Winpad.exe Text

This file contains information in english and germam
Diese Datei enthlt Informationen in Deutsch und Englisch


DEUTSCH/GERMAN:

Aufruf von Prozeduren in DLL's aus Winbasic
===========================================

Externe Prozeduren in Dynamic Link Libraries knnen aufgerufen
werden als wren sie WinBasic Subroutines unter Verwendung
folgender Konvention:

i% = _DLL.prozedur(...)

wobei ... Parameter sind. Um den Aufruf als extern zu kenn-
zeichen und somit von gewhnlichen Aufrufen von WinBasic Sub-
routines zu unterscheiden ist das erste Zeichen im Aufruf ein
Unterstrich. Der folgende Name besteht aus zwei Teilen: zu-
nchst der Modulname und dann der eigentliche Prozedurname,
abgetrennt durch einen Punkt. Parameter werden wie gewhnlich
innerhalb runder Klammern bergeben.

Um Aufrufe an die Windows Module 'user.exe', 'gdi.exe' und
'kernel.exe' abzusetzen - diese Module enthalten die Funktionen
des Windows SDK - kann der fiktive Name 'Windows' als Modulname
benutzt werden. WinBasic wird die gerufene Prozedur dann in
den genannten drei Modulen suchen. Dies ist komfortabel weil
in der Dokumentation des SDK nirgendwo vermerkt ist in welchem
Modul sich die Prozeduren befinden.

Der Return-Wert einer externen Funktion ist immer ein LONG Wert.
WinBasic's automatische Typenwandlung wird eine Anpassung an
jede Variable vornehmen.

Die Parameter knnen 'by value' oder 'by reference' mit dem
Schlsselwort VAR bergeben werden. Lokale Variablen und For-
malparameter in Subroutines sind jedoch nicht als VAR-Parameter
erlaubt!

Um 'Strukturen' (C-Jargon) an externe Prozeduren zu bergeben 
baut man diese als Records auf und bergibt diese als VAR 
Parameter.

Eine besondere Schwierigkeit ist die bergabe von Strings als
Parameter weil BASIC-bersetzer Strings als Variablen variabler
Lnge in einer speziellen Weise behandeln. Um Strings an externe
Prozeduren zu bergeben mssen die Strings fester Lnge inner-
halb von Records verwendet werden. Definieren Sie einen
'RecType' mit nur einen 'Recvar', nmlich den String den Sie
bergeben wollen. Dieser String muss eine ungerade Lnge haben;
WinBasic wird den String automatisch durch Anhngen einer
binren Null auf gerade Lnge bringen. Diese Null wird i. a.
von externen Prozeduren als String-Ende Markierung erwartet.
Sollten Sie eine gerade Lnge haben mssen, verwenden Sie
eine zweite 'Recvar'-Variable vom Typ INTEGER, diese wird
durch WinBasic zu Null initialisiert und liefert damit die
String-Ende Marke. Im Aufruf der externen Prozedur verwenden
Sie dann den Record als Parameter (nicht den String direkt).

Beispiel:

RecType R1
  Recvar Str$ 65	'oder Recvar Str$ 64, dummy%
Endrec

Record R1 WinText

...

REM main program

hwnd% = _Windows.GetActiveWindow()	'Handle hWnd% besorgen

i% = _Windows.GetWindowText( hwnd%, VAR WinText, 64 )
Print "Window title is "; WinText.Str$
WinText.Str$ = "New title"
i% = _Windows.SetWindowText( hwnd%, VAR WinText )


Hinweis: fr viele Windows Funktionen mssen Sie ein 'Handle'
zu Ihrem Hauptfenster haben. Man bekommt diese durch den Aufruf
der Prozedur 'GetActiveWindow' beim Programmstart (dann ist
sicher da das eigene Programm das 'aktive' ist) wie im Beispiel
gezeigt.

Weitere Beispiele finden Sie im Programm 'Windows.bas' auf der
Diskette.

Wenn Sie Prozeduren in anderen DLL's als den Windows Modulen
'user.exe', 'kernel.exe' und 'gdi.exe' aufrufen wollen mssen
Sie diese DLL durch Aufruf der Windows Prozedur LoadLibrary
explizit laden und nach Gebrauch wieder freigeben, wie z. B.
durch:


RecType R2
  Recvar Str$ 9
Endrec

Record R2 LIBNAME
LIBNAME.Str$ = "Andere.DLL"

hlib% = _Windows.LoadLibrary( VAR LIBNAME )
i% = _Andere.Bsp( ... ) 	'Prozedur Bsp in DLL aufrufen
...
i% = _Windows.FreeLibrary( hlib% )


=================================================================

ENGLISH:

Calling Procedures in DLL's with WinBasic
=========================================

External procedures in dynamic link libraries can be called
as though they were WinBasic subroutines using the following
syntax:

i% = _DLL.procedure(...)

where ... are parameters. To distinguish the call to an external
procedure from a call to an internal WinBasic subroutine the name
starts with an underscore. The name is made up from two parts,
first the module name of the DLL and then the name of the
procedure itself, separated by a point. Any parameters are passed
in a pair of round brackets.

To make calls to the Windows modules 'user.exe', 'gdi.exe' and
'kernel.exe' - which contain the functions in the Windows SDK -
more convenient, the fictitious module name 'Windows' can be used.
WinBasic will then search for the procedure in the three modules
mentioned above. This is convenient because the locations of
the SDK functions is not documented.

The return value of an external function is always a LONG value.
WinBasic's automatic type conversion can assign this to any
numerical variable.

The parameters can be passed by value or by reference with the VAR
keyword. However, local variables and formal parameters in
subroutines are not allowed as VAR parameters.

To pass structures to external procedures build them up as
records and pass them as VAR parameters.

There is a difficulty with strings as parameters because BASIC
treats strings as variables of variable length in a special
manner. To pass strings as parameters to external procedures
you must use the fixed-length strings used in RECORDS. To do
this define a 'RecType' with only one 'Recvar': the string you
want to pass. Give the string an odd length; WinBasic will fill
it up to an even length by adding a '0' byte at the end, which
is expected by most DLL-procedures as marking the end of strings.
If you *must* have an even number of bytes, add a second 'Recvar'
of type integer, which is initialized with two '0' bytes by
WinBasic. Define a 'Record' with this 'Rectype'. When calling
the external procedure, use the record as a parameter.

Example:

RecType R1
  Recvar Str$ 65	'or Recvar Str$ 64, nullbytes%
Endrec

Record R1 WinText

...

REM main program

hwnd% = _Windows.GetActiveWindow()

i% = _Windows.GetWindowText( hwnd%, VAR WinText, 64 )
Print "Window title is "; WinText.Str$
WinText.Str$ = "New title"
i% = _Windows.SetWindowText( hwnd%, VAR WinText )


Hint: for many Windows functions you must have a handle to your
main window. You can get this with the Windows function
'GetActiveWindow' when your program starts as shown in the
example above.

For further examples please look at the program 'Dll.bas'
on the distribution disk.

If you are calling procedures in DLLs other than Windows own
'user.exe', 'kernel.exe' and 'gdi.exe' you must explicitly load
the DLL by calling LoadLibrary and free it when you are finished
using it, as shown below:

RecType R2
  Recvar Str$ 9
Endrec

Record R2 LIBNAME
LIBNAME.Str$ = "OTHER.DLL"

hlib% = _Windows.LoadLibrary( VAR LIBNAME )
i% = _Other.Foo( ... )	'Call a routine in OTHER.DLL
...
i% = _Windows.FreeLibrary( hlib% )
