home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / VISUAL_B / PROGRAMS / WINBASIC / DLL.TXT < prev    next >
Encoding:
Text File  |  1993-01-31  |  7.0 KB  |  207 lines
  1. Winpad.exe Text
  2.  
  3. This file contains information in english and germam
  4. Diese Datei enthΣlt Informationen in Deutsch und Englisch
  5.  
  6.  
  7. DEUTSCH/GERMAN:
  8.  
  9. Aufruf von Prozeduren in DLL's aus Winbasic
  10. ===========================================
  11.  
  12. Externe Prozeduren in Dynamic Link Libraries k÷nnen aufgerufen
  13. werden als wΣren sie WinBasic Subroutines unter Verwendung
  14. folgender Konvention:
  15.  
  16. i% = _DLL.prozedur(...)
  17.  
  18. wobei ... Parameter sind. Um den Aufruf als extern zu kenn-
  19. zeichen und somit von gew÷hnlichen Aufrufen von WinBasic Sub-
  20. routines zu unterscheiden ist das erste Zeichen im Aufruf ein
  21. Unterstrich. Der folgende Name besteht aus zwei Teilen: zu-
  22. nΣchst der Modulname und dann der eigentliche Prozedurname,
  23. abgetrennt durch einen Punkt. Parameter werden wie gew÷hnlich
  24. innerhalb runder Klammern ⁿbergeben.
  25.  
  26. Um Aufrufe an die Windows Module 'user.exe', 'gdi.exe' und
  27. 'kernel.exe' abzusetzen - diese Module enthalten die Funktionen
  28. des Windows SDK - kann der fiktive Name 'Windows' als Modulname
  29. benutzt werden. WinBasic wird die gerufene Prozedur dann in
  30. den genannten drei Modulen suchen. Dies ist komfortabel weil
  31. in der Dokumentation des SDK nirgendwo vermerkt ist in welchem
  32. Modul sich die Prozeduren befinden.
  33.  
  34. Der Return-Wert einer externen Funktion ist immer ein LONG Wert.
  35. WinBasic's automatische Typenwandlung wird eine Anpassung an
  36. jede Variable vornehmen.
  37.  
  38. Die Parameter k÷nnen 'by value' oder 'by reference' mit dem
  39. Schlⁿsselwort VAR ⁿbergeben werden. Lokale Variablen und For-
  40. malparameter in Subroutines sind jedoch nicht als VAR-Parameter
  41. erlaubt!
  42.  
  43. Um 'Strukturen' (C-Jargon) an externe Prozeduren zu ⁿbergeben 
  44. baut man diese als Records auf und ⁿbergibt diese als VAR 
  45. Parameter.
  46.  
  47. Eine besondere Schwierigkeit ist die ▄bergabe von Strings als
  48. Parameter weil BASIC-▄bersetzer Strings als Variablen variabler
  49. LΣnge in einer speziellen Weise behandeln. Um Strings an externe
  50. Prozeduren zu ⁿbergeben mⁿssen die Strings fester LΣnge inner-
  51. halb von Records verwendet werden. Definieren Sie einen
  52. 'RecType' mit nur einen 'Recvar', nΣmlich den String den Sie
  53. ⁿbergeben wollen. Dieser String muss eine ungerade LΣnge haben;
  54. WinBasic wird den String automatisch durch AnhΣngen einer
  55. binΣren Null auf gerade LΣnge bringen. Diese Null wird i. a.
  56. von externen Prozeduren als String-Ende Markierung erwartet.
  57. Sollten Sie eine gerade LΣnge haben mⁿssen, verwenden Sie
  58. eine zweite 'Recvar'-Variable vom Typ INTEGER, diese wird
  59. durch WinBasic zu Null initialisiert und liefert damit die
  60. String-Ende Marke. Im Aufruf der externen Prozedur verwenden
  61. Sie dann den Record als Parameter (nicht den String direkt).
  62.  
  63. Beispiel:
  64.  
  65. RecType R1
  66.   Recvar Str$ 65    'oder Recvar Str$ 64, dummy%
  67. Endrec
  68.  
  69. Record R1 WinText
  70.  
  71. ...
  72.  
  73. REM main program
  74.  
  75. hwnd% = _Windows.GetActiveWindow()    'Handle hWnd% besorgen
  76.  
  77. i% = _Windows.GetWindowText( hwnd%, VAR WinText, 64 )
  78. Print "Window title is "; WinText.Str$
  79. WinText.Str$ = "New title"
  80. i% = _Windows.SetWindowText( hwnd%, VAR WinText )
  81.  
  82.  
  83. Hinweis: fⁿr viele Windows Funktionen mⁿssen Sie ein 'Handle'
  84. zu Ihrem Hauptfenster haben. Man bekommt diese durch den Aufruf
  85. der Prozedur 'GetActiveWindow' beim Programmstart (dann ist
  86. sicher da▀ das eigene Programm das 'aktive' ist) wie im Beispiel
  87. gezeigt.
  88.  
  89. Weitere Beispiele finden Sie im Programm 'Windows.bas' auf der
  90. Diskette.
  91.  
  92. Wenn Sie Prozeduren in anderen DLL's als den Windows Modulen
  93. 'user.exe', 'kernel.exe' und 'gdi.exe' aufrufen wollen mⁿssen
  94. Sie diese DLL durch Aufruf der Windows Prozedur LoadLibrary
  95. explizit laden und nach Gebrauch wieder freigeben, wie z. B.
  96. durch:
  97.  
  98.  
  99. RecType R2
  100.   Recvar Str$ 9
  101. Endrec
  102.  
  103. Record R2 LIBNAME
  104. LIBNAME.Str$ = "Andere.DLL"
  105.  
  106. hlib% = _Windows.LoadLibrary( VAR LIBNAME )
  107. i% = _Andere.Bsp( ... )     'Prozedur Bsp in DLL aufrufen
  108. ...
  109. i% = _Windows.FreeLibrary( hlib% )
  110.  
  111.  
  112. =================================================================
  113.  
  114. ENGLISH:
  115.  
  116. Calling Procedures in DLL's with WinBasic
  117. =========================================
  118.  
  119. External procedures in dynamic link libraries can be called
  120. as though they were WinBasic subroutines using the following
  121. syntax:
  122.  
  123. i% = _DLL.procedure(...)
  124.  
  125. where ... are parameters. To distinguish the call to an external
  126. procedure from a call to an internal WinBasic subroutine the name
  127. starts with an underscore. The name is made up from two parts,
  128. first the module name of the DLL and then the name of the
  129. procedure itself, separated by a point. Any parameters are passed
  130. in a pair of round brackets.
  131.  
  132. To make calls to the Windows modules 'user.exe', 'gdi.exe' and
  133. 'kernel.exe' - which contain the functions in the Windows SDK -
  134. more convenient, the fictitious module name 'Windows' can be used.
  135. WinBasic will then search for the procedure in the three modules
  136. mentioned above. This is convenient because the locations of
  137. the SDK functions is not documented.
  138.  
  139. The return value of an external function is always a LONG value.
  140. WinBasic's automatic type conversion can assign this to any
  141. numerical variable.
  142.  
  143. The parameters can be passed by value or by reference with the VAR
  144. keyword. However, local variables and formal parameters in
  145. subroutines are not allowed as VAR parameters.
  146.  
  147. To pass structures to external procedures build them up as
  148. records and pass them as VAR parameters.
  149.  
  150. There is a difficulty with strings as parameters because BASIC
  151. treats strings as variables of variable length in a special
  152. manner. To pass strings as parameters to external procedures
  153. you must use the fixed-length strings used in RECORDS. To do
  154. this define a 'RecType' with only one 'Recvar': the string you
  155. want to pass. Give the string an odd length; WinBasic will fill
  156. it up to an even length by adding a '0' byte at the end, which
  157. is expected by most DLL-procedures as marking the end of strings.
  158. If you *must* have an even number of bytes, add a second 'Recvar'
  159. of type integer, which is initialized with two '0' bytes by
  160. WinBasic. Define a 'Record' with this 'Rectype'. When calling
  161. the external procedure, use the record as a parameter.
  162.  
  163. Example:
  164.  
  165. RecType R1
  166.   Recvar Str$ 65    'or Recvar Str$ 64, nullbytes%
  167. Endrec
  168.  
  169. Record R1 WinText
  170.  
  171. ...
  172.  
  173. REM main program
  174.  
  175. hwnd% = _Windows.GetActiveWindow()
  176.  
  177. i% = _Windows.GetWindowText( hwnd%, VAR WinText, 64 )
  178. Print "Window title is "; WinText.Str$
  179. WinText.Str$ = "New title"
  180. i% = _Windows.SetWindowText( hwnd%, VAR WinText )
  181.  
  182.  
  183. Hint: for many Windows functions you must have a handle to your
  184. main window. You can get this with the Windows function
  185. 'GetActiveWindow' when your program starts as shown in the
  186. example above.
  187.  
  188. For further examples please look at the program 'Dll.bas'
  189. on the distribution disk.
  190.  
  191. If you are calling procedures in DLLs other than Windows own
  192. 'user.exe', 'kernel.exe' and 'gdi.exe' you must explicitly load
  193. the DLL by calling LoadLibrary and free it when you are finished
  194. using it, as shown below:
  195.  
  196. RecType R2
  197.   Recvar Str$ 9
  198. Endrec
  199.  
  200. Record R2 LIBNAME
  201. LIBNAME.Str$ = "OTHER.DLL"
  202.  
  203. hlib% = _Windows.LoadLibrary( VAR LIBNAME )
  204. i% = _Other.Foo( ... )    'Call a routine in OTHER.DLL
  205. ...
  206. i% = _Windows.FreeLibrary( hlib% )
  207.