How to make API/DLL calls

Daar het maken van een API call in feite het zelfde is als een DLL call, 
is het volgende op allebei van toepassing. Over het algemeen, werkt het oproepen 
van een functie API/DLL als volgt:

1) Open de gewenste DLL
2) Roep de functie of functies op
3) Sluit de DLL af

Gewenste DLL kan worden geopend wanneer het programma begint en kan gesloten worden 
wanneer de programma uitvoering is voltooid, of de DLL kan worden geopend vlak voordat
de functies aan geroepen worden en kan daarna onmiddellijk weer worden gesloten.

De volgende statements/functies zijn beschikbaar voor het maken van API/DLL calls:

OPEN
OPEN "filename.dll" for dll as #handle

	 -Deze vorm van OPEN opent een gewenste DLL zodat een programma functies 
	 daarin kan aanroepen.

Liberty BASIC 3 heeft DLL - handle resolutie zo verbeterd dat als een programma 
bepaalde standaard Windows DLLs niet heeft geopend, en er toch een verwijzing 
naar een gelijksoortige handle plaats vindt  het gewenste effect van de DLL 
tocht verkregen wordt.  Dit zal code besparen voor het openen en  sluiten van DLLs.  
De oude manier werkt nog.  Als een programma een DLL opent, dan moet het worden 
gesloten alvorens het programma beëindigt. 
Als de standaard handles hieronder worden gebruikt, 
dan zou een CLOSE bevel niet moeten worden gegeven.

Hier zijn de default handles.

  #user32
  #kernel32
  #gdi32
  #winmm
  #shell32
  #comdlg32
  #comctl32

CALLDLL
CALLDLL #handle, "function", parm1 as type1[, parm2 as type2, ... ], result as returnType

	-Dit statement roept een benoemde functie in een Geopende DLL aan. 
	De lijst met  parameters geeft informatie aan de functie vertelt 
	het hoe zijn taken uit te voeren.
	See CallDLL.

HWND
HWND(#handle)
	-Deze functie keert met een Windows handle voor de Liberty BASIC #handle terug
 
STRUCT
STRUCT name, field1 as type1 [, field2 as type2, ... ]
	 Het  STRUCT statement bouwt een gespecificeerde structuur die nodig is bij het 
	 maken van sommige API/DLL calls.  Er is een voorbeeld hieronder dat laat zien hoe 
	 een rechthoekig raamwerk wordt gebouwd die vaak bij het maken van Windows API calls 
	 wordt gebruikt.
	 See also:  Using types with STRUCT and CALLDLL

Constants
	Liberty BASIC heeft een bibliotheek van de bepaalde constanten van Windows 
	(_SW_HIDE is er één).  Dit is gelijkwaardig aan de definities die in het windows.h  
	bestand zijn gemaakt dat met de meeste compilers van C wordt geleverd.  
	De manier een constante van Windows in te passen is door de naam van 
	de constante te nemen en een onderstreepteken ervoor het te plaatsen.  
	"_SW_HIDE" is dus het zelfde als de Windows constante "SW_HIDE."

Als Liberty BASIC de waarde van een Constante van Windows niet kent, 
zal het een bericht  produceren "undefined constant" tijdens het compileren van het programma.  
In dat geval, moet de numerieke waarde van die constante van andere bronnen komen.

SAMPLE PROGRAM
Hier zijn een korte test (maar niet een volledig) programma 
die alle bovengenoemde statements/functies gebruikt:

NOMAINWIN

'create the structure winRect
    struct winRect, _
        orgX as long, _
        orgY as long, _
        cornerX as long, _
        cornerY as long

'define sizes
    openingWidth = 600
    expandedHeight = 400

 'open USER32.DLL
    open "user32.dll" for dll as #user

    button #main.showMore, "Hide Me", [hide], UL, 10, 10

    open "An Example" for window as #main
    #main "trapclose [quit]"

'get the window handle for #main (a standard Liberty BASIC window)
    hMain = hwnd(#main)

'call the GetWindowRect API to load the window position/size into winRect
    calldll #user, "GetWindowRect", _
        hMain as long, _
        winRect as struct, _
        result as boolean

'extract the position information out of our struct
    xOrg = winRect.orgX.struct
    yOrg = winRect.orgY.struct

'call the MoveWindow API to resize the window to a predefined size
    calldll #user, "MoveWindow", _
        hMain as long, _
        xOrg as long, _
        yOrg as long, _
        openingWidth as long, _
        expandedHeight as long, _
        1 as boolean, _
        result as boolean


    WAIT

[hide]
'get the window handle to a button in our Liberty BASIC window
    hndl = hwnd(#main.showMore)

'call the ShowWindow API, passing _SW_HIDE to hide the button

    calldll #user, "ShowWindow", _
        hndl as long, _
        _SW_HIDE as long, _
        result as boolean
    WAIT

[quit]
    close #main
    'close USER.DLL
    close #user
    END

In het bovengenoemde voorbeeld, draait het programma drie APIs van USER32.DLL, 
die een standaard dynamic link library van Windows is.


Hier is wat de code doet:


1) creëert de structure winRect
2) opent USER32.DLL
3) haalt de windows handle van #main (een standard Liberty BASIC venster)
4) roept  de GetWindowRect API om de venster position/size in winRect te laden
5) haalt de positie informatie uit de struct
6) calls de MoveWindow API om het venster te resizen naar een voorgedefinieerde maat
7) neemt de window handle van een knop in het Liberty BASIC venster
8) calls de ShowWindow API, en geeft  _SW_HIDE door om de knop te verbergen
9) sluit USER32.DLL af



See also:  CALLDLL,  STRUCT, Using Types with CALLDLL, What are APIs/DLLs?