Dialogboxen in GFA-Basic Teil I
In dieser neuen Serie der ST Computer wollen wir auf die vielfältigen Fragen und Reaktionen auf unseren kleinen Artikel in der Februar-Ausgabe dieses Jahres eingehen. Damals wollten wir nur als Anregung zeigen, wie man auch in GFA-BASIC Ressourcen laden und damit Dialogboxen erstellen kann. Diese Serie soll nun tiefer in die Welt dieser kontaktfreudigen Boxen eindringen und so manchen Tip und Kniff verraten, mit dem man sein eigenes Programm verschönern kann. Dazu werden nach und nach die notwendigen und manchmal auch nur vereinfachenden Prozeduren abgedruckt, und anhand von Beispielen die Handhabung ausführlich erklärt.
Zu Beginn sollen in dieser ersten Folge die wichtigsten Routinen zur Benutzung von Dialogboxen erklärt werden. Das sind natürlich die Prozeduren, die die Boxen erst auf dem Bildschirm erscheinen und verschwinden lassen und die einzelnen Objekte abfragen. Dazu ist als Beispiel ein kleines Programm entstanden, das zwei Dialogboxen verwaltet und mehrere EDIT-Felder beinhaltet. Doch zuerst müssen die beiden Boxen in einem Resource Construction Set (RCS) erstellt werden. Wir werden nicht im einzelnen erklären, wie dies bewerkstelligt wird, da wir sonst eine Anleitung für ein RCS schreiben müssen, sondern möchten für jemanden, der noch nie mit einem RCS gearbeitet hat, auf unser nächstes Sonderheft hinweisen, in dem eine ausführliche Anleitung zum RCS V 1.4 aus dem ATARI Entwicklungspaket gegeben wird. Dieses RCS ist auch direkt bei der ST Computer gegen einen Kostenbeitrag von DM 15,— zu beziehen und somit für jedermann zugänglich.
Doch wir lassen Sie nicht ganz im Stich. Die Abbildungen 1 und 2 zeigen, aus welchen Objekttypen sich die beiden Dialogboxen zusammensetzen, so daß man sie mit ein wenig Übung auch als Anfänger leicht „nachbauen“ kann.
Wichtig beim Erstellen der Resourcen ist vor allen Dingen, daß man den Objekten, die man später abfragen oder auch verändern will, einen Namen gibt. Da jedes Objekt der Resourcen einen Index bekommt, wäre dies nicht unbedingt notwendig, erleichtert die Arbeit aber ungemein, wenn man das Resource verändern muß. In diesem Falle können sich nämlich die Reihenfolge der Indizes ändern und man müßte diese für jedes Objekt im Programmlisting anpassen. Um dies zu umgehen, sind am Anfang die benötigten Namen als Variablen definiert. Wir haben dazu im RCS die Namen an die Objekte vergeben und die beim Abspeichern der Resourcen erzeugte Header-Datei (.H) für GFA-BASIC umgewandelt (siehe ST-Ecke Mai ’87) und anschließend zum Programm „hinzugemergt“. Wichtig bei der Namensgebung ist, daß man keine Namen vergibt, die das BASIC als Befehl erkennt, da sonst ein Pfeil vor dem Namen erscheint, um so auf einen Fehler hinzuweisen.
Hat man nun das Resource erstellt und die Variablen am Anfang des Programmes erhalten, kann man sich dem eigentlichen Programmieren der Dialogboxen zuwenden. Dies möchten wir anhand der verwendeten Prozeduren genau erklären.
Verwendete Prozeduren und ihre Parameter
Rsrc_ — Laden einer Resource-Datei
Rsrc_("Programmname.rsc",*Fehler%)
Durch Aufruf der AES-Routine Rsrc_load (Gemsys 110) wird im Arbeitsspeicher Platz für die zu ladende Resource-Datei geschaffen und diese anschließend geladen. Als Parameter wird nur der Programmname benötigt, wobei unsere Version hier nur eine Resource-Datei in der obersten Directory-Ebene findet. Will man sie der Übersicht halber trotzdem aus einem Ordner laden, muß man zuvor mit dem CHDIR-Befehl den richtigen Pfad bestimmen.
Als Rückgabeparameter erhält man in der Variablen Fehler% eine Null oder einen positiven Wert. Ist der Wert Null, so ist ein Resource-Ladefehler aufgetreten.
Rsrc_gaddr — Ermitteln der Baumadresse
Rsrc_gaddr(0,Index%,*Baumadresse)
Nach dem Laden der Resource-Datei wird als nächstes die Baumadresse, d.h. die Stelle der Objektstruktur, an der der Baum beginnt, benötigt. Dazu verwendet man die Routine Rsrc_gaddr (Gemsys 112). Der erste Parameter (Gtype% genannt) muß in unserem Fall eine Null enthalten. Die anderen Möglichkeiten dieses Parameters sollen uns an dieser Stelle nicht interessieren. In unserem Februarheft dieses Jahres hatten wir, wie bereits oben erwähnt, einen kleinen Beitrag über Dialogboxen in GFA BASIC veröffentlicht und darin noch den Parameter Gtype% mit dem Wert 2 benutzt, um die Tedinfo-Adresse herauszubekommen. Diese Methode hat sich aber bei der Benutzung umfangreicherer Resource-Dateien als unbrauchbar erwiesen. Als universeller kann man die jetzt verwendete Routine bezeichnen, wie sie in der Prozedur Patadr später noch beschrieben wird.
Der zweite Parameter beinhaltet die sogenannte Baumindexnummer. Will man mehrere Objektbäume in einer Resource-Datei benutzen (dies tritt ja schon bei der Benutzung zweier Dialogboxen auf), so vergibt das Resource Construction Set für jeden Baum eine Indexnummer. Man muß also die Indexnummer des gewünschten Baumes übergeben. In unserem Falle eine Null (Bauml) oder eine Eins (Baum2).
Als Rückgabeparameter erhält man die gewünschte Baumadresse zur weiteren Verwendung.
Form_center — Ermitteln der Zentrierungskoordinaten
Form_center(Baumadresse%,*F_cx%,*F_cy%,*F_cw%,*F_ch%)
Diese Routine (Gemsys 54) dient, wie der Name schon sagt, der Zentrierung einer Box in der Bildschirmmitte. Man übergibt einfach nur die Baumadresse und das AES antwortet einem freundlicherweise und meistens korrekt mit den Koordinaten für X (F_cx%), Y (F_cy%), Breite (F_cw%) und Höhe (F_ch%) der mittig zentrierten Dialogbox. Natürlich kann man die Form_center-Routine auch weglassen und eigene Koordinaten nehmen, wenn man die Dialogbox nicht in der Mitte haben will, sondern zum Beispiel in der linken unteren Ecke.
Form_dial — Öffnen und Schließen der Dialogbox
Form_dial(Flag%,Littlx%,Littly%,Littlw%,Littlh%,Bigx%,Bigy%,Bigw%,Bigh%)
Die Routine Form_dial bietet vier verschiedene Möglichkeiten des Aufrufs. Welche der vier Möglichkeiten benutzt werden soll, wird durch den ersten Parameter Flag% bestimmt. Im einzelnen bewirken sie beim Aufruf der Routine folgendes:
Flag% = 0 — reserviert einen Bildschirmbereich für die Dialogbox
Flag% = 1 — zeichnet ein sich vergrößerndes Rechteck
Flag% = 2 — zeichnet ein sich verkleinerndes Rechteck
Flag% = 3 — gibt den reservierten Bildschirmbereich wieder frei
Neben dem Flag%-Parameter verlangt Form_dial noch acht weitere Ubergabewerte. Die ersten vier (Littl..) davon bilden die X-, Y-, Breiten- und Höhenkoordinaten des Rechtecks in der Ursprungsgröße. D.h., von dieser Rechtecksgröße ausgehend wird das Rechteck auf die gewünschte Endgröße gebracht. Diese Endgröße wird wiederum von den letzten vier Parametern (Big..) bestimmt. Die Big-Parameter sollten also, will man die Dialogbox zentriert auf dem Bildschirm haben, identisch mit den Rückgabeparametern der Form_center-Routine sein.
Bildschirminhalt zerstört?
Normalerweise würde der Aufruf einer Dialogbox ein häßliches Loch in der Größe der Box auf dem Bildschirm hinterlassen, da AES den Bildschirminhalt nicht automatisch rettet. Deswegen haben wir in zwei Routinen (Form_dial und Objc_draw) zusätzlich noch ein Retten (Get) und wieder Ausgeben (Put) des überzeichneten Bildschirms eingebaut. Somit wird der Bildschirminhalt automatisch wieder regeneriert.
Es ist nicht notwendig, alle vier Form_dial-Routinen zu benutzen. Will man zum Beispiel auf den schönen Effekt des sich vergrößernden Rechtecks verzichten, so läßt man einfach die Aufrufe der Routinen mit den Parametern Flag%=1 und Flag%=2 weg. Die Dialogbox wird dann später direkt auf den reservierten Bildschirm gezeichnet. Doch dazu benötigen wir die nächste Routine.
Objc_draw — Zeichnen der Dialogbox
Objc_draw(Baumadresse%,Startobjekt%,Tiefe%,X%,Y%,W%,H%,)
Hiermit wird endlich die Dialogbox auf den Bildschirm gezeichnet. Die Routine benötigt wieder eine ganze Reihe von Parametern, die folgende Bedeutung haben. Zuerst muß natürlich, wie schon gewohnt, die Baumadresse übergeben werden. Der zweite Parameter (Startobjekt%) gibt an, ab welchem Objekt die Dialogbox gezeichnet werden soll. Wer Lust hat, kann ja mal ausprobieren, was passiert, wenn man die Box nicht ab dem ersten Objekt des Baumes (Objekt 0), sondern vielleicht erst ab dem zweiten oder dritten zeichnen läßt.
Der nächste Parameter gibt die Zeichentiefe an. Darunter ist die Anzahl der Zeichenbenen zu verstehen. AES kann maximal neun dieser Ebenen (0—8) verwalten. Alle Versuche, mehr Ebenen zeichnen zu lassen, wird prompt bombig beantwortet. Am besten gibt man als Parameter immer eine Zeichentiefe von 8 an (also neun Ebenen). So braucht man sich um diesen Parameter nie mehr Sorgen zu machen und kann immer die maximale Tiefe nutzen.
Natürlich braucht man zum Zeichnen auch die Bildschirmkoordinaten der gewünschten Dialogbox, die durch X%,Y%,W%, und H%, definiert sind. Man braucht sie aber nicht selbst auszurechnen oder auszutesten. Durch die Form_center-Routine hat man sie in der Regel schon erhalten und muß sie so nur an die Objc_draw-Routine übergeben. Selbstverständlich ist auch hier der Manipulation Tür und Tor geöffnet, so daß man leicht gewollte/ungewollte Effekte erzielen kann.
Form_do — Kontrollübergabe an AES
Form_do(Baumadresse%,Startobjekt%,*Exitobjekt%)
Durch die Form_do-Routine liefert man sich auf Gedeih und Verderb dem Rechner aus, da durch den Aufruf die komplette Kontrolle an das AES übergeben wird. Der ST wartet nun auf eine bzw. mehrere Eingabe(n) in der Dialogbox und läuft solange in einer Schleife, bis ein Objekt, das als EXIT, TOUCHEXIT oder DE-FAULT definiert wurde, angeklickt wurde. Doch dazu kommen wir gleich noch nach der Parameterbeschreibung.
Als Parameter brauchen wir zuerst wieder die Baumadresse, um den richtigen Baum auszuwählen. Doch schon der nächste Parameter (Startobjekt%) benötigt eine genauere Erklärung. Er gibt an, welches Objekt der Box das erste editierbare Feld ist. Doch Vorsicht! Man sollte darauf achten, daß das Objekt auch wirklich editierbar ist, da der ST sonst gerne als Bombenleger in Erscheinung tritt. Beinhaltet die Dialogbox kein editierbares Feld (z.B. eine Info-Box), so übergibt man einfach den Wert Null.
Als Rückgabeparameter erhält man von der Form_do-Routine den Index des Objektes zurück, durch dessen Anklicken die Dialogbox verlassen (und somit die Form_do-Routine beendet) wurde. Man braucht also nur die Objektindizes mit dem Rückgabeparameter zu vergleichen und weiß sofort, durch welches Objekt die Dialogbox verlassen wurde (z.B. ABBRUCH oder OK). Wie oben schon erwähnt, muß ein solches Objekt zuvor im Resource Construction Set als EXIT, TOUCHEXIT oder DEFAULT definiert werden, da die Form_do-Routine sonst in einer Schleife läuft und ewig wartet. Man kann ein Objekt auch erst später im Programm entsprechend definieren, doch dazu kommen wir erst in der nächsten Ausgabe.
Ptadr — Ermitteln der Textadresse
Patadr(Baumadresse%,Objektindex%,Flag%,*Textadresse%)
Diese Routine ist nicht im AES enthalten und müßte somit selbst geschrieben werden. Sie erleichtert die Handhabung von EDIT-Feldern aber ungemein, da sie die Anfangsadresse eines durch den Objektindex definierten Textfeldes berechnet und zurückgibt. Benötigt werden als Parameter wieder unsere Baumadresse und der Index des gewünschten Objektes.
Die Berechnung geht folgendermaßen vonstatten: Zuerst benötigt man die eigentliche Adresse des Objektes in der Baumstruktur. Man erhält sie, indem man den Objektindex mit 24 multipliziert und das Produkt anschließend zu der Baumadresse addiert. Nun kommt sicherlich die Frage auf, wie diese Berechnung zustandekommt.
Jedes Objekt in der Baumstruktur besitzt einen 24 Byte großen Eintrag, durch den es definiert ist. Wie dieser Eintrag im einzelnen aufgebaut ist, werden wir in der nächsten Ausgabe ausführlich erklären und uns mit ihrer Benutzung beschäftigen.
Diesmal benötigen wir nur die Bytes 12, 13, 14 und 15 der Tabelle für die Ptadr-Routine, um die Adresse der sogenannten TEDINFO zu bekommen. Byte 12, 13, 14 und 15 beinhalten einen Zeiger auf die Objektspezifikation, d.h. hier steht die Adresse für die TEDINFO. Da der ATARI ST intern mit 32-Bit arbeitet, benötigen wir vier Bytes — also ein Langwort — und müssen einen LPEEK-Befehl auf die Summe von Objektadresse und 12 verwenden. Haben wir diese Adresse nun erhalten, stellt sich zunächst einmal die Frage, was ist überhaupt eine TEDINFO und wozu braucht man sie?
Box_undraw — Schließen der Dialogbox (Zusammenfassung)
Box_undraw(Baumadresse%,X%,Y%,W%,H%)
Diese Routine bildet das genaue Gegenteil zur Box__draw-Routine. In ihr werden alle nötigen Aufrufe zum Schließen einer Dialogbox vereinigt, wobei nochmals ein Form_center-Aufruf benutzt wird, für den Fall, daß die Big-Koordinaten inzwischen verlorengegangen sind. Natürlich könnte man sie auch Zwischenspeichern, aber das würde bei Verwendung mehrerer Dialogboxen zuviel Aufwand bedeuten, und außerdem ist diese Methode sicherer und universeller. Bei den Form_dial-Aufrufen kann ebenfalls wieder einer weggelassen werden (Flag%=2). Ansonsten werden als Parameter wieder nur die Baumadresse und die Littl-Koordinaten übergeben.
Undo_objc — Objektstatusflag löschen
Undo_objc(Baumadresse%,Obj_index%,maske%)
Auf diese Routine wird in der nächsten Ausgabe noch ausführlich eingegangen. Hier sei nur soviel gesagt, daß sie in unserem Falle zum Deselektieren der Buttons benutzt wird. Dazu muß der Parameter den Wert 1 haben. Weitere Parameter sind wieder die Baumadresse und der Objektindex.
Rsrc_free — Freigeben des Resourcespeicherplatzes
Rsrc_free
Diese Routine ist endlich mal wieder eine reguläre AES-Routine, nachdem Sie mit unseren eigenen nun eine ganze Zeit lang vorliebnehmen mußten. Rsrc_free wird allzu gerne am Ende des Programmes vergessen. Durch sie wird der durch das Resource belegte Speicherplatz wieder freigegeben. Vergißt man sie, kann es nach mehreren Programmaufrufen zu einem „Out of memory“ (kein Speicherplatz mehr vorhanden) kommen, da jedesmal erneut Speicherplatz beim Laden der Resourcen reserviert wird. Allein deswegen empfiehlt sich beim Rsrc_load-Aufruf die Fehlerabfrage.
Nun, die TEDINFO ist wiederum eine Tabelle, die aus 13 Worten bzw. 26 Byte besteht. In ihr sind alle wichtigen Daten für eine Textein- und ausgabe definiert. Um den Textstring aus einem EDIT-Feld zu bekommen, benötigt man die ersten vier Bytes (te_ptext) der TEDINFO. Diese enthalten die Adresse des schon lang ersehnten Textstrings, auf den wir schritt-bzw. zeigerweise zugearbeitet haben. Die Adresse wird dann von der Prozedur zurückgegeben.
Cursor am Textanfang
Zusätzlich haben wir in die Ptadr-Routine noch die Möglichkeit eingebaut, ein Textfeldeintrag zu löschen und somit den Cursor an den Anfang des EDIT-Feldes zu setzen (siehe ST-Ecke März ’87). Gesteuert wird dies mit dem Parameter Flag%. Hat er den Wert 1, so wird das Textfeld gelöscht, und der Cursor steht am Anfang. Alle anderen Werte bewirken, daß ein vorhandener Text erhalten bleibt. So kann man zum Beispiel im Resource Construction Set schon einen Text vorgeben, der dann nur nach Bedarf entweder im Programm oder mit der Escape- bzw. Back-space-Taste gelöscht wird.
Get_dialogtext — Auslesen des Textstrings
Get_dialogtext(Textadresse%,*Text%)
Auch diese Routine ist selbst geschrieben und dient lediglich dazu, den Textstring aus dem Speicher auszulesen. Übergeben wird die Textanfangsadresse, die man zuvor durch die Ptadr-Routine erhalten hat. In einer Schleife wird dann Zeichen für Zeichen ausgelesen und zu einem Textstring zusammengefügt. Da man durch den PEEK-Befehl lediglich ASCII-Werte erhält, müssen diese durch CHR$ beim Zusammenfügen in Buchstaben konvertiert werden.
Die Schleife läuft solange, bis sie den Wert 0 ausliest, der immer am Ende eines Textfeldes steht. Zurück erhält man den fertigen Textstring zur weiteren Verwendung.
Box_draw — Zeichnen der Dialogbox (Zusammenfassung)
Box_draw(Baumadresse%,X%,Y%,W%,H%)
In dieser Routine werden alle drei bzw. vier Prozeduraufrufe zusammengefaßt, die man zum Zeichnen einer Dialogbox benötigt. Nach Belieben kann dabei der Form_dial-Aufruf mit Flag%= 1 aus oben beschriebenen Gründen weggelassen werden. Man spart also Platz und gewinnt Übersicht, wenn man statt der einzelnen Aufrufe nur noch diese Routine aufruft.
Als Parameter werden die Baumadresse und die und die Littl-Koordinaten für die Form_dial-Routine benötigt.
Zum Programm
Das Programm selbst ist, wie man sieht, gar nicht so lang. Den Löwenanteil machen die Variablendefinition am Anfang und die eigentlichenProzeduren am Ende aus. Nach dem Start erscheint zuerst die erste Box, in die man ein Datum eingeben kann. Anschließend erscheint nach dem Anklicken des Buttons „weiter“ die zweite Box, die zwei EDIT-Felder enthält. Hier lassen sich zwei beliebige Texte eingeben. Als Ausgang aus der Box gibt es hier die Möglichkeiten des Zurückverzweigens in die erste Box (Ex_obj% = Dialog1) oder des Beendens des Programmes (Ex_obj%=Bye).
Wichtig ist das Deselektieren des Buttons, mit dem man die Dialogbox verlassen hat, da dieser sonst bei einem erneuten Aufruf noch selektiert ist und invers (also schwarzer Hintergrund) mit weißer Schrift) dargestellt ist. Am besten deselektiert man gleich nach dem Schließen der Dialogbox automatisch den Button, da man es so nicht vergessen kann.
Nach dieser ersten Einführung werden wir uns im nächsten Heft näher mit der Manipulation des Objektstatus und der Objektflags beschäftigen. Eine Routine (Undo_objc) wurde ja bereits diesmal verwendet, aber noch nicht näher erklärt. Probieren Sie ruhig ein bißchen mit den vorhandenen Routinen herum, indem Sie eigene neue Dialogboxen entwerfen und programmieren. Sie werden sehen, wie leicht man nun Eingabemasken etc. erstellen kann, ohne eine aufwendige Eingaberoutine schreiben zu müssen, da man ja schon im RCS die Länge der Textstrings und die Art der Zeichen begrenzen kann.
(HE)
' *********************************
' * *
' * Dialogboxen in GFA-BASIC *
' * *
' * Teil I *
' * HE *
' * *
' *********************************
'
Baum1=0 ! TREE
Baum2=1 ! TREE
Datum=1 ! OBJECT in TREE #0
Weiter=4 ! OBJECT in TREE #0
Txt1=1 ! OBJECT in TREE #1
Txt2=2 ! OBJECT in TREE #1
Dialog1=6 ! OBJECT in TREE #1
Bye=5 ! OBJECT in TREE #1
'
Gosub Rsrc_load(" juni87.rsc", *Fehler%
If Fehler%=0 Then
Print "RSC-Ladefehler"
End
Endif
'
Gtype%=0
Gindex%=Baum1
Gosub Rsrc_gaddr(Gtype%,Gindex% *Baum1_adr%)
Obj_index%=Datum
Flag%=0 ! Cursor nicht zurücksetzen
Gosub Ptadr(Bauml_adr%,Obj_index%,Flag%,*Txt _adr%)
'
While Ex_obj%<>Bye
Gosub Box_draw(Baum1_adr%,0,0,0,0)
Gosub Form_do(Baum1_adr%,Datum,*Ex_obj%)
Gosub Box_undraw(Baum1_adr%,0,0,0,0)
Gosub Undo_objc(Baum1_adr%,Ex_obj%,1)
Gosub Get_dialogtext(Txt_adr%.*Dat$)
Datum$=Left$(Dat$,2) + ". "+Mid$(Dat$,5,2) + ". "+Right$(Dat$,4)
Print Datum$
'
Gtype%=0
Gindex%=Baum2
Gosub Rsrc_gaddr(Gtype%,Gindex%,*Baum2_adr%)
Obj_index%=Txt1
Flag%=1 ! Cursor zurücksetzen
Gosub Ptadr(Baum2_adr%,Obj_index%, Flag%, *Txt_adr2%)
Obj_index%=Txt2
Gosub Ptadr(Baum2_adr%,Obj_index%,Flag%, *Txt_adr3%)
'
Gosub Box_draw(Baum2_adr%,0,0,0,0)
Gosub Form_do(Baum2_adr%,Txt1,*Ex_obj%)
Gosub Box_undraw(Baum2_adr%,0,0,0,0)
Gosub Undo_objc(Baum2_adr%,Ex_obj%,1)
Wend
'
Gosub Get_dialogtext(Txt_adr2%,*Txt1$)
Print Txt1$
Gosub Get_dialogtext(Txt_adr3%,*Txt2$)
Print Txt2$
'
Gosub Rsrc_free
End
'
' P R O C E D U R E S
'
Procedure Rsrc_load(Rscname$, Aes_return%)
'
Lpoke Addrin,Varptr(Rscname$)
Gemsys 110
*Aes_return%=Dpeek(Gintout ) ! Fehlerabfrage
Return
'
Procedure Rsrc_gaddr(Gtype%,Gindex%,Aes_adr% )
'
Dpoke Gintin,Gtype%
Dpoke Gintin+2,Gindex%
Gemsys 112
Aes_return%=Dpeek(Gintout) ! Fehlerabfrage
*Aes_adr%=Lpeek(Addrout)
Return
'
Procedure Form_center(Baum%, F_cx%, F_cy%, F_cw%, F_ch%)
'
Lpoke Addrin, Baums%
Gemsys 54
*F_cx%=Doeek(Gintout+2)
*F_cy%=Dpeek(Gintout+4)
*F_cw%=Dpeek(Gintout+6)
*F_ch%=Dpeek(Gintout+8)
Return
'
Procedure Form_dial(Flag%,Littlx%,Littly%,Littlw%,Littlh%,Bigx%,Bigy%,Bigw%,Bigh%)
'
Dpoke Gintin,Flag%
Dpoke Gintin+2,Littlx*
Dpoke Gintin+4,Littly%
Dpoke Gintin+6,Littlw%
Dpoke Gintin+8,Littlh%
Dpoke Gintin+10,Bigx%
Dpoke Gintin+12,Bigy%
Dpoke Gintin+14,Bigw%
Dpoke Gintin+16,Bigh%
Gemsys 51
Aes_return%=Dpeek(Gintout ) ! Fehlerabfrage
If Flag%=3
Put Bigx%,Bigy%,Rette$
Endif
Return
'
Procedure Objc_draw(Tree%,Startob%,Depth%,Xclip%,Wclip%,Hclip%)
Get Xclip%,Yclip%,Xclip%+Wclip%+1,Yclip%+Hclip%+1,Rette$
Dpoke Gintin,Startob%
Dpoke Gintin+2,Depth%
Dpoke Gintin+4,Xc1ip%
Dpoke Gintin+6,Yclip%
Dpoke Gintin+8,Hclip%
Dpoke Gintin+10,Hc1ip%
Lpoke Addrin,Tree%
Gemsys 42
Aes_return%=Dpeek(Gintout) !Fehlerabfrage
Return
'
Procedure Form_do(Tree%,Startob%,Aes_return%)
'
Dpoke Gintin,Startob%
Lpoke Addrin,Tree%
Gemsys 50
*Aes_return%=Dpeek (Gintout) ! Exit-Objekt
Return
'
Procedure Ptadr(Tree%,Obj_index%,Flag%,Txt_adresse)
Te_ptext=0
Obj_adresse%=Tree%+24*Obj_index%
Tedinfo_adresse%=Lpeek(Obj_adresse%+123
Txt_adresse%=Lpeek(Tedinfo_adresse%+Te_ptext )
If Flag%=1 Then
Poke Txt_adresse%,0
Endif
*Txt_adresse=Txt_adresse%
Return
'
Procedure Get_dialogtext(Txt_adr%,Txt%)
'
I=0
Txt$ = " "
While Peek(Txt_adr%+I)<>0
Zeichen=Peek(Txt_adr%+I)
Txt$ = Txt$+Chr$(Zeichen)
Inc I
Wend
*Txt% = Txt$
Return
'
Procedure Box_draw(Tree%,X%,Y%,W%,H%)
'
Gosub Form_center(Tree%,*Fo_cx%,*Fo_cy%,*Fo_cw%,*Fo_ch%)
Gosub Form_dial(0,X%,Y%,W%,H%,Fo_cx%,Fo_cy%,Fo_cw%,Fo_ch%)
Gosub Form_dial(1,X%,Y%,W%,H%,Fo_cx%,Fo_cy%,Fo_cw%,Fo_ch%)
Gosub Objc_draw(Tree%,0,8,Fo_cx%,Fo_cy%,Fo_cw%,Fo_ch%)
Return
'
Procedure Box_undraw(Tree%,X%,Y%,W%,H%)
'
Gosub Form_center(Tree%,*Fo_cx%,*Fo_cy%,*Fo_cw%,*Fo_ch%)
Gosub Form_dial(2,X%,Y%,W%,H%,Fo_cx%,Fo_cy%,Fo_cw%,Fo_ch%)
Gosub Form_dial(3,X%,Y%,W%,H%,Fo_cx%,Fo_cy%,Fo_cw%,Fo_ch%)
Return
'
Procedure Undo_objc(Tree%,Obj_index%,Maske%)
'
Obj_adresse%=Tree% + 24*Obj_index%
Aus = Dpeek(Obj_adresse%+10)
Dpoke Obj_adresse% + 10.Aus And Not Maske%
Return
procedure Rsrc_free
Gemsys 111
Aes_return%=Dpeek(Gintout) ! Fehlerabfrage
Return