Form_do-Routine: Eingabe mal anders

Die form_do-Routine des AES ist beim Arbeiten mit Dialogboxen ein praktisches Hilfsmittel, um die Kommunikation des Atari ST mit dem Benutzer zu erleichtern. FORM_DO übernimmt die komplette Verwaltung der Objekte innerhalb einer Dialogbox. Was aber, wenn man während des Dialogs zusätzliche Aktionen (z.B. eine eigene Tastaturabfrage) durchführen will?

Oder wenn man das Aussehen von “Standardobjekten” verändern will? Hier kommt man mit der eingebauten form_do-Routine nicht weiter, sondern muß sich eine eigene Eingabe programmieren.

Bei der Programmierung von Dialogen nimmt uns das GEM mit seiner form_do-Routine einen Großteil der Arbeit ab. Ist die Dialogbox einmal per Resource Construction Set erstellt, wird nach dem Zeichnen dieses Objekts (mit Hilfe von objc_draw) einfach die form_do-Routine des AES aufgerufen, und der Dialog mit dem Benutzer läuft automatisch ab. Das Hauptprogramm erhält erst wieder die Kontrolle, wenn die Dialogbox über ein EXIT- oder TOUCHEXIT-Objekt verlassen worden ist.

Vielleicht haben Sie sich aber schon die Frage gestellt, wie es manche Programme (z.B. das DISKUS-Diskutility oder der TEMPUS-Text-Editor) realisieren, die Buttons innerhalb einer Dialogbox auch über die Tastatur zu erreichen. Dies ist nur über eine neue Eingaberoutine möglich, die die vorhandene form_do-Routine ersetzt und neue Funktionen ermöglicht.

Was muß eine solche Eingaberoutine leisten? Zunächst müssen Eingaben oder Änderungen, die über die Tastatur oder die Maus hervorgerufen werden, auf dem Bildschirm dargestellt werden. Wird also eine Taste gedrückt, muß das der Taste entsprechende alphanumerische Zeichen in das aktuelle Eingabefeld der Dialogbox übertragen werden. Anschließend muß der Eingabe-Cursor auf die nächste Zeichenposition gesetzt werden. Handelt es sich bei der gedrückten Taste um die Tabulator- oder eine Cursor-Taste, muß ein Wechsel der Eingabeposition oder des -feldes erfolgen. Weiterhin muß sich der Programmierer darum kümmern, daß der Cursor innerhalb von Eingabefeldern an der richtigen Stelle dargestellt wird.

Schließlich müssen auch Mausaktionen überwacht werden. Wird ein EXIT- oder TOUCHEXIT-Button angeklickt, muß der Dialog beendet werden. Handelt es sich um einen Radio-Button, muß dies insofern berücksichtigt werden, als nicht nur der Status des angeklickten Buttons geändert werden muß, sondern auch andere Radio-Buttons einen neuen Objektstatus erhalten müssen.

Sie sehen, es gibt viel zu beachten. Glücklicherweise besitzt das AES genügend Unterroutinen, um bei der Verwendung einer eigenen Dialogroutine die Überwachung der oben aufgeführten Eingaben zu erleichtern. Insbesondere spreche ich damit die Funktionen form_keybd, form_button und objc_edit an. In Verbindung mit diesen (leider häufig nur unzureichend dokumentierten) AES-Routinen läßt sich eine Eingaberoutine formulieren, die einige neue Möglichkeiten zur Verwaltung von Dialogen bietet und vom äußerem Erscheinungsbild her wie eine “normale” Dialogbox wirkt.

Damit die folgenden Ausführungen nicht graue Theorie bleiben, soll anhand des Beispielprogramms DIALOG aufgezeigt werden, wie die Programmierung einer eigenen form_do-Routine vonstatten gehen kann. DIALOG stellt eine Dialogbox auf dem Bildschirm dar, die aus zwei Eingabefeldern, zwei Radio-Buttons sowie einem “OK"- und einem "ABBRUCH"-Button besteht. Die Buttons können wie üblich über die Maus bedient werden, und auch sonst bestehen auf den ersten Blick keine Unterschiede zu anderen Dialogboxen.

Wie sieht es auf den zweiten Blick aus? Nun, Radio-Button 1 kann nicht nur über die Maus, sondern auch über die Tastenkombination [ALTERNATE] [1] betätigt werden, Radio-Button 2 ist über [ALTERNATE] [2] ansprechbar. Darüber hinaus kann der "ABBRUCH"-Button über die [Undo]-Taste erreicht werden.

Das ausführlich kommentierte Assembler-Listing zu DIALOG.PRG möchte ich nun als Grundlage nehmen, um die Programmierung einer eigenen Dialogroutine zu erläutern. Wie bereits erwähnt, bilden die AES-Routinen form_keybd und form_button das Kernstück des Programms. form_keybd ermöglicht es, in einer Dialogbox Tastatureingaben zu simulieren, mit form_button kann die Betätigung eines Mausknopfes simuliert werden. Damit man die Möglichkeit hat, während des eigentlichen Dialogs zusätzliche Aktionen vorzunehmen, geschieht die Abfrage von Tastatur und Maus nun nicht mehr über die eingebaute form_do-Routine des AES, die ja Manipulationen während des Dialogs nicht zuläßt, sondern über die evnt_multi-Routine. Allgemein können über evnt_multi diverse Benutzeraktionen überwacht werden. Um zu spezifizieren, worauf evnt_ multi konkret achten soll, wird ein Parameterwort übergeben, in dem je nach zu überwachender Aktion entsprechende Bits gesetzt sind. Nach diesem AES-Aufruf überwacht GEM für uns so lange Tastatur und Maus, bis eine Aktion (Tastendruck oder Betätigung der Maustaste) seitens des Benutzers erfolgt. Erst dann wird die Programmkontrolle wieder an das Hauptprogramm zurückgegeben. Ist dies geschehen, so finden sich in einem eigens für den evnt_multi-Aufruf errichteten Array (in unserem Fall ev_buff) Angaben über die Art der Aktion. Wie bereits beim Aufruf von evnt_multi werden diese Daten wieder durch einzelne Bits repräsentiert.

typedef struct
{
    int      ob_next;       /* -> nächstes Objekt */ 
    int      ob_head;       /* -> erstes Kind */
    int      ob_tail;       /* -> letztes Kind */
    unsigned int ob_type;   /* Objekttyp */ 
    unsigned int ob_flags;  /* Objektflags */ 
    unsigned int ob_state;  /* Objektstatus */ 
    char     *ob_spec;      /* Zeiger auf ergänzende Struktur */ 
    int      ob_x;          /* x-Position (rel. zum Parent-Objekt) */
    int      ob_y;          /* y-Position (rel. zum Parent-Objekt) */
    int      ob_width;      /* Breite */
    int      ob_height;     /* Höhe */
} OBJECT:

Tabelle 1: Organisation eines Objektes

DIALOG.PRG verzweigt nun, je nachdem, um welche Aktion es sich gehandelt hat, in eine Routine zur Behandlung von Mausaktionen oder kümmert sich um die Taste, die vom Anwender gedrückt wurde. Beschäftigen wir uns zunächst mit dem Fall, daß evnt_multi einen Tastendruck gemeldet hat. ASCII- und Scancode der gedrückten Taste werden uns im ev_buff-Array mitgeteilt. Liefert evnt_multi einen gültigen ASCII-Code zurück, handelt es sich um eine “normale” alphanumerische Eingabe, und das Zeichen kann direkt in die Dialogbox geschrieben werden. Ist der ASCII-Code jedoch Null, liegt also nur der Scancode der betätigten Taste vor, geht es nun darum, festzustellen, ob ein Button existiert, der durch diese Taste bedient werden kann.

Um Buttons über die Tastatur bedienen zu können, werden bei DIALOG.PRG Tastenkombinationen zusammen mit der [ALTERNATE]-Taste verwendet, da in diesem Fall von evnt_multi nur der Scancode der Taste, jedoch kein ASCII-Code zurückgeliefert wird. Natürlich muß man an geeigneter Stelle eine Information unterbringen, welcher Button durch welche Taste bedient werden kann. Es ist sehr praktisch, diese Zusatzinformation innerhalb der Objektdaten der Dialogbox unterzubringen. Wie ein Objekt organisiert ist, läßt sich in Tabelle 1 sehen [ 1 ].

Im Wort für den Objekttyp ist nur das Low-Byte belegt. Somit steht das High-Byte für eigene Anwendungen zur Verfügung. DIALOG.PRG macht sich dies zunutze, indem es bei Buttons, die über die Tastatur bedient werden können, im High-Byte des Objekttyps den Scancode der Taste erwartet, durch die der betroffene Button angesprochen werden kann. Das Programm durchsucht nun einfach den gesamten Objektbaum auf ein Objekt, bei dem als erweiterter Objekttyp der Scancode der Taste eingetragen ist, die gedrückt wurde. Findet sich ein solches Objekt nicht, wird zum Schleifenanfang zurückgekehrt und der Dialog fortgesetzt. Ist ein Objekt vorhanden, das über die gedrückte Taste angewählt werden kann, wird die Objektnummer berechnet und über evnt_button ein Mausklick auf dieses Objekt simuliert. Der Effekt eines Tastendrucks in Verbindung mit der [ALTERNATE]-Taste ist somit der gleiche wie beim Anklicken eines Buttons mit der Maus.

Wurde ein alphanumerisches Zeichen (also ein Tastendruck ohne Kombination mit der [ALTERNATE]-Taste) eingegeben. wird mit den ASCII-und Scancodes für dieses Zeichen zunächst die form_keybd-Routine aufgerufen, die in der Lage ist, diesen Tastendruck für unsere Dialogbox aufzuarbeiten. Handelte es sich bei der gedrückten Taste um eine Cursor- oder die Tabulatortaste, liefert uns form_keybd die Nummer des Eingabefeldes zurück, in der wir nun den Text-Cursor positionieren müssen. Zusätzlich bekommen wir in diesem Fall eine Null als Rückgabewert, was bedeutet, daß keine Taste betätigt wurde, um deren ASCII-Darstellung wir uns kümmern müßten.

Erhalten wir keine Null zurück, sondern einen positiver Wert, so ist das Eingabefeld zwar das gleiche geblieben, aber dafür müssen wir an der aktuellen Cursor-Position ein ASCII-Zeichen eintragen. Dies geschieht mit Hilfe von objc_edit. Diese Funktion erlaubt es, Texteingaben in einem Formular vorzunehmen. Nach Aufruf dieser Routine mit dem ASCII-Code der gedrückten Taste wird das Zeichen in der Dialogbox dargestellt. Anschließend liefert uns objc_edit die neue Position des Text-Cursors zurück, der ja jetzt um eine Stelle nach rechts gerückt ist.

Falls evnt_multi abgebrochen wurde, weil ein Maus-Button betätigt wurde, ist zunächst zu prüfen, ob sich der Maus-Cursor überhaupt innerhalb der Dialogbox befindet. Hierzu können wir die objc_find-Funktion heranziehen. Die Koordinaten des Mauszeigers, die objc_find übergeben werden müssen, werden uns von evnt_multi in ev_buff zur Verfügung gestellt. Liefert objc_find einen Wert größer als Null zurück, befand sich der Mauszeiger innerhalb der Dialogbox. Andernfalls wird als Fehlersignal ein Glockenton ausgegeben, so wie es auch die “normale” form_do-Routine macht.

typedef struct {
    int (*ub_code) (); /* Zeiger auf die eigene Funktion */
    long ub_parm; /* ein optionaler Parameter */
} USERBLK;

Tabelle 2: Die USERBLK-Struktur

Wurde ein Objekt innerhalb der Dialogbox angeklickt, wird AES dieser Umstand mittels form_button mitgeteilt. Das GEM übernimmt den Rest der Arbeit, kümmert sich also z.B. darum, ob es sich beim angeklickten Objekt um einen Radio-Button handelt. In diesem Fall wird nicht nur der selektierte Button invertiert, sondern die restlichen Radio-Buttons werden deselektiert. Handelte es sich beim selektierten Objekt um einen Exit-Button, liefert form button einen Wert von Null zurück. Ist dies der Fall, wird der Dialog beendet.

Wurde ein Objekt ausgewählt, das keinen Exit-Status besitzt, muß zunächst geprüft werden, ob es überhaupt selektiert werden darf und es sich nicht z.B. um einen String handelt. Stellt das angeklickte Objekt ein Eingabefeld dar, muß der Text-Cursor auf dieses Feld plaziert werden. Hier hilft die objc_edit-Routine weiter. Zunächst wird der Text-Cursor an der alten Stelle entfernt und anschließend an der neuen Eingabeposition dargestellt.

Nun noch zur Darstellung eigener Objekttypen, wie im Fall von DIALOG dem String, der von einer abgerundeten Box umgeben ist. Will man die Zeichenroutinen des AES umgehen und das Aussehen von Objekten weitgehend selber bestimmen, muß man mit benutzerdefinierten Objekten (G_USERDEF bzw. G_PROGDEF) arbeiten. Bei Objekten dieser Art zeigt ob_spec (s.o.) auf eine USER BLK-Struktur (s. Tabelle 2). Trifft das AES beim Erstellen eines Dialogs auf diesen Objekttyp, wird die Objektdarstellung nicht vom AES übernommen, sondern stattdessen eine Routine aufgerufen, deren Adresse vom Programmierer in der obigen Objektstruktur festgelegt werden kann. DIALOG.PRG nutzt nun VDI-Routinen (nur solche dürfen beim Zeichnen eigener Objekte aufgerufen werden!) dazu, Text und Rahmen des ersten Strings der Dialogbox in einem eigenen Format, also mit abgerundeten Ecken, darzustellen. Natürlich sind an dieser Stelle die verschiedensten Manipulationen denkbar.

Eine Frage ist jedoch noch offen geblieben: Wie bringe ich im High-Byte des Objekttyps eigene Informationen unter? Hier kommt es auf das verwendete Resource Construction Set an. Die Methode, den Objekttyp für eigene Daten zu nutzen, wird z.B. durch das Resource Construction Set von Kuma unterstützt. Hier hat der Anwender die Möglichkeit, für jedes Objekt einen sogenannten “erweiterten Objekttyp” (extended object type) anzugeben. Die Zahl, die man an dieser Stelle einträgt, findet sich im High-Byte des Objekttyps wieder.

Soweit meine Erläuterungen zur Programmierung einer eigenen form_do-Routine. Weitere Informationen können dem kommentierten Programm-Listing entnommen werden. Auf die GEM-Routinen. die zur Darstellung einer Dialogbox benötigt werden, bin ich nicht näher eingegangen, da diese Problematik bereits des öfteren in zurückliegenden Ausgaben des ST-Magazins angesprochen wurde. Der Einbau der vorgestellten Routine in eigene Programme gestaltet sich recht einfach, da im Grunde genommen nur der Aufruf der form_do-Routine des AES durch die neue Routine ersetzt werden muß.

Es dürfte keine große Schwierigkeit darstellen, die Grundidee der vorgestellten Dialogverwaltung in andere Programmiersprachen zu übertragen, da DIALOG.PRG in der Hauptsache Gebrauch von Systemroutinen macht, die ja in Hochsprachen ähnlich wie in Assembler angesprochen werden.

[1]: Jankowski, Reschke, Rabich: Atari ST Profibuch (Sybex-Verlag)

******************************
*    neue form_do-Routine    *
* mit erweiterten Funktionen *
*   1989 by Uwe Seimet       *
*  (c) MAXON Computer GmbH   *
******************************

*für die wenigen Systemaufrufe 
GEMDOS  = 1 
MSHRINK = 74
BIOS    = 13
BCONOUT = 3

        move.l sp,a0
        lea stack+400,sp    ;Stackpointer initiali. 
        move.l 4(a0),a0     ;Pointer auf Basepage 
        move.l 12(a0),a1    ;Länge des TEXT-Segments 
        add.l 20(a0),a1     ;Länge des DATA-Segments 
        add.l 28(a0),a1     ;Länge des 'BSS-Segments 
        lea $100(a1),a1     ;256 Bytes für Basepage
        move.l a1,-(sp) 
        move.l a0,-(sp) 
        clr -(sp)
        move #MSHRINK,-(sp)
        trap #GEMDOS        ;nicht benötigten Speicher rück
        lea 12(sp),sp
        tst.l d0            ;Fehler?
        bne error           ;ja-
        lea intin,a5        ;Pointer auf INTIN-Array
        lea intout,a6       ;Pointer auf INTOUT-Array 
        moveq #10,d0        ;appl_init
        move.l #$00010000,d1 
        bsr aes
        bmi.s error         ;Fehler-
        moveq #7 7,d0       ;graf_handle
        move.l #$00050000,d1 
        bsr aes 
        move.l a5,a0 
        moveq #9,d0 
.opn:   move #1,(a0)+
        dbra d0,.opn 
        move #2,(a0)
        moveq #100,d0       ;v_opnvwk
        lea contrl+2,a3 
        clr.l (a3)+ 
        move #11,(a3)
        move (a6),6(a3)     ;graf_handle
        bsr vdiinit
        move 6(a3),vdi_h    ;vdi_handle merken 
        move #7,(a5)        ;Objektzahl eintragen
fix:    moveq #114,d0       ;rsrc_obfix
        move.l #$01010100,d1
        lea objc000(pc),a0  ;Adresse der Objektdaten 
        bsr aesobj          ;Koordinaten umrechnen
        subq #1,(a5)
        bpl fix             ;nächstes Objekt,wenn vorhanden
        clr (a5)            ;Pfeil als Mauscursor
        moveq #78,d0        ;graf_mouse
        move.l #$01010100,d1 
        bsr aes
        lea objc000(pc),a4  ;Adresse der Dialogbox 
        moveq #2,d4         ;Nummer des ersten Eingabefeldes 
        bsr.s form_do       ;Dialog ausführen
        moveq #19,d0        ;appl_exit
        move.l #$00010000,d1 
        bsr aes
error:  clr -(sp)           ;das war's
        trap #GEMDOS

form_do:
        moveq #54,d0        ;form_center
        move.l #$00050100,d1 
        move.l a4,a0 
        bsr aesobj
        movem.l 2(a6),d5/d6 ;form_xy und form_wh 
        clr d2              ;FMD_START
        movem.l d5/d6,2(a5) 
        movem.l d5/d6,10(a5) 
        bsr.s form_dial
        moveq #1,d0         ;bis zu Ebene 1 zeichnen 
        move.l d0,(a5) 
        movem.l d5/d6,4(a5)
        moveq #42,d0        ;objc_draw
        move.l #$06010100,d1 
        move.l a4,a0
        bsr aesobj          ;Dialogbox darstellen
        bsr.s _form_do      ;zur neuen Dialogroutine 
        moveq #3,d2         ;FMD_FINISH
        movem.l d5/d6,2(a5) 
        movem.l d5/d6,10(a5) 
form_dial:
        moveq #51,d0        ;form_dial
        move.l #$09010100,d1 
        move d2,(a5) 
        bra aes

*neue form_do-Routine, Exit-Button wird in D7 zurückgeliefert 
_form_do:
        moveq #1,d0         ;Cursor einschalten 
        bsr objcedit
        move 2(a6),d3       ;Position des Cursors 
dloop:  move #1,2(a5)       ;warten auf Mausklick
        move #1,4(a5)       ;auf linken Button warten 
        move #1,6(a5)       ;gedrückter Mausbutton 
        moveq #25,d0        ;evnt_multi
        move.l #$10070100,d1
        move #3,(a5)        ;MU_KEYBD |MU_BUTTON
        lea ev_buff,a0
        bsr aesobj          ;Benutzeraktion abwarten
        btst #1,1(a6)       ;MU_BUTTON?
        bne.s button        ;ja-
        move 10(a6),d0      ;Scan- und ASCII-Code der Taste 
        tst.b d0            ;ASCII-Zeichen?
        bne.s noalt         ;ja-
        lsr #8,d0           ;Scancode ins low Byte
        move.l a4,a0 
uloop:  cmp.b 6(a0),d0      ;Button für Taste gefunden? 
        beq.s default       ;ja-
        tst (a0)            ;letztes Objekt erreicht
        beq.s noalt         ;ja-
        lea 24(a0),a0       ;nächstes Objekt prüfen 
        bra uloop 
default: sub.l a4,a0 
        move.l a0,d7
        divu #24,d7         ;ergibt Objektnummer
        move #1,12(a6)      ;für Simulation Mausklick 
        bra.s obj
noalt:  move 10(a6),2(a5)   ;eingegebenes Zeichen
        move d4,(a5)        ;aktuelles Eingabefeld
        clr 4(a5)
        moveq #55,d0        ;form_keybd
        move.l #$03030100,d1 
        move.l a4,a0 
        bsr aesobj
        move 2(a6),d7       ;neues Eingabefeld
        tst (a6)            ;Exit-Objekt betätigt?
        beq exit            ;ja-
        tst 4(a6)           ;Wechsel des Eingabefeldes
        beq.s newinput      ;ja-
        move 10(a6),2(a5)   ;eingegebenes Zeichen 
        move d3,4(a5)       ;aktuelle Cursorposition
        moveq #2,d0         ;Zeichen ausgeben
        bsr.s objcedit
        move 2(a6),d3       ;neue Cursorposition 
        bra dloop 
button: clr (a5)
        move #1,2(a5)       ;bis Ebene 1 suchen 
        move.l 2(a6),4(a5)  ;aktuelle Mausposition 
        moveq #43,d0        ;objc_find
        move.l #$04010100,d1 
        move.l a4,a0 
        bsr.s aesobj
        move (a6),d7        ;Objektnummer 
        bpi.s obj           ;Objekt wurde gefunden-
        move #$07,-(sp)     ;BEL 
        move #2,-(sp) 
        move #BCONOUT,-(sp) 
        trap #BIOS          ;Glockenton als Fehlermeldung
        addq.l #6,sp 
        bra dloop 
obj:    moveq #56,d0        ;form_button
        move.l #$02020100,d1 
        move d7,(a5)        ;angeklicktes Objekt
        move 12(a6),2(a5)   ;Anzahl der Mausklicks
        move.l a4,a0 
        bsr.s aesobj
        tst (a6)            ;wurde Exit-Objekt klickt
        beq.s exit          ;ja-
        move d7,d0 
        mulu #24,d0
        btst #3,9(a4,d0)    ;Objekt editierbar? 
        beq dloop           ;nein-
        cmp d7,d4           ;Wechsel des Eingabefeldes
        beq dloop           ;nein-
newinput:bsr.s exit         ;Cursor abschalten
        move d7,d4          ;neues Eingabefeld
        bra _form_do        ;Dialog fortführen
exit:   move d3,4(a5)       ;Cursorpos.
        moveq #3,d0
objcedit:move d4,(a5)       ;Nummer des Eingabefeldes
        move d0,6(a5) 
        moveq #46,d0        ;objc_edit
        move.l #$04020100,d1 
        move.l a4,a0 
aesobj: move.l a0,addrin
aes:    lea contrl,a0
        move d0,(a0) 
        movep.l d1,3(a0) 
        move.l #aespb,d1 
        move #$c8,d0
        trap #2             ;AES-Aufruf
        rts

vdi:    move vdi_h,contrl+12
vdiinit:move d0,contrl
        move.l #vdipb,d1 
        moveq #$73,d0
        trap #2             ;VDI-Aufruf
        rts

*Benutzerdefiniertes Objekt zeichnen 
draw:
        move.l 4(sp),a0
        move.l 10(a0),d0    ;x/y-Koordinaten
        sub.l #$00030000,d0
        move.l d0,ptsin
        add.l #$00060000,d0
        add.l 14(a0),d0
        move.l d0,ptsin+4
        lea contrl,a0
        move.l #$02000000,d0
        movep.l d0,3(a0)
        move #8,contrl+10
        moveq #11, d0       ;v_rbox
        bsr vdi             ;abgerundete Box zeichnen
        move.l 4 (sp),a0
        move.l 26(a0),a1    ;Pointer auf Textstring 
        lea intin,a2 
        clr d0
        clr d1
.loop:  move.b (a1)+,d0
        beq.s .end 
        move d0,(a2)+ 
        addq #1,d1 
        bra .loop 
.end:   move.l #$01000000,d0
        lea contrl,a1 
        movep.l d0,3(a1) 
        move d1,contrl+6 
        move.l 10(a0),ptsin 
        add #17,ptsin+2
        moveq #8,d0         ;v_gtext
        bra vdi

user:   dc.l draw
        dc.l spec000

*Daten für die Dialogbox
*-----------------------------------------
*verwendete Objekttypen 
BOX     = 20
BUTTON  = 26
STRING  = 24
FTEXT   = 29

objc000:.dc.w $ffff
        .dc.w $0001,$0007 
        .dc.w BOX 
        .dc.w $0000,$0010 
        .dc.l $00021100 
        .dc.w $0007,$0004 
        .dc.w $002b,$000f

        .dc.w $0002 
        .dc.w $ffff,$ffff 
        .dc.w STRING 
        .dc.w $0000,$0011
        .dc.l user  ;" Testdialog für neue form_do-Routine"
        .dc.w $0003,$0001 
        .dc.w $0025,$0801

        .dc.w $0003 
        .dc.w $ffff,$ffff 
        .dc.w FTEXT 
        .dc.w $0008,$0000
        .dc.l spec001       ;"Eingabefeld 1:
                              _____________"
        .dc.w $0009,$0005 
        .dc.w $0019,$0001

        .dc.w $0004 
        .dc.w $ffff,$ffff 
        .dc.w FTEXT 
        .dc.w $0008,$0000
        .dc.l spec002       ;"Eingabefeld 2:
                              _____________"
        .dc.w $0009,$0007 
        .dc.w $0019,$0001

        .dc.w $0005 
        .dc.w $ffff,$ffff 
        .dc.w $781a 
        .dc.w $0011,$0001
        .dc.l spec003       ;"Radiobutton 1"
        .dc.w $0007,$000a 
        .dc.w $000e,$0001

        .dc.w $0006 
        .dc.w $ffff,$ffff 
        .dc.w $791a 
        .dc.w $0011,$0000
        .dc.l spec004       ;"Radiobutton 2"
        .dc.w $0016,$000a 
        .dc.w $000e,$0001

        .dc.w $0007
        .dc.w $ffff,$ffff
        .dc.w BUTTON
        .dc.w $0007,$0000
        .dc.l spec005       ;"OK"
        .dc.w $000c,$000d 
        .dc.w $0009,$0001

        .dc.w $0000
        .dc.w $ffff,$ffff 
        .dc.w $611a 
        .dc.w $0025,$0000
        .dc.l spec006       ;"ABBRUCH"
        .dc.w $0016,$000d 
        .dc.w $0009,$0001

spec000:.dc.b " Testdialog für neue form_do-Routine",0

spec001:.dc.l txt001,plt001,val001 
        .dc.w $0003 
        .dc.w $0006 
        .dc.w $0000 
        .dc.w $1180 
        .dc.w $0000 
        .dc.w $ffff 
        .dc.w $000b,$001a 
txt001: .dc.b "@         ",0
plt001: .dc.b "Eingabefeld 1: _____________",0
val001: .dc.b "XXXXXXXXXX",0

spec002:.dc.l txt002,plt002,val002 
        .dc.w $0003 
        .dc.w $0006 
        .dc.w $0000 
        .dc.w $1180 
        .dc.w $0000 
        .dc.w $ffff 
        .dc.w $000b,$001a 
txt002: .dc.b "@         ",0
plt002: .dc.b "Eingabefeld 2: _____________",0
val002: .dc.b "XXXXXXXXXX",0

spec003:.dc.b "Radiobutton 1",0

spec004:.dc.b "Radiobutton 2",0

spec005:.dc.b "OK",0

spec006:.dc.b "ABBRUCH",0

*****************************
* Konvertiert durch RSCCONV *
*     Autor: Uwe Seimet     *
*      (C) 1989 by CCD      *
*****************************

* ------------------------------------------------

        data

aespb:  dc.l contrl,global,intin,intout,addrin, addrout

vdipb:  dc.l contrl,intin,ptsin,intout,ptsout

        bss

*diverse AES- und VDI-Arrays

contrl: ds.w 11

global: ds.w 15

intin:  ds.w 64

intout: ds.w 64

addrin: ds.w 64

addrout:ds.w 64

ptsin:  ds.w 64

ptsout: ds.w 64

ev_kuff:ds.w 8      ;Puffer für evnt_multi

vdi_h:  ds.w 1      ;VDI-Handle

        even

stack:  ds.l 100    ;eigener Stackbereich

Uwe Seimet
Links

Copyright-Bestimmungen: siehe Über diese Seite