home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / RCT1,62.DMS / in.adf / NEUHEITEN < prev    next >
Encoding:
Text File  |  1993-09-06  |  44.6 KB  |  1,730 lines
  1. /**********************************************************************/
  2. /*      RCT 1.62 September 93                                         */
  3. /*                                                                    */
  4. /*      RCT Info  Neuerungen seit der Version 1.51 vom Mai 92         */
  5. /*                                                                    */
  6. /*      - Gadgets werden nun direkt im 2.0 Look angezeigt.            */
  7. /*                                                                    */
  8. /*      - neuer, File Requester mit folgenden Features                */
  9. /*        - reentrant in einer Library enthalten.                     */
  10. /*        - tastatursteuerbar                                         */
  11. /*        - als Vorschau auf die Version 2.0 von R.C.T. größen und    */
  12. /*          Fontvariabel.                                             */
  13. /*        - sehr leicht aus allen Programmiersprachen z.B. GFA-Basic  */
  14. /*          ( siehe Programm  FILER_GFABAS.LST ) aufrufbar.           */
  15. /*                                                                    */
  16. /*                                                                    */
  17. /*      - RCT_TO_ASCII wurde in RCT2ASC umbenannt und komplett neu    */
  18. /*        gestaltet                                                   */
  19. /*                                                                    */
  20. /*      - es kann jetzt Source-Code für die Programmiersprachen       */
  21. /*        AMIGA-, GFA-, HiSoft-Basic,                                 */
  22. /*        Lattice-, Aztec-C,                                          */
  23. /*        Kick-Ass, Aztec-Ass, GfaAssembler,                          */
  24. /*        Kick-Pascal                                                 */
  25. /*        Modula M2 generiert werden.                                 */
  26. /*        MAXON C++ in Vorbereitung                                   */
  27. /*                                                                    */
  28. /**********************************************************************/
  29.  
  30.  
  31. Wichtig: Damit R.C.T. überhaupt gestartet werden kann, müssen Sie die 
  32. RCT.LIBRARY aus dem Verzeichnis LIBRARIES auf der Diskette in ihren 
  33. Libs-Ordner kopieren. Klicken Sie dazu das Ikon RCTLib-Install 
  34. vor dem ersten Starten des Programmes an.
  35.  
  36. Durch die Änderung des R.C.T. auf den 3D-Look von 2.0 stimmen leider
  37. die Abbildungen im Handbuch nicht mehr mit denen des Programmes überein.
  38. Einzelnen Funktionen innerhalb der Requester haben sich allerdings nur
  39. im Text-Requester und im Füllmuster-Requester geändert.
  40. Der File-Requester hatte schon in der Version 1.2 ein anders Aussehen, was
  41. in der neuen Version noch einmal gänzlich geändert wurde.
  42.  
  43. Die Seiten 5 "Lieferumfang", 9 "Der Datei-Auswahl-Requester" und 45
  44. "Der Source-Code-Generator" stimmen mit der aktuellen Programmversion nicht
  45. mehr überein und können ignoriert werden. Im Folgenden werden Änderungen
  46. und Neuerungen beschrieben.
  47.  
  48. Lieferumfang:
  49.  
  50. Wurzelverzeichnis
  51.  
  52.  RCT             -> Das Hauptprogramm
  53.  RCTRESOURCE.RCT -> Die Benutzeroberfläche von RCT
  54.  RCTLIB-INSTALL  -> Batch zum kopieren der RCT.LIBRARY
  55.  NEUHEITEN       -> Der Text den Sie gerade lesen
  56.  
  57. Ordner Source
  58.  
  59.  NEURCTTOASC.RCT -> Die Benutzeroberfläche zum Programm
  60.  
  61. Ordner Libs
  62.  
  63.  FileReq.mod     -> File-Requester einbindung in Modula 2
  64.  rct.bmap        -> Definitionen für AMIGA-Basic
  65.  rct.def     -> Definitionen für Modula 2
  66.  rct.library     -> Funktionsbibliothek
  67.  rct.sym         -> Symbole für Modula 2
  68.  rctdef.h        -> includes für C-Programme
  69.  rctlibrary.lib  -> includes für Pascal Programme
  70.  rctneu.def      ->
  71.  rct_amigabasic.vorsp -> Programm vorbereitung für Amiga-Basic
  72.  rct_bas.fd      -> FD-Datei zur Funktionsbibliothek
  73.  rct_gfabas.lst  -> Funktionseinbindungen für GFA-Basic
  74.  rct_lnk.asm     -> Funktionseinbindugen für C und Assembler
  75.  
  76.  
  77. Der Ordner Demos enthält Beispielprogramme im Source-Code
  78. für verschiedene Programmiersprachen.
  79.  
  80.  
  81. Neues im R.C.T.
  82.  
  83. Die wichtigste Änderung ist die, daß jetzt auch das RCT von der Möglichkeit
  84. den Oberflächencode während der Laufzeit nachzuladen gebrauch macht.
  85. Leider haben sich im Zuge der Änderung alle Requester geändert, und stimmen
  86. nun nicht mehr mit den im Handbuch abgebildeten überein.
  87. Die Umstellung hatte zur Folge, daß ich weniger Daten in meinem C-Source
  88. bekam und dadurch auf das Small-Code-Data-Model umsteigen konnte, was
  89. ungefähr einen um 100 KByte kürzeren Programmcode ausmachte.
  90.  
  91. Für alle Funktionen, die die Manipulation der Oberfläche betreffen, werden
  92. Library-Funktionen aus der RCT.Library aufgerufen.
  93.  
  94. In der Objektauswahl haben sie lediglich die Menüleisten geändert und sind
  95. nun entsprechend den Commodore Richtlinien aufgebaut.
  96.  
  97. Der Menüpunkt Ausgabe kam hinzu. Mit diesem Menüpunkt kann festgelegt
  98. werden, für welche Programmiersprache eine Include-Datei erzeugt werden
  99. soll. In der Include-Datei sind die Konstantendeklarationen für die
  100. REQUESTER-, GADGET-, und MENU-IDs enthalten. Die Einstellungen unter diesem
  101. Menüpunkt könnenim RCTSETUP gespeichert werden, so daß nach einem Neustart
  102. von R.C.T. die Einstellung weiterhin vorhanden ist.
  103.  
  104. Das RCTSETUP wird gespeichert in dem Sie den "RCT Setup Requester"
  105. ( Menüpunkt "OBJEKTBEARBEITUNG" -> "R.C.T. - Setup") mit OK bestädigen.
  106.  
  107.  
  108. Im Requester-Editor hat sich einiges getan.
  109.  
  110. - Automatische Border
  111.  
  112.   In der alten Version mußte man, sobald ein Gadget vergrößert wurde, die
  113.   Border des Gadgets selbst nachbearbeiten.
  114.  
  115.   Jetzt passen sie sich automatisch den neuen Gadget-Ausmaßen an.
  116.  
  117. - Neue Tastaturbelegung
  118.  
  119.   Bei gedrückter Taste "T" und Anwahl eines Requestertextes mir der Maus,
  120.     wird nur der Requestertext ausgewählt obwohl er eventuell unter einem
  121.     Gadget steht und normal nicht angewählt werden kann.
  122.  
  123.     Das gleiche ist auch mit Border möglich, wenn die Taste "B" gedrückt wird.
  124.     Bei Border-Objekten muß allerdings einer der Eckpunkte angeklickt werden.
  125.  
  126. - Flexiblere Fontverwaltung
  127.  
  128.     In der letzten Version war es nicht möglich, einen mit dem R.C.T.
  129.     generierten Requester, in dem von den Systemfonts abweichende Fonts
  130.     (DISKFONTS) enthalten waren auf einem anderen Computersstem mit dem
  131.      R.C.T. anzuzeigen, wenn die Fontliste im FONTS:-Verzeichnis anders
  132.     sortiert war.
  133.     Dies ist nun behoben. Wird beim Laden ein verwendeter Font nicht
  134.     gefunden, erscheint ein Alert der mit dem Fontnamen draufhinweist.
  135.   Für alle Objekte die den nicht gefundenen Font benutzen wollten, wird
  136.     dann der kleinste Systemresidente Fonts eingestellt (normalerweise
  137.     TOPAZ 8).
  138.  
  139.     Die allermeisten Neuerungen hat allerdings die Library erfahren!
  140.   Sie ist aber dennoch voll kompatibel zur Alten.
  141.  
  142.  
  143.  
  144. Der Source-Code Generator
  145.  
  146. Der Source-Code Generator ist nicht in das R.C.T. integriert sondern ist
  147. ein eigenständiges Programm. Sie finden es auf der Originaldiskette im
  148. Verzeichnis "SOURCE". Nach dem Start des Programmes RCT2ASC wird ein Requester
  149. innerhalb eines Fensters auf dem Workbenchscreen angezeigt.
  150.  
  151. Für folgende Programmiersprachen kann Source-Code generiert werden:
  152.  
  153. GFA-BASIC
  154. AMIGA-BASIC
  155. HISOFT-BASIC
  156. AZTEC-C
  157. LATTICE-C (SAS-C)
  158. AZTEC-ASSEMBLER
  159. HISOFT-ASSEMBLER
  160. KICK-ASSEMBLER
  161. KICK-C++ (noch im Vorbereitung. Wird im ersten Quartal `92 erwartet)
  162. KICK-PASCAL
  163. MODULA M2-AMIGA
  164.  
  165. Sie könne zwischen verschiedenen Möglichkeiten der Source-Code erzeugung
  166. wählen. Die einfachste ist es, sich den puren Datencode erzeugen zu lassen.
  167. Dabei wird die vom R.C.T. gespeicherte Datei direkt in Date-Source
  168. umgewandelt.
  169.  
  170. Möchten Sie jedoch einen fertigen Programmrumpf generieren, so daß das
  171. Ergebnis direkt compiliert oder intepretiert werden kann, muß die Option
  172. "mit Programmrumpf" eingeschaltet sein. Dabei hat man weiter
  173. Auswahlmöglichkeiten.
  174.  
  175.  
  176. OHNE LIBRARY
  177.  
  178. Voreingestellt ist die Option "ohne Library". Mit dieser Einstellung wird
  179. Programmcode generiert, der rein auf die Systemlibraries ausgelegt ist.
  180.  
  181. Das heist, zur Anzeige eines Requester wird zuvor ein Window geöffnet,
  182. dessen Source-Code (NewWindow-Struktur) ebenfalls erzeugt wird usw.
  183.  
  184.  
  185. MIT LINKER-LIBRARY
  186. MIT AMIGA-LIBRARY
  187.  
  188. Ist einer der beiden Optionen eingeschaltet, wird auf die Funktionen der
  189. R.C.T.-Library zurückgegriffen. Der Unterschied zwischen den beiden
  190. Optionen ist, daß bei eingeschalteter AMIGA-Library im Hauptprogramm die
  191. RCT.LIBRAY geöffnet wird. Dies ist nicht notwendig, wenn die
  192. Linker-Library benutzt wird, da die RCT-Funktionen direkt an das Programm
  193. gelinkt werden.
  194.  
  195. Bei eingeschalteter Linker- oder Amiga-Library Option besteht zusätzlich
  196. die Möglichkeit die Option "Resource nachladen" einzuschalten. Hierbei wird
  197. kein Daten-Source erzeugt sondern reiner Programmcode, in dem die Funktionen
  198. der RCT.LIBRARY genutzt werden um die mit dem R.C.T. erzeugt Obeflächendaten
  199. nachzuladen.
  200.  
  201. Bevor nun mit der Codeerzeugung begonnen werden kann, muß eine R.C.T.-Datei
  202. ausgewählt werden. Mit Klick auf den Button "Datei Auswahl" erscheint eine
  203. File-Requester, mit dessen Hilfe Sie die gewünschte Datei auswählen können.
  204.  
  205. Der Name der gewählten Datei wird im darunter stehenden String-Gadget
  206. angezeigt.
  207.  
  208. KONVERTIEREN
  209.  
  210. Sie können die Konvertierung mit Klick auf das Gadget "Starte Konvertierung"
  211. starten.
  212.  
  213. Die erzeugt Datei wird in das Verzeichnis geschrieben, aus dem die R.C.T.-Datei
  214. gewählt wurde.
  215.  
  216.  
  217.  
  218.  
  219. Die RCT-Library Version 1.5
  220.  
  221. Die RCT-Library enthält Funktionen zum Laden und Verwalten der mit R.C.T.
  222. erstellten Benutzeroberfläche. Sie ist komplett reentrant und enthält
  223. außerdem einen sehr komfortablen File-Requester und einen einfach
  224. aufrufbaren System-Alarm-Requester.
  225. Im Libraries-Verzeichnis der Diskette ist eine ".FD"-Datei enthalten,
  226. in der die Library Offsets und Funktionsparamter für BASIC und C enthalten
  227. sind. Anhand der FD-Datei können Sie die Libraryeinbindung für andere
  228. Progammiersprachen einfach nachbilden. In der R.C.T.-Endversion sind neben
  229. allen Include-Dateien auch Linker-Librarys für Aztec- und Lattice-Compiler
  230. enthalten.
  231.  
  232.  
  233. Die Versionsnummer der neue Library ist 15 mit der Revisionsnummer 7.
  234.  
  235. Sie sollten also beim öffnen immer die Library mit der Versionsnummer 15
  236. verlangen.
  237.  
  238.  
  239.  
  240. NAME
  241.  
  242.              rctload
  243.  
  244. SYNOPSIS
  245.  
  246.       rctadress = rctload( pfad)
  247.                              A0
  248.  
  249.       APTR rctadress;
  250.       char *pfad;
  251.  
  252.  
  253. ERKLÄRUNG
  254.  
  255. Lädt die im String angegebene R.C.T.-Datei in den Speicher und liefert deren
  256. Adresse. Im String sollte nur der Dateiname stehen, da sich die Datei, bei
  257. ganzen Pfadangaben immer im betreffenden Pfad befinden muß.
  258. Es ist vielmehr sinnvoller, nur den Dateinamen anzugeben, und bevor das
  259. Programm gestartet wird, mit "CD" einen Pfad zu legen. Das Pfadproblem ist nur
  260. dann vorhanden, wenn ein Programm aus dem CLI gestartet wird. Startet man ein
  261. Programm von der Workbench, wird der aktuelle Pfad automatisch auf den gelegt,
  262. von dem aus das Programm gestartet wird.
  263.  
  264. ÄNDERUNGEN
  265. Kann die angegebene Datei nicht gefunden werden, wird versucht, diese von
  266. Laufwerk "RCT:" zu laden. Dies bedeutet, daß Sie ein Verzeichnis anlegen können
  267. in das Sie alle RCT-Dateien kopieren und am besten in der Startup-Sequence das
  268. betreffende Verzeichnis mit "ASSIGN RCT: Verzeichnis" anmelden sollten.
  269. In den Requester-Flags wird das Flag NOISYREQ generell gesetzt. Dadurch ist es
  270. möglich auch RAWKEY-Codes bei aktivem Requester zu empfangen. Man muss zum
  271. Empfangen allerdings die Message-Funktion waitall() verwenden. Mit reqwait
  272. werden nur GADGETDOWN, GADGETUP und MOUSEBUTTON Messages geliefert.
  273.  
  274. RÜCKGABEN
  275.  
  276. Zurückgeliefert wird eine Adresse auf die geladenen Datei, die jeder anderen
  277. RCT-Library-Funktion, die aufgerufen wird, übergeben werden muß.
  278.  
  279. SIEHE
  280.  
  281. rctfree
  282.  
  283. BUGS
  284.  
  285. Fehler mit DISKFONTS. Wird ein gewünschter Diskfont nicht gefunden, wird als
  286. default immer der TOPAZ 8 Font genommen.
  287.  
  288.  
  289. ----------------------------------------------------------------
  290.  
  291. NAME
  292.  
  293.              rctfree
  294.  
  295. SYNOPSIS
  296.  
  297.       Boolean = rctfree( rctadress)
  298.                                     A0
  299.       APTR rctadress;
  300.  
  301. ERKLÄRUNG
  302.  
  303. Gibt den durch die Funktion rctload() reservierten Speicherplatz wieder frei.
  304. Dies sollte am Ende jedes Programmes oder wenn eine
  305. andere RCT-Datei geladen wird, gemacht werden.
  306.  
  307. Wurde die Funktion ausgeführt, führt jeder weitere Zugriff mit den
  308. RCT-Library-Funktionen auf die freigegebene RCT-Datei zu einem Systemabsturz.
  309.  
  310. RÜCKGABEN
  311.  
  312. Kann ignoriert werden.
  313.  
  314.  
  315. ----------------------------------------------------------------
  316.  
  317. NAME
  318.  
  319.              rctaddr
  320.  
  321. SYNOPSIS
  322.  
  323.       addr = rctaddr( rctadress, art, id)
  324.                                 A0       D0     D1
  325.  
  326.       struct Requester *addr; oder struct Menu *addr;
  327.       APTR rctadress;
  328.       SHORT art;
  329.       SHORT id;
  330.  
  331. ERKLÄRUNG
  332.  
  333. Ermittelt die Adresse von Requester oder Menüleisten. Die Funktion muß vor dem
  334. Anzeigen von Requester oder Setzen von Menüleisten ausgeführt werden. Je nach
  335. Art wird die Speicheradresse eines Requesters (art = 0) oder die
  336. Speicheradresse einer Menüleiste (art > 0) zurückgeliefert. Die id der Objekte
  337. wird beim Speichern der RCT-Datei in einer Include-Datei abgelegt. Die Endung
  338. des Dateinamens unterscheidet sich je nach Programmierspracheneinstellung im
  339. R.C.T.
  340. Ist die der Funktion übergebene id zu groß, wird NULL zurückgeliefert.
  341.  
  342. RÜCKGABE
  343.  
  344. Ist art gleich 0 wird die Adresse des durch id definierten Requester und bei
  345. art größer 0 die Adresse der betreffenden Menüleiste zurückgeliefert.
  346.  
  347.  
  348. ----------------------------------------------------------------
  349.  
  350. NAME
  351.  
  352.              reqcenter
  353.  
  354. SYNOPSIS
  355.  
  356.       Boolean = reqcenter( rctadress, requester, window)
  357.                                       A0             A1          A2
  358.  
  359.       APRT rctadress;
  360.       struct Requester *requester;
  361.       struct Window *window;
  362.  
  363. ERKLÄRUNG
  364.  
  365. Zentriert den angegebenen Requester innerhalb der Ausmaße des angegebenen
  366. Windows. Ist der Requester bereits angezeigt, hat dies keine Auswirkung auf die
  367. Position des Requesters. Erst bei erneutem Anzeigen wird die Position neu
  368. gesetzt. Diese Funktion sollte deshalb vor dem Zeichnen des Requesters
  369. aufgerufen werden.
  370.  
  371. RÜCKGABE
  372.  
  373. Bei Erfolg TRUE andernfalls FALSE wobei dann eine der drei anzugebenden
  374. Adressen nicht initialisiert ist.
  375.  
  376.  
  377. ----------------------------------------------------------------
  378.  
  379. NAME
  380.  
  381.              reqdraw
  382.  
  383. SYNOPSIS
  384.  
  385.       Boolean = reqdraw( rctadress, requester, window)
  386.                                     A0           A1            A2
  387.  
  388.       APTR rctadress;
  389.       struct Requester *requester;
  390.       struct Window *window;
  391.  
  392. ERKLÄRUNG
  393.  
  394. Zeichnet den angegebenen Requester in das angegebene Window. Das Fenster sollte
  395. mindestens so groß wie der Requester sein.
  396.  
  397. RÜCKGABE
  398.  
  399. Ist nicht genügend CHIP-Speicher vorhanden, wird FALSE
  400. zurückgeliefert, andernfalls TRUE.
  401.  
  402. HINWEIS
  403.  
  404. Wird für ein Gadget innerhalb des Requesters das Flag ENDGADGET definiert, wird
  405. der Requester durch Inuition automatisch ge-
  406. schlossen, sobald man das Gadget anklick. In diesem Fall ist es nicht mehr
  407. möglich, den Requester mit der Funktion reqend() zu schließen.
  408.  
  409.  
  410.  
  411. ----------------------------------------------------------------
  412.  
  413. NAME
  414.  
  415.              reqdrawwindow
  416.  
  417. SYNOPSIS
  418.  
  419.       window = reqdrawwindow( rctadress, requester, screen, title)
  420.                                           A0             A1          A2         A3
  421.  
  422.       struct Window *window;
  423.       APTR rctadress;
  424.       struct Requester *requester;
  425.       struct Screen *screen;
  426.       char *title;
  427.  
  428. ERKLÄRUNG
  429.  
  430. Öffnet ein Window in der Größe des angegebenen Requesters und zeigt diesen
  431. darin an. Das Window ist verschiebbar und kann in den Vorder- oder Hintergrund
  432. geklickt werden. Ohne Angabe einer Screenadresse wird das Window auf dem
  433. Workbenchscreen geöffnet. Beim Schließen des Requesters mit der Funktion
  434. reqend() wird auch das Window geschlossen.
  435.  
  436. RÜCKGABE
  437.  
  438. Konnte die Funktion erfolgreich ausgeführt werden, wird die Adresse des Windows
  439. zurückgeliefert, andernfalls NULL.
  440.  
  441. HINWEIS
  442.  
  443. Wird für ein Gadget innerhalb des Requesters das Flag ENDGADGET definiert, wird
  444. der Requester durch Inuition automatisch ge-
  445. schlossen, sobald man das Gadget anklick. In diesem Fall ist es nicht mehr
  446. möglich, den Requester mit der Funktion reqend() zu schließen. Man muß dann das
  447. Window selbst schließen.
  448.  
  449.  
  450. ----------------------------------------------------------------
  451.  
  452. NAME
  453.  
  454.              reqwait
  455.  
  456. SYNOPSIS
  457.  
  458.       id = reqwait( rctadress, requester, &messageart)
  459.  
  460.       SHORT id;
  461.       APTR rctadress;
  462.       struct Requester *requester;
  463.       ULONG messageart;
  464.  
  465. ERKLÄRUNG
  466.  
  467. Wartet auf Nachrichten, die auftreten, wenn mit der Maus Gadgets innerhalb des
  468. angegebenen Requesters angeklickt werden.
  469. RÜCKGABEN
  470.  
  471. Zurückgeliefert wird die ID-Nummer des angeklickten Gadgets und in messageart,
  472. ob das Gadget gedrückt (GADGETDOWN) oder losgelassen wurde (GADGETUP). Da die
  473. Nachricht GADGETUP nur dann geliefert wird, wenn man den Mausebutton über dem
  474. Gadget losläßt, würde man keine Nachricht erhalten, wenn der Mausbutton
  475. außerhalb des Gadgets losgelassen wird. In diesem Fall liefert die Funktion in
  476. messageart eine MOUSEBUTTON Nachricht. Dabei muß nicht ausgewertet werden, ob
  477. es sich um SELECTDOWN oder SELECTUP handelt, da diese Nachricht nur bei
  478. SELECTUP geliefert wird.
  479.  
  480.  
  481. ----------------------------------------------------------------
  482.  
  483. NAME
  484.  
  485.              getreqstruct
  486.  
  487. SYNOPSIS
  488.  
  489.       wert = getreqstruct( rctadress, requester, item)
  490.                                         A0          A1         D0
  491.  
  492.       VOID wert;
  493.       APTR rctadress;
  494.       struct Requester *requster;
  495.       SHORT item;
  496.  
  497. ERKLÄRUNG
  498.  
  499. Liefert den Wert des angegebenen Requester-Strukturteils.
  500.  
  501. Folgende Werte kann item annehmen:
  502.  
  503.       item = 0    -> struct Requester *OlderRequest
  504.       item = 1    -> LeftEdge
  505.       item = 2    -> TopEdge
  506.       item = 3    -> Width
  507.       item = 4    -> Height
  508.       item = 5    -> RelLeft
  509.       item = 6    -> RelTop
  510.       item = 7    -> struct Gadget *ReqGadget
  511.       item = 8    -> struct Border *ReqBorder
  512.       item = 9    -> struct InuiText *ReqText
  513.       item = 10 -> Flags
  514.       item = 11 -> BackFill
  515.       item = 12 -> struct Layer *ReqLayer
  516.       item = 13 -> struct BitMap *ImageBMap
  517.       item = 14 -> struct Window * RWindow
  518.  
  519.  
  520. ----------------------------------------------------------------
  521.  
  522. NAME
  523.  
  524.              setreqstruct
  525.  
  526. SYNOPSIS
  527.  
  528.       Boolean = setreqstruct( rctadress, requester, item, wert)
  529.                                           A0              A1         D0     D1
  530.   APTR rctadress;
  531.       struct Requester *requester;
  532.       SHORT item;
  533.       SHORT wert;
  534.  
  535. ERKLÄRUNG
  536.  
  537. Setzt den in item angegebenen Struturteil der Requester-
  538. Struktur auf den
  539. in wert angegebenen Wert.
  540.  
  541. Folgende Werte kann item annehmen:
  542.  
  543.     item = 1 -> LeftEdge
  544.     item = 2 -> TopEdge
  545.     item = 3 -> Width
  546.     item = 4 -> Height
  547.     item = 5 -> RelLeft
  548.     item = 6 -> RelTop
  549.     item = 7 -> Flags
  550.     item = 8 -> BackFill
  551.     Ist der Requester angezeigt, verändert sich nichts an seinem
  552. Aussehen. Erst wenn er erneut angezeigt wird, wird eine Ver~
  553. änderung sichtbar.
  554.  
  555. ----------------------------------------------------------------
  556.  
  557. NAME
  558.  
  559.              setreqtext
  560.  
  561. SYNOPSIS
  562.  
  563.       Boolean = setreqtext( rctadress, requester, id, stringadr)
  564.                                         A0           A1         D0      A2
  565.   APTR rctadress;
  566.       struct Requester *requester;
  567.       SHORT id;
  568.       char *stringadr;
  569.  
  570. ERKLÄRUNG
  571.  
  572. Setzt einen neuen Textstring in eine Requestertext. Ist der Requester angezeigt
  573. wird das Textfeld neugezeichnet, so daß der neue Text direkt sichtbar wird.
  574.  
  575.  
  576. ----------------------------------------------------------------
  577.  
  578. NAME
  579.  getreqtext
  580.  
  581. SYNOPSIS
  582.  
  583.       stringadr = getreqtext( rctadress, requester, id)
  584.                                           A0             A1        D0
  585.     char *stringadr;
  586.       APTR rctadress;
  587.       struct Requester *requester;
  588.       SHORT id;
  589.  
  590. ERKLÄRUNG
  591.  
  592. Liefert die Adresse des Textstrings des angegebenen Requester~
  593. textes. In GFA-Basic wird ein Basic-String zurückgeliefert.
  594.  
  595.  
  596. ----------------------------------------------------------------
  597.  
  598. NAME
  599.  
  600.              gettextstruct
  601.  
  602. SYNOPSIS
  603.  
  604.       wert = gettextstruct( rctadress, requester, id, item)
  605.                                         A0           A1         D0    D1
  606.   VOID wert;
  607.       APTR rctadress;
  608.       struct Requester *requester;
  609.       SHORT id;
  610.       SHORT item;
  611.  
  612. ERKLÄRUNG
  613.  
  614. Ermittelt den Wert des in item angegebenen Strukturteils der IntuiTextstruktur.
  615. Item kann folgende Werte annehmen:
  616.  
  617.   item = 0 -> FrontPen
  618.   item = 1 -> BackPen
  619.   item = 2 -> DrawMode
  620.   item = 3 -> LeftEdge
  621.   item = 4 -> TopEdge
  622.   item = 5 -> struct TextAttr *ITextFont
  623.   item = 6 -> Adresse der Textstrings
  624.   item = 7 -> Adresse des nächsten Requester-Textes
  625.  
  626.  
  627. ----------------------------------------------------------------
  628.  
  629.  
  630. NAME
  631.  
  632.              settextstruct
  633.  
  634. SYNOPSIS
  635.  
  636.       Boolean = settextstruct( rctadress, requester, id, item, wert)
  637.                                             A0           A1         D0    D1     D2
  638.   APTR rctadress;
  639.       struct Requester *requester;
  640.       SHORT id;
  641.       SHORT item;
  642.       SHORT wert;
  643.  
  644. ERKLÄRUNG
  645.  
  646. Schreibt den in wert angegebenen Wert in den in item angebenen Strukturteil der
  647. Intuitext Struktur eines Requestertextes.
  648.  
  649. Item kann folgende Werte annehmen:
  650.  
  651.   item = 0 -> FrontPen
  652.   item = 1 -> BackPen
  653.   item = 2 -> DrawMode
  654.   item = 3 -> LeftEdge
  655.   item = 4 -> TopEdge
  656.  
  657.  
  658. ----------------------------------------------------------------
  659. NAME
  660.  
  661.              setgadtext
  662.  
  663. SYNOPSIS
  664.  
  665.       Boolean = setgadtext( rctadress, requester, id, stringadr)
  666.                                          A0          A1         D0      A2
  667.   APTR rctadress;
  668.       struct Requester *requester;
  669.       SHORT id;
  670.       char *stringadress;
  671.  
  672. ERKLÄRUNG
  673.  
  674. Setzt anstelle des Gadgettextes einen neuen Textstring ein.
  675. Ist der Requester auf dem Bildschirm angezeigt, wird das Gadget gleichzeitig
  676. neu gezeichnet, so daß der neue Text direkt sichtbar wird.
  677.  
  678.  
  679. ----------------------------------------------------------------
  680.  
  681. NAME
  682.  
  683.              getgadtext
  684.  
  685. SYNOPSIS
  686.  
  687.       stringadr = getgadtext( rctadress, requester , id)
  688.                                           A0             A1         D0
  689.  
  690.       APTR rctadress;
  691.       struct Requester *requester;
  692.       short id;
  693.  
  694. ERKLÄRUNG
  695.  
  696. Ermittelt die Adresse des Gadgettexts der im Gadget mit der Objetnummer id
  697. gesetzt ist. In GFA-Basic wird ein Basic-String zurückgeliefert.
  698.  
  699.  
  700. ----------------------------------------------------------------
  701.  
  702. NAME
  703.  
  704.              getgadstruct
  705.  
  706. SYNOPSIS
  707.  
  708.       wert = getgadstruct( rctadress, requester, id, item)
  709.                                       A0              A1        D0   D1
  710.  void wert;
  711.       APTR rctadress;
  712.       struct Requester *requester;
  713.       SHORT id;
  714.       SHORT item;
  715.  
  716. ERKLÄRUNG
  717.  
  718. Ermittelt den Wert des Strukturteils item der Gadget Struktur des in der
  719. Objektnummer id angegebenen Gadgets.
  720.  
  721. item kann folgende Werte annehmen:
  722.  
  723.     item = 0 -> Adresse der Gadget-Struktur
  724.     item = 1 -> struct Gadget *NextGadget
  725.     item = 2 -> LeftEdge
  726.     item = 3 -> TopEdge
  727.     item = 4 -> Width
  728.     item = 5 -> Height
  729.     item = 6 -> Flags
  730.     item = 7 -> Activation
  731.     item = 8 -> GadgetType
  732.     item = 9 -> APTR GadgetRender
  733.     item = 10 -> APTR SelectRender
  734.     item = 11-> struct IntuiText *GadgetText
  735.     item = 12-> MutualExclude
  736.     item = 13-> APTR SpecialInfo
  737.     item = 14-> Gadgetid
  738.     item = 15-> APTR UserData
  739.  
  740. ----------------------------------------------------------------
  741.  
  742. NAME
  743.  
  744.              setgadstruct
  745.  
  746. SYNOPSIS
  747.  
  748.       Boolean = setgadstruct( rctadress, requester, id, item, wert)
  749.                                             A0           A1        D0   D1      D2
  750.       APTR rctadress;
  751.       struct Requester *requester;
  752.       SHORT id;
  753.       SHORT item;
  754.       void  wert
  755.  
  756. ERKLÄRUNG
  757.  
  758. Schreibt in das in item angegebene Strukturteil der Gadget Struktur
  759. den Wert wert.
  760.  
  761. item kann folgende Werte annehmen:
  762.  
  763.     item = 1 -> LeftEdge
  764.     item = 2 -> TopEdge
  765.     item = 3 -> Width
  766.     item = 4 -> Height
  767.     item = 5 -> Flags
  768.     item = 6 -> Activation
  769.     item = 7 -> GadgetType
  770.     item = 8 -> MutualExclude
  771.     item = 9 -> Gadgetid
  772.     item = 10-> APTR UserData
  773.  
  774. ----------------------------------------------------------------
  775.  
  776. NAME
  777.  
  778.              redrawgadgets
  779.  
  780. SYNOPSIS
  781.  
  782.       Boolean = redrawgadgets( rctadress, requester, id)
  783.                                             A0             A1      D0
  784.   APTR rctadress;
  785.       struct Requester *requester;
  786.       SHORT id;
  787.  
  788. ERKLÄRUNG
  789. Zeichnet alle Gadgets ab dem in id angegebenen Gadget ent-
  790. sprechend ihrer Verbindung neu.
  791.  
  792.  
  793. ----------------------------------------------------------------
  794.  
  795. NAME
  796.  
  797.              redrawgad
  798.  
  799. SYNOPSIS
  800.  
  801.       Boolean = redrawgad( rctadress, requester, id, anzahl)
  802.                                       A0              A1        D0     D1
  803.   APTR rctadress;
  804.       struct Requester *requester;
  805.       SHORT id;
  806.       SHORT anzahl;
  807.       ERKLÄRUNG
  808.  
  809. Zeichnet die in anzahl angegebenen Gadgets ab dem in id angegebenen Gadget neu.
  810.  
  811.  
  812. ----------------------------------------------------------------
  813.  
  814. NAME
  815.  
  816.              aktivegad
  817.  
  818. SYNOPSIS
  819.  
  820.       Boolean = aktivegad( rctadress, requester, id)
  821.                                       A0              A1        D0
  822.   APTR rctadress;
  823.       struct Requester *requester;
  824.       SHORT id;
  825.  
  826. ERKLÄRUNG
  827.  
  828. Aktiviert das in id angegebene String Gadget, so da
  829. s, requester, id, stringadr)
  830.                                             A0           A1         D0      A2
  831.   APTR rctadress;
  832.       struct Requester *requester;
  833.       SHORT id;
  834.       char *stringadr;
  835.  
  836. ERKLÄRUNG
  837.  
  838. Setzt einen neuen Text in das Eingabefeld eines String Gadgets.
  839. Ist der Requester zu dem das Gadget gehört angezeigt, wird der neue Text direkt
  840. sichbar.
  841.  
  842.  
  843.  
  844. ----------------------------------------------------------------
  845.  
  846. NAME
  847.              getstrgadtext
  848.  
  849. SYNOPSIS
  850.  
  851.       stringadr = getstrgadtext( rctadress, requester, id)
  852.                                               A0             A1        D0
  853.   char *stringadress;
  854.       APTR rctadress;
  855.       struct Requester *requester;
  856.  
  857. ERKLÄRUNG
  858.  
  859. Ermittelt die Adresse des Textes der in das Eingabefeld des String Gadget mit
  860. der Objektnummer id eingegeben wurde.
  861. In GFA-Basic wird ein Basic-String zurückgeliefert.
  862.  
  863.  
  864. ----------------------------------------------------------------
  865.  
  866. NAME
  867.  
  868.              getstrgadstruct
  869.  
  870. SYNOPSIS
  871.  
  872.       wert = getstrgadstruct( rctadress, requester, id, item)
  873.                                           A0              A1        D0   D1
  874.  void wert;
  875.       APRT rctadress;
  876.       struct Requester *requester;
  877.       SHORT id;
  878.       SHORT item;
  879.  
  880. ERKLÄRUNG
  881.  
  882. Ermittelt den in item angegebenen Strukturteil der Stringinfo Struktur des
  883. String Gadgets mit der Objektnummer id.
  884.  
  885. item kann folgende Werte annehmen:
  886.  
  887.   item = 0 -> Adresse der StringInfo-Struktur
  888.   item = 1 -> *Buffer
  889.   item = 2 -> *UndoBuffer
  890.   item = 3 -> BufferPos
  891.   item = 4 -> MaxChars
  892.   item = 5 -> DispPos
  893.   item = 6 -> UndoPos
  894.   item = 7 -> NumChars
  895.   item = 8 -> DispCount
  896.   item = 9 -> CLeft
  897.   item = 10-> CTop
  898.   item = 11-> struct Layer *LayerPtr
  899.   item = 12-> LongInt
  900.   item = 13-> struct KeyMap *AltKeyMap
  901.  
  902.  
  903. ----------------------------------------------------------------
  904.  
  905. NAME
  906.  
  907.              setstrgadstruct
  908.  
  909. SYNOPSIS
  910.  
  911.       Boolean = setstrgadstruct( rctadress, requester, id, item, wert)
  912.                                               A0             A1        D0   D1      D2
  913.   APTR rctadress;
  914.       struct Requester *requester;
  915.       SHORT id;
  916.       SHORT item;
  917.       SHORT wert;
  918.  
  919. ERKLÄRUNG
  920.  
  921. Schreibt den in wert angegebenen Wert in das in item angegebene Strukturteil
  922. der Stringinfo Struktur des String Gadgets mit der Objektnummer id.
  923.  
  924. item kann folgende Werte annehmen:
  925.  item = 1 -> BufferPos
  926.   item = 2 -> MaxChars
  927.   item = 3 -> DispPos
  928.  
  929.  
  930. ----------------------------------------------------------------
  931.  
  932. NAME
  933.  
  934.              getpropgadstruct
  935.  
  936. SYNOPSIS
  937.  
  938.       wert = getpropgadstruct( rctadress, requester, id, item)
  939.                                             A0           A1         D0    D1
  940.  void wert
  941.       APTR rctadress;
  942.       struct Requester *requester;
  943.       SHORT id;
  944.       SHORT item;
  945.  
  946. ERKLÄRUNG
  947.  
  948. Ermittelt den Wert des in item angegebenen Strukturteiles der Propinfo Strutur
  949. des Proportional Gadgets mit der Objektnummer id.
  950.  
  951. item kann folgende Werte annehmen:
  952.  
  953.   item = 0 -> Adresse der PropInfo-Struktur
  954.   item = 1 -> Flags
  955.   item = 2 -> HorizPot
  956.   item = 3 -> VertPot
  957.   item = 4 -> HorizBody
  958.   item = 5 -> VertBody
  959.   item = 6 -> CWidth
  960.   item = 7 -> Height
  961.   item = 8 -> HPotRes
  962.   item = 9 -> VPotRes
  963.   item = 10-> LeftBorder
  964.   item = 11-> TopBorder
  965.  
  966.  
  967.  
  968. ----------------------------------------------------------------
  969.  
  970. NAME
  971.  
  972.              setpropgadstuct
  973.  
  974. SYNOPSIS
  975.  
  976.       Boolean = setpropgadstruct( rctadress, requester, id, item, wert)
  977.                                                 A0           A1         D0    D1     D2
  978.  
  979.       APTR rctadress;
  980.       struct Requester *requester;
  981.       SHORT id;
  982.       SHORT item;
  983.       UHORT wert;
  984.  
  985. ERKLÄRUNG
  986.  
  987. Schreibt den in wert angegebenen Wert in den in item angegegeben Strukturteil
  988. der Propinfo Struktur des Proportional Gagets mit der Objektnummer id.
  989.  
  990. item kann folgende Werte annehmen:
  991.  
  992.   item = 1 -> Flags
  993.   item = 2 -> HorizPot
  994.   item = 3 -> VertPot
  995.   item = 4 -> HorizBody
  996.   item = 5 -> VertBody
  997.  
  998.  
  999. ----------------------------------------------------------------
  1000.  
  1001. Menü-Bibliothek
  1002.  
  1003.  
  1004. NAME
  1005.  
  1006.              menudraw
  1007.  
  1008. SYNOPSIS
  1009.  
  1010.       Boolean = menudraw( rctadress, menu, window)
  1011.                                      A0         A1      A2
  1012.   APTR rctadress;
  1013.       struct Menu *menu;
  1014.       struct Window *window;
  1015.  
  1016. ERKLÄRUNG
  1017.  
  1018. Setzt in das in window angegebene Window die in menu angegebene Menüleiste.
  1019.  
  1020. ----------------------------------------------------------------
  1021.  
  1022. NAME
  1023.  
  1024.              menuend
  1025.  
  1026. SYNOPSIS
  1027.  
  1028.       Boolean = menuend( rctadress, menu, window)
  1029.                                     A0         A1      A2
  1030.   APTR rctadress;
  1031.       struct Menu *menu;
  1032.       struct Window *window;
  1033.  
  1034. ERKLÄRUNG
  1035.  
  1036. Löscht die in menu angegeben Menüleiste aus dem in window angegebenen Window.
  1037. Die Menüleiste wird dabei nicht aus dem Speicher gelöscht. Dies geschieht mit
  1038. der Funktion rctfree().
  1039.  
  1040. ----------------------------------------------------------------
  1041.  
  1042. NAME
  1043.  
  1044.              setmenutitle
  1045.  
  1046. SYNOPSIS
  1047.  
  1048.       Boolean = setmenutitle( rctadress, menu, menuid, stringadr)
  1049.                                           A0          A1        D0         A2
  1050.   APTR rctadress;
  1051.       struct Menu *menu;
  1052.       SHORT menuid;
  1053.       char *stringadr;
  1054.     ERKLÄRUNG
  1055.  
  1056. Schreibt den neuen String in den Menütitel mit der Objektnummer menuid.
  1057.  
  1058.  
  1059.  
  1060. ----------------------------------------------------------------
  1061.  
  1062. NAME
  1063.  
  1064.              getmenutitle
  1065.  
  1066. SYNOPSIS
  1067.  
  1068.       stringadr = getmenutitle( rctadress, menu, menuid)
  1069.                                              A0         A1      D0
  1070.     char *stringadr;
  1071.       APTR rctadress;
  1072.       struct Menu *menu;
  1073.       SHORT menuid;
  1074.  
  1075. ERKLÄRUNG
  1076.  
  1077. Ermittelt die Adresse des Menütiteltextes des Menütitel mit der Objektnummer
  1078. menuid.
  1079. In GFA-Basic wird ein Basic String zurückgeliefert.
  1080.  
  1081.  
  1082.  
  1083. ----------------------------------------------------------------
  1084.  
  1085. NAME
  1086.  
  1087.              setmenustruct
  1088.  
  1089. SYNOPSIS
  1090.  
  1091.       Boolean = setmenustruct( rctadress, menu, menuid, item, wert)
  1092.                                             A0         A1      D0      D1      D2
  1093.   APTR rctadress;
  1094.       struct Menu *menu;
  1095.       SHORT menuid;
  1096.       SHORT item;
  1097.       void wert;
  1098.  
  1099. ERKLÄRUNG
  1100.  
  1101. Schreibt den in wert angegebenen Wert in den in item angegebenen Strukturteil
  1102. des Menüs mit der Objektnummer menuid.
  1103.  
  1104. item kann folgende Werte anehmen:
  1105.  
  1106.     item = 0 -> Adresse der Menu-Struktur
  1107.     item = 1 -> struct Menu *NextMenu
  1108.     item = 2 -> LeftEdge
  1109.     item = 3 -> TopEdge
  1110.     item = 4 -> Width
  1111.     item = 5 -> Height
  1112.     item = 6 -> Flags
  1113.     item = 7 -> *MenuName item = 8 -> struct MenuItem *FirstItem
  1114.  
  1115.  
  1116. ----------------------------------------------------------------
  1117.  
  1118. NAME
  1119.  
  1120.              getmenustruct
  1121.  
  1122. SYNOPSIS
  1123.  
  1124.       wert = getmenustruct( rctadress, menu, menuid, item)
  1125.                                         A0         A1      D0      D1
  1126.       SHORT wert;
  1127.       APTR rctadress;
  1128.       struct Menu *menu;
  1129.       SHORT menuid;
  1130.       SHORT item;
  1131.  
  1132. ERKLÄRUNG
  1133.  
  1134. Ermittelt den Wert des in item angegebenen Strukturteil der Menü Struktur des
  1135. Menüs mit der Objektnummer menuid.
  1136.  
  1137. item kann folgende Werte anehmen:
  1138.  
  1139.     item = 1 -> LeftEdge
  1140.     item = 2 -> TopEdge
  1141.     item = 3 -> Width
  1142.     item = 4 -> Height
  1143.     item = 5 -> Flags
  1144.  
  1145. ----------------------------------------------------------------
  1146.  
  1147. NAME
  1148.  
  1149.              setmenuitext
  1150.  
  1151. SYNOPSIS
  1152.  
  1153.       Boolean = setmenuitext( rctadress, menu, menuid, itemid, stringadr)
  1154.                                           A0          A1        D0       D1          A2
  1155.       APTR rctadress;
  1156.       struct Menu *menu;
  1157.       SHORT menuid;
  1158.       SHORT itemid;
  1159.       char *stringadr;
  1160.  
  1161. ERKLÄRUNG
  1162.  
  1163. Schreibt den in String der an der Adresse stringadr im Speicher steht
  1164. in den Menüeintrag mit der Objektnummer itemid.
  1165.  
  1166.  
  1167.  
  1168. ----------------------------------------------------------------
  1169.  
  1170. NAME
  1171.  
  1172.              getmenuitext
  1173.  
  1174. SYNOPSIS
  1175.  
  1176.       stringadr = getmenuitext( rctadress, menu, menuid, itemid)
  1177.                                              A0         A1      D0         D1
  1178.  
  1179.       char *stringadr;
  1180.       APTR rctadress;
  1181.       struct Menu *menu;
  1182.       SHORT menuid;
  1183.       SHORT itemid;
  1184.  
  1185. ERKLÄRUNG
  1186.  
  1187. Ermittlet die Adresse des Textstrings des Menüeintrages mit der Objektnummer
  1188. itemid im Pull-Down Menü mit der Objektnummer menuid.
  1189. In GFA-Basic wird ein Basic-String zurückgeliefert.
  1190.  
  1191.  
  1192. ----------------------------------------------------------------
  1193.  
  1194. NAME
  1195.  
  1196.              setmenuitemstruct
  1197.  
  1198. SYNOPSIS
  1199.  
  1200.       Boolean = setmenuitemstruct( rctadress, menu, menuid, itemid, item, wert)
  1201.                                                  A0         A1      D0         D1      D2      D3
  1202.   APTR rctadress;
  1203.       struct Menu *menu;
  1204.       SHORT menuid;
  1205.       SHORT itemid;
  1206.       SHORT item;
  1207.       void wert;
  1208.  
  1209. ERKLÄRUNG
  1210.  
  1211. Schreibt den in wert enthaltenen Wert in die Strukturkomponente item des
  1212. Menüeintrages mit der Objektnummer itemid im Pull-Down-
  1213. Menü mit der Objektnummer menuid.
  1214.  
  1215. item kann folgende Werte annehmen:
  1216.  
  1217.   item = 1 -> LeftEdge
  1218.   item = 2 -> TopEdge
  1219.   item = 3 -> Width
  1220.   item = 4 -> Height
  1221.   item = 5 -> Flags
  1222.   item = 6 -> MutualExclude
  1223.   item = 7 -> Command
  1224.   item = 8 -> NextSelect
  1225.  
  1226.  
  1227. ----------------------------------------------------------------
  1228.  
  1229. NAME
  1230.  
  1231.              getmenuitemstruct
  1232.  
  1233. SYNOPSIS
  1234.  
  1235.       wert = getmenuitemstruct( rctadress, menu, menuid, itemid, item)
  1236.                                              A0         A1      D0          D1      D2
  1237.  
  1238.       void wert;
  1239.       APTR rctadress;
  1240.       struct Menu *menu;
  1241.       SHORT menid;
  1242.       SHORT itemid;
  1243.       SHORT item;
  1244.  
  1245. ERKLÄRUNG
  1246.  
  1247. Ermittelt den Wert der in item angegebenen Strukturkomponente der Menuitem
  1248. Struktur des Menüeintrages mit der Objektnummer itemid im Pull-Down-Menü mit
  1249. der Objektnummer menuid.
  1250.  
  1251. item kann folgende Werte annehemen:
  1252.  
  1253.   item = 0 -> Adresse der MenuItem-Struktur
  1254.   item = 1 -> struct MenuItem *NextItem
  1255.   item = 2 -> LeftEdge
  1256.   item = 3 -> TopEdge
  1257.   item = 4 -> Width
  1258.   item = 5 -> Height
  1259.   item = 6 -> Flags
  1260.   item = 7 -> MutualExclude
  1261.   item = 8 -> APTR ItemFill
  1262.   item = 9 -> APTR SelectFill
  1263.   item = 10-> Command
  1264.   item = 11-> struct MenuItem *SubItem
  1265.   item = 12-> NextSelect
  1266.  
  1267. ----------------------------------------------------------------
  1268.  
  1269. NAME
  1270.  
  1271.              setmenustext
  1272.  
  1273. SYNOPSIS
  1274.  
  1275.       Boolean = setmenustext( rctadress, menu, menuid, itemid, subid, stringadr)
  1276.                                           A0          A1        D0       D1         D2        A2
  1277.  
  1278.       APTR rctadress;
  1279.       struct Menu *menu;
  1280.       SHORT menuid;
  1281.       SHORT itemid;
  1282.       SHORT subid;
  1283.       char *stringadr;
  1284.  
  1285. ERKLÄRUNG
  1286.  
  1287. Schreibt einen neuen Text in das Submenü mit der Objektnummer subid, dessen
  1288. ursprung im Menüeintrag mit der Objektnummer itemid liegt und sich im
  1289. Pull-Down-Menü mit der Objektnummer menuid befindete.
  1290.  
  1291.  
  1292. ----------------------------------------------------------------
  1293.  
  1294. NAME
  1295.  
  1296.              getmenustext
  1297.  
  1298. SYNOPSIS
  1299.  
  1300.       stringadr = getmenustext( rctadress, menu, menuid, itemid, subid)
  1301.                                              A0         A1      D0         D1      D2
  1302.      char *stringadr;
  1303.       APTR rctadress;
  1304.       struct Menu *menu;
  1305.       SHORT menuid;
  1306.       SHORT itemid;
  1307.       SHORT subid;
  1308.  
  1309. ERKLÄRUNG
  1310.  
  1311. Ermittelt die Adresse des Textstrigns des Submenü mit der Objektnummer subid,
  1312. dessen ursprung im Menüeintrag mit der Objektnummer itemid liegt und sich im
  1313. Pull-Down-Menü mit der Objektnummer menuid befindete.
  1314. In GFA-Basic wird ein Basic-String zurückgeliefert.
  1315.  
  1316.  
  1317. ----------------------------------------------------------------
  1318.  
  1319. NAME
  1320.  
  1321.              setmenusubstruct
  1322.          SYNOPSIS
  1323.  
  1324.       Boolean = setmenusubstruct( rctadress, menu, menuid, itemid, subid ,item,
  1325.       wert)
  1326.                                                 A0         A1      D0        D1       D2
  1327.                                                 D3     D4
  1328.   APTR rctadress;
  1329.       struct Menu *menu;
  1330.       SHORT menuid;
  1331.       SHORT itemid;
  1332.       SHORT subid;
  1333.       SHORT item;
  1334.       void wert;
  1335.  
  1336. ERKLÄRUNG
  1337.  
  1338. Schreibt den Inhalt von wert in die in item angegebene Struktur-
  1339. komponuente des Submenüs mit der Objetnummer subid, dessen Ursprung im
  1340. Menüeintrag mit der Objektnummer itemid liegt und sich im Pull-Down-Menü mit
  1341. der Objektnummer menuid befindete.
  1342.  
  1343. item kann folgende Werte annehmen:
  1344.  
  1345.   item = 1 -> LeftEdge
  1346.   item = 2 -> TopEdge
  1347.   item = 3 -> Width
  1348.   item = 4 -> Height
  1349.   item = 5 -> Flags
  1350.   item = 6 -> MutualExclude
  1351.   item = 7 -> Command
  1352.   item = 8 -> NextSelect
  1353.  
  1354.  
  1355. ----------------------------------------------------------------
  1356.  
  1357. NAME
  1358.  getmenusubstruct
  1359.  
  1360. SYNOPSIS
  1361.  
  1362.       wert = getmenusubstruct( rctadress, menu, menuid, itemid, subid, item)
  1363.                                             A0         A1      D0        D1       D2      D3
  1364.  void wert;
  1365.       APRT rctadress;
  1366.       struct Menu *menu;
  1367.       SHORT menuid;
  1368.       SHORT itemid;
  1369.       SHORT subid;
  1370.       SHORT item;
  1371.  
  1372. ERKLÄRUNG
  1373.  
  1374. Ermittelt den Wert der in item angegebenen Strukturkomponenten des Submenü mit
  1375. der Objektnummer subid, dessen ursprung im Menüeintrag mit der Objektnummer
  1376. itemid liegt und sich im Pull-Down-Menü mit der Objektnummer menuid befindete.
  1377.  
  1378. item kann folgende Werte annehemen:
  1379.  
  1380.   item = 0 -> Adresse der MenuItem-Struktur
  1381.   item = 1 -> struct MenuItem *NextItem
  1382.   item = 2 -> LeftEdge
  1383.   item = 3 -> TopEdge
  1384.   item = 4 -> Width
  1385.   item = 5 -> Height
  1386.   item = 6 -> Flags
  1387.   item = 7 -> MutualExclude
  1388.   item = 8 -> APTR ItemFill
  1389.   item = 9 -> APTR SelectFill
  1390.   item = 10-> Command
  1391.   item = 11-> NextSelect
  1392.  
  1393.  
  1394. ----------------------------------------------------------------
  1395.  
  1396. NAME
  1397.  
  1398.              showscreen
  1399.  
  1400. SYNOPSIS
  1401.  
  1402.       screen = showscreen( rctadress, mod, depth, title)
  1403.                                       A0          D0     D1        A1
  1404.       struct Screen *screen;
  1405.       APTR rctadress;
  1406.       USHORT mod;
  1407.       SHORT depth;
  1408.       char *title;
  1409.  
  1410. ERKLÄRUNG
  1411.  
  1412. Öffnet einen Screen in der angegebenen Auflösung und Tiefe und liefert die
  1413. Adresse auf die Screen Struktur zurück. Unter Workbench 2.0 wird der Screen
  1414. automatisch im 3D-Look geöffnet.
  1415.  
  1416.  
  1417.  
  1418. ----------------------------------------------------------------
  1419.  
  1420. NAME
  1421.  
  1422.              remscreen
  1423.  
  1424. SYNOPSIS
  1425.  
  1426.       Boolean = remscreen( rctadress, screen)
  1427.                                       A0            A1
  1428.  
  1429.       APTR rctadress;
  1430.       struct Screen *screen;
  1431.  
  1432. ERKLÄRUNG
  1433.  
  1434. Bevor der Screen geschlossen wird, werden alle Windows und Requester
  1435. geschlossen, so daß keine Fensterleichen entstehen.
  1436.  
  1437.  
  1438. ----------------------------------------------------------------
  1439.  
  1440. NAME
  1441.  
  1442.              form_alert
  1443.  
  1444. SYNOPSIS
  1445.  
  1446.       id = form_alert( default, commandstring)
  1447.                                  D0            A0
  1448.  
  1449.       SHORT id;
  1450.       SHORT default;
  1451.       char *commandstring;
  1452.  
  1453. ERKLÄRUNG
  1454.  
  1455. Zeigt eine Alarm-Requester zentriert auf dem aktiven Screen an.
  1456. Im commandstring sind sowohl die Texte der Alarmmeldung als auch die der
  1457. Gadgets enthalten. Es können maximal 5 Textzeilen je 30 Zeichen und Maximal 3
  1458. Gadgets mit je 12 Zeichen ausgegeben werden.
  1459. Der String hat folgendes Format:
  1460.  "[SYMBOLNUMMER][1. Textzeile|2. Textzeile|3. Textzeile|4. Textzeile|5.
  1461. Textzeile][1. Gadget|2. Gadget|3. Gadget]"
  1462.  
  1463. Wie Sie sehen werden die Textzeilen und die Gadgets durch ein |-
  1464. Zeichen voneinander getrennt. Die erste Ziffer, die mit SYMBOLNUMMER bezeichnet
  1465. ist, wählt das Symbol, das links im Requester erscheinen soll.
  1466. Es gibt vier Möglichkeiten:
  1467.  
  1468. 0 -> kein Symbol
  1469. 1 -> NOTE (ein auf der Spitze stehendes Quadrat mit Ausrufezeichen)
  1470. 2 -> WAIT (ein Fragezeichen in einem Achtung-Schild)
  1471. 3 -> STOP (ein STOP-Schild)
  1472.  
  1473. Eines der Gadgets kann durch die Variable default als Default-Gadgets definiert
  1474. werden. Das Default-Gadget ist durch eine dickeren Rahmen in der Farbe mit dem
  1475. Index 3 unübersehbar und kann mit der Taste Return ausgewählt werden.
  1476. Ist der Requester auf dem Bildschirm angezeigt, kann der Rahmen mit den
  1477. Cursor-Tasten von Gadget zu Gadget gewechselt werden. Es ist immer das Gadget
  1478. mit Return wählbar, auf dem der Default-
  1479. Rahmen gezeichnet ist.
  1480.  
  1481. Ist default = 0 gibt es kein Default-Gadget.
  1482.  
  1483.  
  1484. ----------------------------------------------------------------
  1485.  
  1486. NAME
  1487.  
  1488.              filer
  1489.  
  1490. SYNOPSIS
  1491.  
  1492.       boolean = filer( rctfilereq)
  1493.  
  1494.       struct RCTFileRequester *rctfilereq;
  1495.  
  1496.  
  1497. ERKLÄRUNG
  1498.  
  1499. Durch Aufrufen dieser Funktion erscheint ein komfortabler, vollkommen
  1500. tastatursteuerbarer, reentranter Datei-Requester. Der Requester erscheint
  1501. wahlweise in einem verschiebaren Window oder in einem feststehenden Requester.
  1502.  
  1503. Die Datenstruktur deren Adresse übergeben werden muß, muß nicht unbedingt
  1504. initialisiert werden, was den Aufruf aus Programmiersprachen wie Basic
  1505. erheblicht vereinfacht. Die Struktur sollte aber wenigstens mit Nullen gefüllt
  1506. sein.
  1507.  
  1508. Die Datenstruktur und die einstellbaren Flags wurden vom FileRequester Aufruf
  1509. der REQUESTER.Library übernommen, so daß eine Umstellung auf den
  1510. RCT-File-Requester sehr einfach gemacht werden kann.
  1511.  
  1512. Die Struktur sieht folgendermaßen aus:
  1513.  
  1514.  
  1515. struct RCTFileRequester
  1516.   {
  1517.   UWORD     VersionNumber;         /* Die Versionsnummer der Library, die beim
  1518.                                              Programmieren verwendet wird */
  1519.  
  1520.   char     *Title;                  /* Entweder der Fenstertitel oder ein besonderes
  1521.                                              Requestergadget */
  1522.   char     *Dir;                     /* Pfad-Array (DSIZE+1) */
  1523.   char     *File;                     /* Dateiname-Array (FCHARS+1) */
  1524.   char     *PathName;              /* Pfad- und Dateinamen-Array (DSIZE+FCHARS+2) */
  1525.  
  1526.   struct Window *Window;         /* Window in dem der Requester angezeigt werden
  1527.                                              soll oder NULL */
  1528.   UWORD     reserved;                 /* wird ignoriert */
  1529.   UWORD     numlines;                 /* wird ignoriert */
  1530.   UWORD     numcolumns;             /* wird ignoriert */
  1531.   UWORD     devcolumns;
  1532.   ULONG     Flags;                     /* Definitionen der Flags siehe weiter */
  1533.   UWORD     dirnamescolor;         /* wird ignoriert */
  1534.   UWORD     filenamescolor;         /* wird ignoriert */
  1535.   UWORD     devicenamescolor;     /* wird ignoriert */
  1536.   UWORD     fontnamescolor;         /* wird ignoriert */
  1537.   UWORD     fontsizescolor;         /* wird ignoriert */
  1538.  
  1539.   UWORD     detailcolor;             /* wird ignoriert */
  1540.   UWORD     blockcolor;             /* wird ignoriert */
  1541.   UWORD     gadgettextcolor;      /* wird ignoriert */
  1542.   UWORD     textmessagecolor;     /* wird ignoriert */
  1543.   UWORD     stringnamecolor;      /* wird ignoriert */
  1544.   UWORD     stringgadgetcolor;     /* wird ignoriert */
  1545.   UWORD     boxbordercolor;         /* wird ignoriert */
  1546.   UWORD     gadgetboxcolor;         /* wird ignoriert */
  1547.  
  1548.   UWORD     FRU_Stuff[18];         /* Reserviert, sollte NULL sein */
  1549.   struct DateStamp DirDateStamp; /* wird ignoriert */
  1550.  
  1551.   UWORD     WindowLeftEdge;         /* Diese beiden Felder werden benutzt, um den
  1552.                                              Requester zu */
  1553.   UWORD     WindowTopEdge;         /* positionieren. */
  1554.  
  1555.   UWORD     FontYSize;              /* wird ignoriert */
  1556.   UWORD     FontStyle;              /* wird ignoriert */
  1557.  
  1558.   ULONG     *reserved1;             /* Reserviert */
  1559.   char     Hide[WILDLENGTH+2];  /* Wildcards Text für Dateien die nicht
  1560.                                              angezeigt werden sollen */
  1561.   char     Show[WILDLENGTH+2];  /* Wildcards Text für Dateien die angezeigt
  1562.                                              werden sollen */
  1563.   WORD     FileBufferPos;         /* Werte für Stringgadgets */
  1564.   WORD     FileDispPos;             WORD     DirBufferPos;            WORD
  1565.   DirDispPos;              WORD     HideBufferPos;
  1566.   WORD     HideDispPos;
  1567.   WORD     ShowBufferPos;
  1568.   WORD     ShowDispPos;
  1569.  
  1570.  /**;       Die nachfolgenden Felder sind Privat und sollten aus Ihren
  1571.               Programmen nie angesprochen oder genutzt werden */
  1572.  
  1573.   APTR     privat1;
  1574.   APTR     privat2;
  1575.   APTR     privat3;
  1576.   char     privat4[DSIZE+2];        /* Used for keeping a record of which */
  1577.   struct FileInfoBlock      *privat6;
  1578.   WORD     privat7;
  1579.   WORD     privat8;
  1580.   WORD     privat9;
  1581.   WORD     privat10;
  1582.   };
  1583.  
  1584.  
  1585. DSIZE ist die Definition für die Größe des Pfadnamen-Arrays.
  1586. FCHARS steht für die Größe des Dateinamen-Arrays.
  1587. WILDLENGTH ist die länge des Stings für den Hide- und Showtext.
  1588.  
  1589. Durch folgende Flags kann das Aussehen und die Art des Requesters verändert
  1590. werden:
  1591.  
  1592. FRQCACHINGM      /* Wenn das eingelesene Verzeichnis zwischengespeichert und
  1593.                          beim nächsten Aufruf des Requesters wieder aufgerufen werden
  1594.                          soll */
  1595. FRQABSOLUTEXYM  /* in den Felder WindowLeftEdge, WindowTopEdge werden
  1596.                          Koordianten angegeben anderenfalls wird der Requester
  1597.                          zentiert */
  1598. FRQCACHEPURGEM  /* Das zwischengespeicherte Verzeichnis wird neu geladen wenn
  1599.                          sich das Datum des Verzeichnisses geändert hat */
  1600. FRQNOHALFCACHEM /* Die eingelesenen Dateien werden nicht bis zum nächsten
  1601.                          Aufruf zwischengespeichert, wenn sie nicht vollständig
  1602.                          eingelesen werden konnten */
  1603. FRQNOSORTM         /* Die Dateinamen sollen unsortiert angezeigt werden */
  1604. FRQNODRAGM         /* Der Requester kann nciht verschoben oder in den
  1605.                          Hinter-/Vordergrund geholt werden */
  1606. FRQSAVINGM         /* Im "OK-Gadget" wird der Text "SAVE" angezeigt */
  1607. FRQLOADINGM      /* Im "OK-Gadget" wird der text "LOAD" angezeigt */
  1608. FRQNODEPTHM      /* Das Fenster soll zwar verschiebbar aber nicht in der
  1609.                          Vorder-/Hintergrund stellbar sein. */
  1610.  
  1611.  
  1612. Alle Funktionen des Requesters können mit der Tastatur erreicht werden. Die
  1613. Gadgets sind durch Drücken der Ctrl-Taste zusammen mit dem jeweiligen
  1614. Anfangsbuchstaben des Gadgettextes zu erreichen.
  1615.  
  1616. Das aktuelle Device sowie der erste Dateiname sind nach Aufruf des Requester
  1617. invers unterlegt. Mit den Cursortasten-Auf und -Ab kann der Dateiname
  1618. gewechselt werden. Tatsächlich angewählt und in das String-Gadtet übernommen
  1619. wird er allerdings erst, wenn Return betätigt wird. Genau so verhält es sich
  1620. auch mit den Devices. Es muß lediglich zusammen mit den Cursortasten die Ctrl-
  1621. Taste gedrückt werden um in der Deviceliste zu scrollen. Ctrl und Return wählt
  1622. ein Device an um lädt dessen Inhaltsverzeichnis.
  1623. Eventuell Pfadeinstellungen werden beim Wechseln der Devices gemerkt und bei
  1624. erneuten Wechsel wieder eingestellt.
  1625.  
  1626.  
  1627. ----------------------------------------------------------------
  1628.  
  1629. NAME
  1630.  
  1631.              filercachefree
  1632.  
  1633. SYNOPSIS
  1634.  
  1635.       void filercachefree( rctfilereq)
  1636.                                     A0
  1637.       struct RCTFileRequester *rctfilereq;
  1638.  
  1639.  
  1640. ERKLÄRUNG
  1641.  
  1642. Ist bei Aufruf des FilerRequester das Flag zum Zwischenspeichern (FRQCACHINGM)
  1643. des Verzeichnisses eingestellt gewesen, muß spätestens beim Beenden des
  1644. Programmes der Speicher wieder freigeben werden.
  1645.  
  1646. ----------------------------------------------------------------
  1647.  
  1648. NAME
  1649.  
  1650.              waitall
  1651.  
  1652. SYNOPSIS
  1653.  
  1654.       void waitall( Port, message)
  1655.                           A0         A1
  1656.       struct MessagePort *port;
  1657.       struct IntuiMessage *message;
  1658.  
  1659.  
  1660. ERKLÄRUNG
  1661.  
  1662. Anders als bei reqwait werden bei dieser Funktion die IDCMP-Flags
  1663. des Fensters nicht beeinflußt. Sie liefert eine exakte Kopie der
  1664. Nachricht und schickt die Original-Nachricht an das System zurück.
  1665. Die Auswertung bleibt Ihnen überlassen.
  1666.  
  1667. Beispiel:
  1668.  
  1669. struct IntuiMessage message; /* kein Pointer sondern die ganze Struktur */
  1670. struct Window *window;
  1671.  
  1672. waitall( window->UserPort, &message);
  1673.  
  1674. if(message.Class & RAWKEY)
  1675.   {
  1676.   ......
  1677.   }
  1678.  
  1679.  
  1680. SIEHE
  1681.  
  1682. reqwait
  1683.  
  1684.  
  1685. ----------------------------------------------------------------
  1686.  
  1687. NAME
  1688.  
  1689.             gaddrawwindow
  1690.  
  1691. SYNOPSIS
  1692.  
  1693.         window = gaddrawwindow( rctadress, requester, screen, title, idcmp, flags)
  1694.                                           A0             A1          A2         A3      d0        d1
  1695.  
  1696.       struct Window *window;
  1697.       APTR rctadress;
  1698.       struct Requester *requester;
  1699.       struct Screen *screen;
  1700.       char *title;
  1701.       ULONG idcmp;
  1702.       ULONG flags;
  1703.  
  1704. ERKLÄRUNG
  1705.  
  1706. Öffnet ein Window in der Größe des angegebenen Requesters und zeigt diesen
  1707. darin an. Ohne Angabe einer Screenadresse wird das Window auf dem
  1708. Workbenchscreen geöffnet. Beim Schließen des Requesters mit der Funktion
  1709. reqend() wird auch das Window geschlossen.
  1710. Der einzige Unterschied zu reqdrawwindow ist der, daß alle Gadgets,
  1711. Requestertexte und Border direkt auf Window gebracht werden. Man hat dadurch
  1712. den Vorteil, das zusätzlich zur Abfrage der Gadgets noch die Menüleiste
  1713. berücksichtigt werden kann.
  1714.  
  1715. RÜCKGABE
  1716.  
  1717. Konnte die Funktion erfolgreich ausgeführt werden, wird die Adresse des Windows
  1718. zurückgeliefert, andernfalls NULL.
  1719.  
  1720. HINWEIS
  1721.  
  1722. Wird für ein Gadget innerhalb des Requesters das Flag ENDGADGET definiert,
  1723. wird der Requester durch Inuition automatisch geschlossen, sobald man
  1724. das Gadget anklick. In diesem Fall ist es nicht mehr möglich, den Requester
  1725. mit der Funktion reqend() zu schließen. Man muß dann das
  1726. Window selbst schließen.
  1727.  
  1728.  
  1729. ----------------------------------------------------------------
  1730.