home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / bbs / jet_conf / listbox.s < prev    next >
Text File  |  1993-04-12  |  52KB  |  1,629 lines
  1. **************************************************************************
  2. ; HNDLMENU-Modul
  3. ; 21.01.1993 by Jan Kriesten
  4. **************************************************************************
  5.  
  6.         .INCLUDE "OFFSET.SH"
  7.         
  8. *** Globale Variablen:
  9.  
  10.         ;*** Arbeitsbereich des Desktops:
  11.         .IMPORT desk
  12.  
  13.         ;*** MyDial-Variablen:
  14.         .IMPORT my_mousnumber, my_mousform, mygl_wbox, mygl_hbox
  15.  
  16. *** Globale Funktionen:
  17.  
  18.         ;*** Routinen zur Listbox-Behandlung:
  19.         .EXPORT listbox, HndlDial, dial_do, obj2item
  20.  
  21.         ;*** Scrollroutine (aus MISC.S):
  22.         .IMPORT scroll_area
  23.         
  24.         ;*** MyDial-Routinen:
  25.         .IMPORT open_dial, dial_draw, dial_move, close_dial
  26.         .IMPORT obj_edit, form_Keybd, mybeep, objc_rect
  27.         .IMPORT get_idx, get_obspec, do_state, undo_state
  28.  
  29.         ;*** Bibliotheksfunktionen:
  30.         .IMPORT form_button, graf_mouse, graf_slidebox, strncpy
  31.         .IMPORT EvntMulti, objc_find, objc_change, objc_draw, wind_update
  32.  
  33. **************************************************************************
  34. ; Routinen zur Listbox-Behandlung
  35. **************************************************************************
  36.  
  37.         .TEXT
  38.         
  39. ;-------------------------------------------------------------------------------
  40. ; Funktionsname:    HndlDial
  41. ;         ->    a0:    Zeiger auf Objektbaum
  42. ;            a1:    Zeiger auf RECT für die Ausgangsposition von Grow-/Shrinkbox
  43. ;            d0:    TRUE: Grow-/Shrinkboxen zeichnen, sonst FALSE
  44. ;            d1:    Default-Editfeld
  45. ;        <-    d0: Exit-Button, mit dem Dialog verlassen wurde (Bit 15 ist bei
  46. ;                Doppelklick gesetzt!)
  47. ;
  48. ; Die Funktion handelt eine Dialogbox unter Verwendung der Funktionen hndl_list
  49. ; open_dial, dial_draw, dial_do und dial_close vollständig ab. Sie ist eine
  50. ; an meine eigene dial_do-Routine angepaßte Version der Namensgleichen MyDial-
  51. ; Routine.
  52. ;
  53. HndlDial:
  54.         movem.l        d3/d4/a3/a4, -(sp)    ; Register retten
  55.         
  56.         movea.l        a0, a3                ; Tree sichern
  57.         movea.l        a1, a4                ; Rect-Adresse sichern
  58.         move.w        d0, d3                ; Grow/Shrink? sichern
  59.         move.w        d1, d4                ; Default-Edit-Objekt sichern
  60.         
  61.         link        a2, #-32            ; Lokale Variable anlegen
  62.             DIALINF        .EQU    -32        ; Offset der Variable
  63.  
  64.         ;*** Dialogbox öffnen:
  65.         pea            DIALINF(a2)            ; Adresse der DialInfo-Struktur auf den Stack
  66.         jsr            open_dial            ; MYDIAL: öffne Dialog
  67.         addq.l        #4, sp                ; Stack restaurieren
  68.  
  69.         ;*** Dialogbox zeichnen:
  70.         lea            DIALINF(a2), a0        ; Adresse der DialInfo-Struktur nach a0
  71.         jsr            dial_draw            ; MYDIAL: Dialog zeichnen
  72.  
  73.         ;*** Dialog abarbeiten:
  74.         lea            DIALINF(a2), a0        ; Adresse der DialInfo-Struktur nach a0
  75.         clr.l        a1                    ; keine Listbox
  76.         move.w        d4, d0                ; Default Edit-Objekt
  77.         jsr            dial_do
  78.         move.w        d0, d4                ; Rückgabe sichern
  79.         
  80.         ;*** SELECTED-Status beim Exit-Objekt löschen:
  81.         ext.l        d0                    ; suchen der Anfangsadresse des Objekts
  82.         move.l        d0, d1                ; d0 ist nur Hilfsvariable
  83.         add.l        d1, d1                ;\
  84.         add.l        d0, d1                ; >    d1 * 24 [ (d0 + d0 + d0) * 8 ]
  85.         lsl.l        #3, d1                ;/
  86.         andi.w        #$FFFE, 10(a0, d1.l); SELECTED löschen
  87.  
  88.         ;*** Dialogbox schließen:
  89.         movea.l        a4, a0                ; Bildschirmmitte für Grow-/Shrinkbox zeichnen
  90.         lea            DIALINF(a2), a1        ; Adresse der Dialinfo-Struktur
  91.         move.w        d3, d0                ; keine Grow-/Shrinkbox zeichnen
  92.         jsr            close_dial            ; MYDIAL: Dialog schließen
  93.  
  94.         ;*** Ende der Funktion:
  95.         move.w        d4, d0                ; Rückgabewert wieder setzen
  96.         unlk        a2                    ; Lokale Variablen entfernen
  97.         movem.l        (sp)+, d3/d4/a3/a4    ; Register restaurieren
  98.         rts                                ; und zurück
  99.  
  100. ;-------------------------------------------------------------------------------
  101. ; Funktionsname:    dial_do
  102. ;         ->    a0:    Zeiger auf Dialinfo-Struktur
  103. ;            a1:    Zeiger auf Listbox-Struktur
  104. ;            d0: Start-Editfeld
  105. ;        <-    d0: Exit-Button, mit dem Dialog verlassen wurde (Bit 15 ist bei
  106. ;                Doppelklick gesetzt!)
  107. ;
  108. ; Die Funktion handelt eine Dialogbox unter Verwendung der Funktionen hndl_list
  109. ; und dial_move vollständig ab. Sie ist eine erweiterung der MyDial-Funktion 
  110. ; dial_do.
  111. ;
  112. dial_do:
  113.         move.l        a2, -(sp)            ; Register retten
  114.         move.l        a3, -(sp)            ; "
  115.         
  116.         movea.l        a0, a3                ; Pointer auf DIALINFO sichern
  117.         movea.l        a1, a2                ; Pointer auf LISTBOX  sichern
  118.  
  119.         cmp.w        #-1, d7                ; war d7 -1?
  120.         bne            .loop                ; wenn nicht, dann ist die Parameter-
  121.                                         ; übergabe in Ordnung!
  122.         clr.l        a2                    ; sonst kein Pointer auf Listbox!
  123.         
  124. .loop:
  125. *** Abhandlung des Dialoges mit editieren, shortcuts und listen durch hndl_list:
  126.         movea.l        (a3), a0            ; Pointer auf Objektbaum übergeben
  127.         movea.l        a2, a1                ; Pointer auf LISTBOX übergeben
  128.         bsr            hndl_list            ; Dialog mit Listbox abarbeiten
  129.         move.w        d0, d2                ; Retten des Return-Buttons
  130.  
  131. ;*** suchen der Anfangsadresse des Exit-Objekts
  132.         movea.l        (a3), a0            ; Adresse des Dialogbaums holen
  133.         andi.l        #$00007fff, d0        ; Bit 15 (Doppelklick) löschen
  134.         move.l        d0, d1                ; d0 ist nur Hilfsvariable
  135.         add.l        d1, d1                ;\
  136.         add.l        d0, d1                ; >    d1 * 24 [ (d0 + d0 + d0) * 8 ]
  137.         lsl.l        #3, d1                ;/
  138.         move.w        6(a0, d1.l), d0        ; ob_type des Buttons 
  139.         
  140.         lsr            #8, d0                ; extended objecttype holen
  141.         cmpi.w        #17, d0                ; Dialmover?
  142.         bne            .ld_ende            ; wenn nicht, dann zurück
  143.  
  144.         ;*** Mauszeiger in Hand verwandeln:
  145.         clr.l        a0                    ; keine eigene Mausform
  146.         moveq.l        #4, d0                ; FLATHAND darstellen
  147.         jsr            graf_mouse            ; AES-Funktion ausführen
  148.         
  149. ;*** Dialogbox verschieben:
  150.         lea            desk, a0            ; Adresse des Desk-Arbeitsbereiches holen
  151.         move.w        6(a0), -(sp)        ; desk.h auf den Stack
  152.         move.w        4(a0), d2            ; desk.w nach d2
  153.         move.w        2(a0), d1            ; desk.y nach d1
  154.         move.w        (a0), d0            ; desk.x nach d0
  155.         movea.l        a3, a0                ; DIALINFO-Adresse nach a0
  156.         jsr            dial_move            ; MYDIAL: Dialog verschieben
  157.         addq.l        #2, sp                ; Stack aufräumen
  158.  
  159.         ;*** Mauszeiger in letzte Mausform zurück:
  160.         movea.l        my_mousform, a0        ; letzte Mausform
  161.         movea.l        (a0), a0            ; "
  162.         movea.l        my_mousnumber, a1    ; Nummer der letzten Mausform
  163.         move.w        (a1), d0            ; "
  164.         jsr            graf_mouse            ; AES-Funktion ausführen
  165.  
  166.         clr.w        d0                    ; 0 Start-Editobjekt        
  167.         bra            .loop                ; weiter
  168.  
  169. *** Ende von dial_do:
  170.  
  171. .ld_ende:
  172.         move.w        d2, d0                ; Exit-Button zurückgeben
  173.         
  174.         movea.l        (sp)+, a3            ; Register restaurieren
  175.         movea.l        (sp)+, a2            ; "
  176.         
  177.         rts
  178.  
  179. ;-------------------------------------------------------------------------------
  180. ; Funktionsname:    hndl_list
  181. ;         ->    a0:    Zeiger auf Objekt-Baum
  182. ;        ->    a1: Zeiger auf Listbox-Struktur
  183. ;        ->    d0:    Start-Editobjekt
  184. ;        <-    d0: Exit-Button, mit dem Dialog verlassen wurde (Bit 15 ist bei
  185. ;                Doppelklick gesetzt!)
  186. ;
  187. ; Eine Dialogbox wird soweit abgearbeit, daß Einträge in Editfelder vorgenommen,
  188. ; Shortcuts und Buttons behandelt und Clicks in Listboxen abgearbeitet
  189. ; werden.
  190. ;
  191. hndl_list:
  192.         movem.l        d3-d7/a3-a5, -(sp)    ; Register retten
  193.  
  194. ;*** Variablen initialisieren:        
  195.         movea.l        a0, a3                ; Zeiger auf Objektbaum retten
  196.         movea.l        a1, a4                ; Zeiger auf Listbox-Struktur retten
  197.         move.w        d0, d4                ; Start-Editfeld retten
  198.         
  199.         ;*** Bildschirmaktionen anderer Programme sperren:
  200.         moveq.l        #1, d0                ; BEG_UPDATE
  201.         jsr            wind_update            ; AES-Funktion ausführen
  202.         
  203.         ;*** Mauskontrolle übernehmen:
  204.         moveq.l        #3, d0                ; BEG_MCTRL
  205.         jsr            wind_update            ; AES-Funktion ausführen
  206.  
  207.         tst.w        d4                    ; war ein Editfeld ausgewählt?
  208.         bne            .no_search            ; wenn ja, dann brauchen wir nicht suchen
  209.  
  210.         moveq.l        #-2, d1                ; Vorwärts suchen
  211.         movea.l        a3, a0                ; Zeiger auf Dialogbaum nach a0
  212.         bsr            find_obj            ; Start-Editfeld suchen
  213.  
  214. .no_search:
  215.         move.w        d0, d4                ; Start-Editfeld in next_obj
  216.  
  217.         clr.l        d3                    ; aktuelles edit_obj initialisieren
  218.         moveq.l        #1, d7                ; cont auf TRUE setzen
  219.  
  220.         ;*** EvntStruct initialisieren:
  221.         lea            evnt_strct, a0        ; Adresse des evnt_strct-Feldes laden
  222.         move.l        #$00030002, (a0)    ; flags: MU_KEYBD|MU_BUTTON, maximal gezählte Tastendrücke: 2
  223.         move.l        #$00010001, 4(a0)    ; Maske: linke Maustaste, State: muß gedrückt sein
  224.         clr.l        8(a0)                ; keine Rechtecke und Flags für Maus        
  225.         clr.l        12(a0)
  226.         clr.l        16(a0)
  227.         clr.l        20(a0)
  228.         clr.l        24(a0)
  229.         clr.l        28(a0)                ; kein Timer
  230.         
  231. ;               *+++++*+++++* Schleife abarbeiten *+++++*+++++*
  232.  
  233. while:
  234.         tst.w        d7                    ; cont noch ungleich 0?
  235.         beq            .hl_ende            ; wenn nein, dann ende der Funktion
  236.         
  237.         tst.w        d4                    ; ist next_obj gleich Null?
  238.         beq            .l1                    ; wenn ja, dann kein Editfeld initialisieren
  239.         
  240.         cmp.w        d3, d4                ; und ist edit_obj != next_obj?
  241.         beq            .l1                    ; wenn ja, ebenfalls nix Editfeld initialisieren
  242.         
  243. ;*** Editfeld initialisieren:
  244.         move.w        d4, d3                ; edit_obj = next_obj setzen
  245.         clr.w        d4                    ; und next_obj auf 0 setzen
  246.  
  247.         move.w        d3, edit_obj        ; nur zum Übergeben der Adresse
  248.         move.w        d5, idx                ; "
  249.         
  250.         move.w        #-1, -(sp)            ; kein Window-Handle
  251.         pea            edit_obj            ; hier neues edit_obj eintragen
  252.         clr.w        -(sp)                ; Bildschirmausgaben sind erlaubt
  253.         move.w        #1, -(sp)            ; obj_edit initialiseren, Cursor einschalten
  254.         lea            idx, a1                ; Adresse des Indexes
  255.         clr.w        d2                    ; kein kreturn
  256.         clr.w        d1                    ; kein kstate
  257.         move.w        d3, d0                ; Objektnummer des aktuellen Edit-Objekts
  258.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  259.         jsr            obj_edit            ; MYDIAL: neue objc_edit-Routine
  260.         lea            10(sp), sp            ; Stack aufräumen
  261.  
  262.         move.w        edit_obj, d3        ; aktuelles Edit-Objekt zurückschreiben
  263.         move.w        idx, d5                ; aktuellen idx zurückschreiben
  264.  
  265. .l1:
  266. *** Event-Multi aufrufen:
  267.         ;*** jetzt kommt ein Event-Multi!
  268.         lea            evnt_strct, a0        ; Adresse des evnt_strct-Feldes laden
  269.         jsr            EvntMulti            ; AES-Funktion ausführen
  270.  
  271.         ;*** Rückgabe sichern:
  272.         move.w        d0, d6                ; Return-Wert von evnt_multi
  273.         lea            ev_mox, a0            ; Adresse des intout-Feldes laden
  274.         move.l        (a0), mox            ; mox, moy sichern
  275.         move.l        4(a0), mobutton        ; mobutton, kstate sichern
  276.         move.l        8(a0), kreturn        ; kreturn, breturn sichern
  277.  
  278. *** Überprüfen, ob ein Tastaturereignis aufgetreten ist:
  279.         btst.b        #0, d6                ; Bit 0 gesetzt (Tastaturereignis)?
  280.         beq            .mous_ev            ; wenn Zero-Flag, dann auf mbutton testen
  281.  
  282. *** Tastaturereignis abarbeiten:
  283.         move.w        d4, next_obj        ; nur zum Übergeben der Adresse
  284.  
  285.         ;*** form_Keybd aufrufen:
  286.         pea            kreturn                ; Adresse von kreturn auf den Stack
  287.         lea            next_obj, a1        ; Adresse von next_obj nach a1
  288.         move.w        kstate, -(sp)        ; Status der Sondertasten auf den Stack
  289.         move.w        kreturn, d2            ; Inhalt von kreturn nach d2
  290.         move.w        d4, d1                ; next_obj nach d1
  291.         move.w        d3, d0                ; edit_obj nach d0
  292.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  293.         jsr            form_Keybd            ; MYDIAL: neue form_keybd-Routine
  294.         addq.l        #6, sp                ; Stack aufräumen
  295.         
  296.         move.w        next_obj, d4        ; aktuelles next_obj zurückschreiben
  297.         move.w        d0, d7                ; Return-Wert ist cont
  298.         
  299.         ;*** Ist Eingabe in ein Editobjekt nötig?
  300.         tst.w        kreturn                ; ist kreturn 0?
  301.         beq            .no_editinput        ; wenn ja, dann keine Eingabe
  302.  
  303.         ;*** Eingabe in Edit-Objekt vornehmen:        
  304.         move.w        d3, edit_obj        ; nur zum Übergeben der Adresse
  305.         move.w        d5, idx                ; "
  306.         
  307.         move.w        #-1, -(sp)            ; kein Window-Handle
  308.         pea            edit_obj            ; hier neues edit_obj eintragen
  309.         clr.w        -(sp)                ; Bildschirmausgaben sind erlaubt
  310.         move.w        #2, -(sp)            ; Zeichen verarbeiten (ED_CHAR)
  311.         lea            idx, a1                ; Adresse des Indexes
  312.         move.w        kreturn, d2            ; kreturn
  313.         move.w        kstate, d1            ; kstate
  314.         move.w        d3, d0                ; Objektnummer des aktuellen Edit-Objekts
  315.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  316.         jsr            obj_edit            ; MYDIAL: neue objc_edit-Routine
  317.         lea            10(sp), sp            ; Stack aufräumen
  318.  
  319.         move.w        edit_obj, d3        ; aktuelles Edit-Objekt zurückschreiben
  320.         move.w        idx, d5                ; aktuellen idx zurückschreiben
  321.  
  322.         move.w        d3, d4                ; next_obj = edit_obj setzen
  323.  
  324.         bra            .mous_ev            ; weiter bei .mous_ev
  325.  
  326. .no_editinput:
  327.  
  328.         ;*** war die Eingabe vielleicht ein Shortcut für ein Exit-Objekt?
  329.         andi.l        #$0000FFFF, d3        ; d3 erweiteren
  330.         move.l        d3, d0                ; d0 ist nur Hilfsvariable
  331.         add.l        d0, d0                ;\
  332.         add.l        d3, d0                ; >    d0 * 24 [ (d3 + d3 + d3) * 8 ]
  333.         lsl.l        #3, d0                ;/
  334.         move.w        8(a3, d0.l), d0        ; ob_flags des Objekts
  335.  
  336.         btst.b        #2, d0                ; Bit 2 (EXIT) in ob_flags gesetzt?
  337.         beq            .mous_ev            ; wenn nicht, dann weiter bei .mous_ev
  338.  
  339.         cmp.w        d3, d4                ; und edit_obj != next_obj?
  340.         beq            .mous_ev            ; wenn nicht, dann weiter bei .mous_ev
  341.  
  342.         move.w        d3, d4                ; next_obj = edit_obj setzen
  343.         clr.w        d3                    ; edit_obj = FALSE setzen
  344.         clr.w        d7                    ; cont = FALSE setzen
  345.  
  346. .mous_ev:
  347.  
  348. *** Mausereignis abarbeiten:
  349.  
  350.         btst.l        #1, d6                ; war ein Mausereignis aufgetreten?
  351.         beq            .no_event            ; wenn nicht, dann weiter bei .no_event
  352.  
  353.         ;*** Suchen, auf welches Objekt ein Click ausgeführt wurde:
  354.         move.w        moy, -(sp)            ; y-Koordinate des Mausclicks
  355.         move.w        mox, d2                ; x-Koordinate des Mausclicks
  356.         moveq.l        #8, d1                ; Suchtiefe: MAX_DEPTH
  357.         clr.w        d0                    ; Startobjekt: 0
  358.         movea.l        a3, a0                ; Tree-Adresse
  359.         jsr            objc_find            ; AES-Funktion ausführen
  360.         addq.l        #2, sp                ; Stack restaurieren
  361.  
  362.         ;*** Rückgabe sichern:
  363.         move.w        d0, d4                ; Rückgabe ist neues next_obj
  364.         
  365.         ;*** Ist überhaupt eins gefunden worden?
  366.         bpl            .found                ; wenn ja, dann weiter bei .found
  367.  
  368.         ;*** kein Objekt gefunden:
  369.         jsr            mybeep                ; Piepser ausführen
  370.         clr.w        d4                    ; und next_obj auf 0 setzen
  371.         bra            .no_event            ; dann weiter mit .no_event
  372.         
  373. .found:
  374.         *** ist in eine Listbox geclickt worden?
  375.         cmpa.l        #0, a4                ; ist überhaupt eine Listbox vorhanden?
  376.         beq            .no_list            ; wenn nicht, dann weiter mit .no_list
  377.  
  378.         cmp.w        ROOT(a4), d4        ; gefundenes Objekt >= ROOT-Objekt der Listbox?
  379.         bmi            .no_list            ; wenn nicht, dann weiter mit .no_list
  380.         
  381.         cmp.w        DOWN(a4), d4        ; gefundenes Objekt <= DOWN-Arrow der Listbox?
  382.         bhi            .no_list            ; wenn nicht, dann weiter mit .no_list
  383.  
  384. *** Listbox bearbeiten:
  385.         lea            mk, a1                ; Adresse der mk-info-Struktur
  386.         movea.l        a4, a0                ; Listbox-Adresse nach a0
  387.         moveq.l        #4, d0                ; LIST_CLICK
  388.         bsr            listbox                ; Unterroutine zur List-Behandlung
  389.  
  390.         cmpi.l        #0, FUNC(a4)        ; ist eine Funktion vorhanden?
  391.         beq            .no_lfunc            ; wenn nicht, dann weiter bei .no_lfunc
  392.         
  393.         cmpi.w        #2, breturn            ; breturn == 2?
  394.         bne            .no_lfunc            ; wenn nicht, dann weiter bei .no_lfunc
  395.  
  396.         move.w        d4, d0                ; Angeclicktes Objekt        
  397.         movea.l        a4, a0                ; Listbox-Adresse nach a0
  398.         movea.l        FUNC(a4), a1        ; Funktionsadresse holen
  399.         jsr            (a1)                ; Funktion aufrufen
  400.  
  401. .no_lfunc:
  402.         clr.w        d7
  403.         bra            .no_event            ; weiter bei .no_event
  404.  
  405. .no_list:
  406.         ;*** Keine Listbox, dann form_button ausführen
  407.         lea            next_obj, a1        ; Adresse von next_obj
  408.         move.w        breturn, d1            ; clicks
  409.         move.w        d4, d0                ; next_obj
  410.         movea.l        a3, a0                ; Tree-Adresse
  411.         jsr            form_button            ; AES-Funktion ausführen
  412.         
  413.         move.w        d0, d7                ; return-Wert: 0 = EXIT Objekt;
  414.  
  415.         ;*** Bedingung für Ende des Dialoges erfüllt?
  416.         ;+++    cont = 0?
  417.         beq            .no_event            ; Edit-Cursor ausschalten und Schluß
  418.  
  419.         ;+++    next_obj EDITABLE?
  420.         move.w        next_obj, d4        ; neues next_obj
  421.         beq            .no_event            ; wenn nicht editable, dann .no_event
  422.  
  423.         ;+++    Auf Editobjekt geclickt
  424.         ;        _und_ erweiterter Typ 25
  425.         ;        _und_ breturn == 2?
  426.  
  427.         andi.l        #$0000FFFF, d4        ; d4 erweiteren
  428.         move.l        d4, d0                ; d0 ist nur Hilfsvariable
  429.         add.l        d0, d0                ;\
  430.         add.l        d3, d0                ; >    d0 * 24 [ (d3 + d3 + d3) * 8 ]
  431.         lsl.l        #3, d0                ;/
  432.         move.w        8(a3, d0.l), d1        ; ob_flags des Objekts
  433.         move.w        6(a3, d0.l), d0        ; ob_type des Objekts
  434.  
  435.         btst.l        #3, d1                ; Bit 3 (EDITABLE) in ob_flags gesetzt?
  436.         beq            .no_event            ; wenn nicht, dann gleich dort weiter
  437.  
  438.         lsr.w        #8, d0
  439.         cmpi.w        #25, d0
  440.         bne            .bear_edit            ; wenn nicht, dann weiter bei .bear_edit
  441.  
  442.         cmpi.w        #2, breturn            ; breturn == 2?
  443.         bne            .bear_edit            ; wenn nicht, dann weiter bei .bear_edit
  444.         
  445.         clr.w        d7                    ; cont auf 0 setzen
  446.         
  447.         bra            .no_event            ; Edit-Cursor ausschalten und Schluß
  448.  
  449. *** Bearbeiten eines Editfeldes:        
  450. .bear_edit:
  451.         ; muß am Cursor etwas geändert werden?
  452.         cmp.w        d3, d4                ; ist next_obj != edit_obj?
  453.         beq            .m2                    ; wenn nicht, dann weiter bei .m2
  454.  
  455.         ;*** Cursor im derzeitigen Editobjekt löschen:
  456.         move.w        d3, edit_obj        ; nur zum Übergeben der Adresse
  457.         move.w        d5, idx                ; "
  458.         
  459.         move.w        #-1, -(sp)            ; kein Window-Handle
  460.         pea            edit_obj            ; hier neues edit_obj eintragen
  461.         clr.w        -(sp)                ; Bildschirmausgaben sind erlaubt
  462.         move.w        #3, -(sp)            ; Cursor abschalten (ED_END)
  463.         lea            idx, a1                ; Adresse des Indexes
  464.         clr.w        d2                    ; keine Eingabe
  465.         move.w        kstate, d1            ; kstate
  466.         move.w        d3, d0                ; Objektnummer des aktuellen Edit-Objekts
  467.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  468.         jsr            obj_edit            ; MYDIAL: neue objc_edit-Routine
  469.         lea            10(sp), sp            ; Stack aufräumen
  470.  
  471.         move.w        idx, d5                ; aktuellen idx zurückschreiben
  472.  
  473.         move.w        d4, d3                ; edit_obj = next_obj
  474.         clr.w        d4                    ; und next_obj = 0 setzen
  475.  
  476. .m2:
  477.         ;*** Ausdehnung des Edit-Objekts berechnen:
  478.         clr.w        d1                    ; ??
  479.         lea            work, a1            ; RECT des Objekts
  480.         move.w        d3, d0                ; das aktuelle Editobjekt
  481.         movea.l        a3, a0                ; Tree-Adresse
  482.         jsr            objc_rect            ; MYDIAL: Ausdehnung berechnen
  483.  
  484.         ;*** Adresse des ob_spec des Edit-Objekts:
  485.         movea.l        a3, a0                ; Tree-Adresse
  486.         move.w        d3, d0                ; das aktuelle Editobjekt
  487.         jsr            get_obspec            ; MYDIAL: Zeiger auf ob_spec holen
  488.         movea.l        d0, a0
  489.  
  490.         ;*** Zeichensatzgröße Korrekt setzen:
  491.         cmpi.w        #5, 12(a0)            ; Fontgröße SMALL?
  492.         bne            .normal                ; wenn nicht, dann weiter bei .normal
  493.         
  494.         moveq.l        #6, d2                ; wbox setzen
  495.         bra            .switch                ; und weiter bei .switch
  496.  
  497. .normal:
  498.         move.w        mygl_wbox, d2        ; sonst normale Punktgröße
  499.  
  500.         ;*** Textausrichtung beachten:
  501. .switch:
  502.         move.w        work, d1            ; work.x nach d1
  503.  
  504.         cmpi.w        #1, 16(a0)            ; TE_RIGHT?
  505.         bne            .s1                    ; wenn nicht, dann weiter bei .s1
  506.  
  507.         moveq.l        #-1, d0                ; -1 wegen Stringende
  508.         add.w        26(a0), d0            ; + ob_spec->te_tmplen
  509.         mulu.w        d2, d0                ; das ganze mal wbox
  510.         add.w        work+4, d1            ; work.w dazuaddieren
  511.         sub.w        d0, d1                ; und das in d0 davon abziehen
  512.  
  513.         bra            .s2                    ; weiter bei .s2
  514.  
  515. .s1:
  516.         cmpi.w        #2, 16(a0)            ; TE_CNTR?
  517.         bne            .s2                    ; wenn nicht, dann weiter bei .s2
  518.  
  519.         moveq.l        #-1, d0                ; -1 wegen Stringende
  520.         add.w        26(a0), d0            ; + ob_spec->te_tmplen
  521.         mulu.w        d2, d0                ; das ganze mal wbox
  522.         move.w        work+4, d6            ; work.w nach d6
  523.         sub.w        d0, d6                ; und das in d0 davon abziehen
  524.         lsr.w        #1, d6                ; insgesamt noch durch 2 teilen
  525.         add.w        d6, d1                ; und zu d1 hinzuaddieren
  526.  
  527. .s2:
  528.         ;*** neuen idx berechnen:
  529.         ext.l        d5
  530.         move.w        d2, d0                ; wbox
  531.         lsr.w        #1, d0                ; wbox/2
  532.         move.w        mox, d5                ; ( x-Position des Mausclicks
  533.         sub.w        d1, d5                ; minus work.x
  534.         add.w        d0, d5                ; plus wbox/2 )
  535.         divu.w        d2, d5                ; durch wbox
  536.  
  537.  
  538.         ;*** neuer idx zu groß?
  539.         moveq.l        #-1, d0                ; -1 wegen Stringende
  540.         add.w        26(a0), d0            ; ob_spec->te_tmplen nach d0
  541.         cmp.w        d5, d0                ; idx größer als te_tmplen?
  542.         bpl            .not_greater        ; wenn nicht, dann weiter bei .not_greater
  543.  
  544.         move.w        d0, d5                ; idx = te_tmplen-1 setzen
  545.  
  546. .not_greater:
  547.  
  548.         ;*** absolute Cursorposition berechnen:
  549.         move.w        d5, d1                ; aktueller index
  550.         move.w        d3, d0                ; aktuelles Editobjekt
  551.         movea.l        a3, a0                ; Tree-Adresse
  552.         jsr            get_idx                ; MYDIAL: absolute Cursorposition berechnen
  553.         move.w        d0, d5                ; absoluten neuen idx sichern
  554.  
  555.         ;*** und noch Cursor an neuer Position zeichnen:
  556.         move.w        d3, edit_obj        ; nur zum Übergeben der Adresse
  557.         move.w        d5, idx                ; "
  558.         
  559.         move.w        #-1, -(sp)            ; kein Window-Handle
  560.         pea            edit_obj            ; hier neues edit_obj eintragen
  561.         clr.w        -(sp)                ; Bildschirmausgaben sind erlaubt
  562.         move.w        #2, -(sp)            ; Zeichen verarbeiten (ED_CHAR)
  563.         lea            idx, a1                ; Adresse des Indexes
  564.         clr.w        d2                    ; kein Zeichen verarbeiten
  565.         move.w        kstate, d1            ; kstate
  566.         move.w        d3, d0                ; Objektnummer des aktuellen Edit-Objekts
  567.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  568.         jsr            obj_edit            ; MYDIAL: neue objc_edit-Routine
  569.         lea            10(sp), sp            ; Stack aufräumen
  570.  
  571.         move.w        edit_obj, d3        ; aktuelles Edit-Objekt zurückschreiben
  572.         move.w        idx, d5                ; aktuellen idx zurückschreiben
  573.  
  574. .no_event:
  575.  
  576. *** Überprüfen, ob im aktuelles Editobjekt der Cursor ausgeschaltet werden muß:
  577.         tst.w        d7                    ; Dialogende?
  578.         beq            .end_obedit            ; wenn ja, dann Cursor abschalten
  579.         
  580.         tst.w        d4                    ; oder next_obj != 0
  581.         beq            while                ; wenn nein, dann weiter bei while
  582.  
  583.         cmp.w        d3, d4                ; ist next_obj != edit_obj?
  584.         beq            while                ; wenn nicht, dann weiter bei while
  585.  
  586. .end_obedit:
  587.  
  588. *** Cursor im aktuellen Editobjekt abschalten:
  589.         move.w        d3, edit_obj        ; nur zum Übergeben der Adresse
  590.         move.w        d5, idx                ; "
  591.         
  592.         move.w        #-1, -(sp)            ; kein Window-Handle
  593.         pea            edit_obj            ; hier neues edit_obj eintragen
  594.         clr.w        -(sp)                ; Bildschirmausgaben sind erlaubt
  595.         move.w        #3, -(sp)            ; Cursor abschalten (ED_END)
  596.         lea            idx, a1                ; Adresse des Indexes
  597.         clr.w        d2                    ; keine Eingabe
  598.         move.w        kstate, d1            ; kstate
  599.         move.w        d3, d0                ; Objektnummer des aktuellen Edit-Objekts
  600.         movea.l        a3, a0                ; Zeiger auf Dialogbaum
  601.         jsr            obj_edit            ; MYDIAL: neue objc_edit-Routine
  602.         lea            10(sp), sp            ; Stack aufräumen
  603.  
  604.         move.w        edit_obj, d3        ; aktuelles Edit-Objekt zurückschreiben
  605.         move.w        idx, d5                ; aktuellen idx zurückschreiben
  606.  
  607.         bra            while                ; und wieder zu while verzweigen        
  608.  
  609. *** Ende der Funktion:
  610.  
  611. .hl_ende:
  612.         ;*** Mauskontrolle freigeben:
  613.         moveq.l        #2, d0                ; END_MCTRL
  614.         jsr            wind_update            ; AES-Funktion ausführen
  615.         
  616.         ;*** Bildschirmaktionen wieder erlauben:
  617.         clr.w        d0                    ; END_UPDATE
  618.         jsr            wind_update            ; AES-Funktion ausführen
  619.         
  620.         move.w        d4, d0                ; next_obj ist Exit-Objekt
  621.  
  622.         movem.l        (sp)+, a3-a5/d3-d7    ; Register restaurieren
  623.         rts                                ; und zurück
  624.  
  625.  
  626. ;-------------------------------------------------------------------------------
  627. *** Suchen eines Editobjekts:
  628. find_obj:
  629.         movem        d3-d6, -(sp)          ; Register retten
  630.         
  631.         moveq.l        #3, d4                ; flag für EDITABLE (Bit 3: 8)
  632.         move.w        #1, d5                ; Inkrement mit 1 vorbesetzen
  633.         moveq.l        #5, d6                ; flag für LASTOB (Bit 5: 32)
  634.  
  635.         ;*** Was ist zu tun?
  636.         addq.w        #1, d1                ; Rückwärts suchen?
  637.         beq            .case_1                ; ja, dann weiter bei .case_1
  638.         addq.w        #1, d1                ; Vorwärts suchen?
  639.         beq            .case_2                ; ja, dann weiter bei .case_2
  640.         addq.w        #1, d1                ; DEFAULT-Objekt suchen?
  641.         bne            .while                ; nein, dann eben doch Vorwärts suchen
  642.  
  643.         ;*** DEFAULT-Objekt suchen:
  644.         moveq.l        #2, d4                ; flag auf DEFAULT setzen
  645.         bra            .while                ; und suchen ...
  646.         
  647.         ;*** case FMD_BACKWARD:
  648. .case_1:
  649.         moveq.l        #-1, d5                ; dann um 1 dekrementieren
  650.  
  651.         ;*** case FMD_FORWARD:
  652. .case_2:
  653.         move.w        d0, d3                ; start der Suche ist Start-Objekt
  654.         add.w        d5, d3                ; + Inkrement
  655.         
  656.         ;*** jetzt kommt eine while-Schleife:
  657. .loop:
  658.         move.w        d3, d1
  659.         ext            d1
  660.         move.l        d1, d2
  661.         add.l        d2, d2
  662.         add.l        d1, d2
  663.         lsl.l        #3, d2
  664.         move.w        8(a0, d2), d1
  665.         
  666.         ;*** ob_flags & flag?
  667.         btst.b        d4, d1                ; ist BIT 'd4' in d1 gesetzt?
  668.         beq            .l1                    ; nein, dann weiter bei .l1
  669.     
  670.         move.w        d3, d0                ; aktuelles Objekt ist Rückgabewert
  671.         bra            fo_ende                ; und schluss ...
  672.  
  673. .l1:
  674.         ;*** ob_flags & LASTOBJ?
  675.         btst        d6, d1                ; ist Bit 'd6' in d1 gesetzt?
  676.         bne            fo_ende                ; ja, also letztes Objekt => ende
  677.  
  678.         add.w        d5, d3                ; counter erhöhen/erniedrigen
  679.         
  680. .while:
  681.         tst.w        d3
  682.         bpl.b        .loop                ; positiv oder null: => .loop
  683.  
  684. fo_ende:
  685.  
  686.         movem        (sp)+, d3-d6         ; Register restaurieren
  687.         rts        
  688.  
  689. ;-------------------------------------------------------------------------------
  690. ; Funktionsname:    listbox
  691. ;         ->    a0:    Zeiger auf Listbox-Struktur
  692. ;            a1: Zeiger auf mk-info-Struktur
  693. ;            d0:    flags (LIST_CLICK, LIST_INIT, LIST_DRAW)
  694. ;        <-    nichts.
  695. ;
  696. ; Eine Listbox wird abgearbeitet (Init, Draw und Click).
  697. ;
  698. listbox:
  699.         movem.l        d3-d7/a3-a5, -(sp)    ; Register retten
  700.         movea.l        a0, a3                ; Listbox-Adresse retten
  701.         movea.l        a1, a5                ; MKINFO-Adresse retten
  702.         move.w        d0, d7                ; Flags retten
  703.         
  704.         movea.l        TREE(a3), a4        ; Tree-Adresse sichern
  705.  
  706. VERKETTET        .EQU    2
  707.  
  708. ;           ############### flags & LIST_INIT ###############
  709.  
  710.         btst.l        #0, d7                ; LIST_INIT?
  711.         beq            .list_click            ; sonst .list_click abarbeiten
  712.         
  713.         move.w        ITEMS(a3), d0        ; Berechnen des Offsets des
  714.         ext.l        d0                    ; Item-Objekts
  715.         move.l        d0, d2                ; Offset in d2 berechnen
  716.         add.l        d2, d2                ; \
  717.         add.l        d0, d2                ;  > d2 * 24 
  718.         lsl.l        #3, d2                ; /
  719.         
  720.         ;*** Berechnen der sichtbaren Einträge:
  721.         move.w        OB_TAIL(a4, d2.l), d1    ; ob_tail von Item-Objekt
  722.         sub.w        OB_HEAD(a4, d2.l), d1    ; - ob_head
  723.         addq.l        #1, d1                    ; plus 1
  724.         move.w        d1, VIS_ITEMS(a3)        ; Anzahl der sichtbaren Einträge
  725.         
  726.         ;*** Maximale Position berechnen (in d6):
  727.         move.w        NUM_ITEMS(a3), d6        ; Anzahl der Elemente
  728.         sub.w        d1, d6                    ; minus Anzahl der sichtbaren Einträge
  729.         
  730.         ;*** Breite der Liste bestimmen:
  731.         move.w        OB_WIDTH(a4, d2.l), d0    ; ob_width nach d0
  732.         ext.l        d0                        ; auf Long erweitern
  733.         move.l        d0, d1                    ; und zusätzlich in d1 sichern
  734.         addq.l        #1, d0                    ; ein Pixel wird unten abgezogen
  735.         divu.w        mygl_wbox, d0            ; durch Zeichenbreite teilen
  736.         move.w        d0, WIDTH(a3)            ; in Listbox sichern
  737.         
  738.         ;*** Objekt-Breite notfalls korrigieren:
  739.         divu.w        mygl_wbox, d1            ; ob_width durch Zeichenbreite teilen
  740.         swap        d1                        ; Rest betrachten
  741.         tst.w        d1
  742.         bne            .n1                        ; wenn nicht 0, dann weiter bei .n1
  743.         
  744.         sub.w        #1, OB_WIDTH(a4, d2.l)    ; ob_width korrigieren
  745.  
  746. .n1:
  747.         ;*** ist list->first_item > max_pos?
  748.         cmp.w        FIRST_ITEM(a3), d6        ; Vergleich mit max_pos
  749.         bpl            .n2                        ; nicht größer, dann weiter bei .n2
  750.         
  751.         move.w        d6, FIRST_ITEM(a3)        ; sonst auf max_pos setzen
  752.         
  753. .n2:
  754.         ;*** ist list->first_item < 0?
  755.         tst.w        FIRST_ITEM(a3)            ; Vergleich auf 0
  756.         bpl            .n3                        ; wenn >= 0, dann weiter bei .n3
  757.     
  758.         clr.w        FIRST_ITEM(a3)            ; sonst auf 0 setzen
  759.             
  760. .n3:
  761.  
  762.         ;*** Adresse der Itemlist in Register schieben:
  763.         movea.l        ITEMLIST(a3), a5        ; Adresse nach a5
  764.  
  765. ;            ######+++++###### Schleife ######++++++######
  766.         clr.w        d4                        ; Schleifenzähler initialisieren
  767.         
  768. .loop1:
  769.         ;*** aktuelle Objektnummer berechnen:
  770.         moveq.l        #1, d5
  771.         add.w        d4, d5
  772.         add.w        ITEMS(a3), d5
  773.         ext.l        d5
  774.         
  775.         ;*** Status des Objektes ist nicht selektiert:
  776.         move.w        SEL_STATE(a3), d1        ; Art der Selektion nach d1
  777.         move.w        d5, d0                    ; Nummer des Objekts
  778.         movea.l        a4, a0                    ; Tree-Adresse nach a0
  779.         jsr            undo_state                ; MYDIAL: Status setzen
  780.  
  781.         ;*** Offset des aktuellen Objekts berechnen:
  782.         move.l        d5, d2
  783.         add.l        d2, d2
  784.         add.l        d5, d2
  785.         lsl.l        #3, d2
  786.         
  787.         ;*** ob_width des Objekts notfalls korrigieren:
  788.         move.w        OB_WIDTH(a4, d2.l), d0    ; ob_width nach d0
  789.         ext.l        d0                        ; auf Long erweitern
  790.         divu.w        mygl_wbox, d0            ; dividieren ...
  791.         swap        d0                        ; Rest betrachten
  792.         tst.w        d0
  793.         bne            .n4                        ; wenn nicht 0, dann weiter bei .n4
  794.         
  795.         sub.w        #1, OB_WIDTH(a4, d2.l)    ; ob_width korrigieren
  796. .n4:
  797.         move.w        OB_TYPE(a4, d2.l), d0    ; ob_type nach d0
  798.  
  799.         ;*** Adresse des Zielstrings holen:
  800.         
  801.         ;###### switch:
  802.         cmpi.w        #28, d0                    ; ist ob_type == G_STRING
  803.         beq            .sw1
  804.         
  805.         cmpi.w        #26, d0                    ; ist ob_type == G_BUTTON
  806.         beq            .sw1
  807.         
  808.         bra            .sw2                    ; sonst ist ob_type G_TEXT,
  809.                                             ; G_BOXTEXT, G_FTEXT oder G_FBOXTEXT
  810. .sw1:
  811.         movea.l        OB_SPEC(a4, d2.l), a0    ; Adresse des Textes
  812.         bra            .n5                        ; weiter bei .n5
  813.  
  814. .sw2:
  815.         movea.l        OB_SPEC(a4, d2.l), a0    ; Zeiger auf eine Tedinfo-Struktur
  816.         movea.l        (a0), a0                ; Adresse des Textes
  817.         
  818. .n5:
  819.         ;*** sichtbare Einträge in die Listbox kopieren:
  820.         move.w        d4, d0                    ; aktuelle Nummer
  821.         add.w        FIRST_ITEM(a3), d0        ; + erster sichtbarer Eintrag
  822.         cmp.w        NUM_ITEMS(a3), d0        ; genügend Einträge vorhanden?
  823.         bpl            .n6                        ; wenn nicht, dann mit '0' füllen
  824.  
  825. *** Fallunterscheidung:
  826. ***    1. Verkettete Liste der Daten
  827. *** 2. Direkter Zeiger
  828. *** 3. Indirekter Zeiger
  829.  
  830.         ;*** Auf Verkettete Liste Testen:
  831.         cmpi.w        #VERKETTET, INDIRECT(a3); Verkettete Liste?
  832.         bne            .nicht_verkettetx        ; wenn nicht, dann dort weiter
  833.  
  834.         ;*** Adresse des Struktur holen:
  835.         movea.l        a5, a1                    ; Adresse der Itemlist nach a1
  836.         move.w        ITEMSIZE(a3), d0        ; Größe der Liststruktur
  837.         sub.w        #4, d0                    ; -4, da steht der Zeiger auf's nächste Element
  838.         move.w        d4, d1                    ; counter
  839.         
  840. .roundx:
  841.         sub.w        #1, d0                    ; counter um 1 erniedrigen
  842.         bmi            .copy1                    ; wenn kleiner Null, dann Schluß
  843.         movea.l        (a1, d1.w), a1            ; sonst nächstes Element holen
  844.         bra            .roundx                    ; und weiter
  845.  
  846. .nicht_verkettetx:        
  847.         ;*** Addresse des Items holen:
  848.         move.w        FIRST_ITEM(a3), d1        ; Offset berechnen
  849.         add.w        d4, d1                    ;
  850.         mulu.w        ITEMSIZE(a3), d1        ;
  851.         
  852.         movea.l        a5, a1                    ; Adresse nach a1
  853.         adda.l        d1, a1                    ; + Offset
  854.  
  855.         ;*** list->indirect testen:
  856.         tst.w        INDIRECT(a3)            ; Test
  857.         beq            .copy1                    ; wenn 0, dann nicht indirekt!
  858.  
  859.         movea.l        (a1), a1                ; Zeiger auf Zeiger! ;-)
  860.         
  861. .copy1:
  862.         ;*** kopieren:
  863.         move.w        WIDTH(a3), d0            ; Breite der Box
  864.         ext.l        d0
  865.         jsr            strncpy                    ; String kopieren
  866.         
  867.         bra            .for1                    ; weiter mit .for
  868.         
  869. .n6:
  870.         clr.b        (a0)                    ; mit '0' füllen
  871.         
  872. .for1:
  873.         addq.l        #1, d4
  874.         cmp.w        VIS_ITEMS(a3), d4        ; Schleife oft genug durchlaufen?
  875.         bmi            .loop1                    ; wenn nicht, dann nochmal
  876. ;        -------------------- Schleifenende --------------------
  877.  
  878.         ;*** aktives Objekt sichtbar?
  879.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  880.         bsr            in_listbox                ; testen, ob sichtbar
  881.         
  882.         tst.w        d0                        ; sichtbar?
  883.         beq            .not_vis                ; wenn nicht, dann weiter bei .not_vis
  884.  
  885.         ;*** Status setzen:
  886.         move.w        ACTIVE(a3), d0            ; Element-Nummer
  887.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  888.         bsr            item2obj                ; Element-Nr. in Objekt-Nr. umwandeln
  889.         movea.l        a4, a0                    ; Tree-Adresse nach a0
  890.         move.w        SEL_STATE(a3), d1        ; Art der Selektion
  891.         jsr            do_state                ; MYDIAL: Selektieren
  892.         
  893. .not_vis:
  894.         ;*** Offset des Sliders berechnen:
  895.         move.w        SLIDER(a3), d0
  896.         ext.l        d0
  897.         move.l        d0, d3
  898.         add.l        d3, d3
  899.         add.l        d0, d3
  900.         lsl.l        #3, d3
  901.         
  902.         ;*** Slidergröße setzen:
  903.         movea.l        a3, a0                    
  904.         bsr            calc_size                ; Größe berechnen
  905.         
  906.         move.w        d0, OB_HEIGHT(a4, d3.l)    ; Größe setzen
  907.         
  908.         ;*** Sliderposition setzen:
  909.         movea.l        a3, a0
  910.         bsr            calc_pos                ; Position berechnen
  911.         
  912.         move.w        d0, OB_Y(a4, d3.l)        ; Position setzen
  913.  
  914.         ;*** falls flags & LIST_DRAW, dann zeichnen:
  915.         btst.l        #1, d7                    ; LIST_DRAW gesetzt?
  916.         beq            .list_click                ; wenn nicht, dann weiter bei .list_click
  917.         
  918.         clr.w        d1                        ; FALSE
  919.         move.w        ROOT(a3), d0            ; Root zeichnen
  920.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  921.         bsr            draw_listobj            ; Listbox zeichnen        
  922.  
  923. ;           ############### flags & LIST_CLICK ###############
  924. .list_click:
  925.  
  926.         btst.l        #2, d7                    ; LIST_CLICK?
  927.         beq            lb_ende                    ; sonst Ende der Funktion
  928.  
  929.         ;*** Objekt suchen, auf das geclickt wurde:
  930.         move.w        MOY(a5), -(sp)            ; Maus-Y auf den Stack
  931.         move.w        MOX(a5), d2                ; Maus-X nach d2
  932.         moveq.l        #8, d1                    ; Maximale Suchtiefe
  933.         move.w        ROOT(a3), d0            ; ab dem Root-Objekt suchen
  934.         movea.l        a4, a0                    ; Dialog-Baum übergeben
  935.         jsr            objc_find                ; AES-Funktion ausführen
  936.         addq.l        #2, sp                    ; Stack restaurieren
  937.         
  938.         ext.l        d0
  939.         move.l        d0, d3                    ; Objekt-Nummer nach d3
  940.  
  941.         ;*** Test, ob ein List-Eintrag neu gezeichnet werden muß:
  942.         tst.w        SEL_STATE(a3)            ; ist die Art der Selektion != NORMAL
  943.         beq            .tst_parent                ; wenn gleich Null, dann weiter bei .tst_parent
  944.  
  945.         cmp.w        ITEMS(a3), d3            ; ist ITEMS < obj
  946.         ble            .tst_parent                ; wenn nicht, dann weiter bei .tst_parent
  947.         
  948.         add.l        d0, d0                    ; Offset von obj im Baum berechnen
  949.         add.l        d3, d0                    ;
  950.         lsl.l        #3, d0                    ;
  951.         
  952.         move.w        OB_STATE(a4, d0.l), d0    ; ob_state des Objekts nach d0
  953.         andi.w        #8, d0                    ; DISABLED-Status testen
  954.         bne            .tst_parent                ; wenn != 0, dann weiter bei .tst_parent
  955.         
  956.         move.w        VIS_ITEMS(a3), d0        ; vis_items nach d0
  957.         cmp.w        NUM_ITEMS(a3), d0        ; vis_items < num_items?
  958.         bmi            .n7                        ; wenn ja, dann weiter bei .n7
  959.         
  960.         move.w        NUM_ITEMS(a3), d0        ; sonst num_items nach d0
  961. .n7:
  962.         add.w        ITEMS(a3), d0            ; + ITEMS
  963.         cmp.w        d0, d3                    ; obj <= d0?
  964.         bgt            .tst_parent                ; wenn nicht, dann weiter bei .tst_parent
  965.  
  966. *######* Eintrag in der Listbox selektiert:        
  967.         move.w        d3, d0                    ; obj nach d0
  968.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  969.         bsr            obj2item                ; Objekt-Nr. in Eintrag-Nr. umwandeln
  970.  
  971.         move.w        ACTIVE(a3), d4            ; aktiver Eintrag nach d4
  972.         cmp.w        d4, d0                    ; ist aktiver Eintrag != dem gewählten Eintrag?
  973.         beq            .tst_parent                ; wenn nicht, dann weiter bei .tst_parent
  974.         
  975.         cmp.w        #-1, d4                    ; ist schon einmal selektiert worden?
  976.         beq            .n8                        ; wenn nicht, dann weiter bei .n8
  977.  
  978.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  979.         bsr            in_listbox                ; aktiver Eintrag sichtbar?
  980.         tst.w        d0                        ; sichtbar?
  981.         beq            .n8                        ; wenn nicht, dann weiter bei .n8
  982.  
  983.         ;*** Aktiven Eintrag deselektieren:
  984.         move.w        d4, d0                    ; aktiver Eintrag nach d0
  985.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  986.         bsr            item2obj                ; Eintrag-Nr. in Objekt-Nr. umwandeln
  987.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  988.         moveq.l        #1, d1                    ; TRUE
  989.         bsr            draw_listobj            ; List-Objekt neu zeichnen
  990.         
  991. .n8:
  992.         ;*** Neues Objekt als aktiven Eintrag selektieren:
  993.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  994.         move.l        d3, d0                    ; Objekt-Nr. nach d0
  995.         bsr            obj2item                ; Objekt-Nr. in Eintrag-Nr. umwandeln
  996.         move.w        d0, ACTIVE(a3)            ; Aktiven Eintrag sichern
  997.         
  998.         movea.l        a3, a0                    ; Adresse der Listbox nach a0
  999.         moveq.l        #1, d1                    ; TRUE
  1000.         move.w        d3, d0                    ; obj zeichnen
  1001.         bsr            draw_listobj            ; List-Objekt neu zeichnen
  1002.  
  1003.         ;*** Test, ob Slider oder Pfeil der Listbox angeclickt wurde:
  1004. .tst_parent:
  1005.         cmp.w        PARENT(a3), d3            ; PARENT-Objekt <= obj?
  1006.         bmi            lb_ende                    ; wenn nicht, dann Ende
  1007.         
  1008.         cmp.w        DOWN(a3), d3             ; obj <= DOWN-Objekt?
  1009.         bhi            lb_ende                    ; wenn nicht, dann Ende
  1010.         
  1011. *######* Slider bzw. Pfeil der Listbox wurde angeclickt:
  1012.  
  1013.         move.w        FIRST_ITEM(a3), d4        ; new_pos = first_item setzen
  1014.         move.w        d4, d5                    ; old_pos ebenfallst
  1015.         move.w        NUM_ITEMS(a3), d6        ; unteres WORD: max_pos
  1016.         sub.w        VIS_ITEMS(a3), d6        ; max_pos = num_items - vis_items
  1017.         
  1018.         bpl            .n9                        ; ist max_pos >= 0
  1019.         
  1020.         clr.w        d6                        ; wenn nicht, dann Null setzen
  1021. .n9:
  1022.         ;*** Objekt suchen:
  1023.         cmp.w        UP(a3), d3                ; obj = UP-Pfeil?
  1024.         bne            .n10                    ; wenn nicht, dann .n10
  1025.         
  1026.         subq.l        #1, d4                    ; --new_pos
  1027.         bra            .calc_delta                ; weiter bei .calc_delta
  1028.         
  1029. .n10:
  1030.         cmp.w        DOWN(a3), d3            ; obj = DOWN-Pfeil?
  1031.         bne            .n11                    ; wenn nicht, dann .n11
  1032.         
  1033.         addq.l        #1, d4                    ; ++new_pos
  1034.         bra            .calc_delta                ; weiter bei .calc_delta
  1035.         
  1036. .n11:
  1037.         cmp.w        PARENT(a3), d3            ; obj = PARENT-Objekt?
  1038.         bne            .n12
  1039.         
  1040.         ;*** Seite hoch oder runter?
  1041.         clr.w        d1                        ; FALSE
  1042.         lea            work, a1                ; hier soll das RECT hin
  1043.         move.w        SLIDER(a3), d0            ; Objektnummer des Sliders
  1044.         movea.l        a4, a0                    ; Dialogbaum
  1045.         jsr            objc_rect                ; MYDIAL: RECT des Objekts holen
  1046.  
  1047.         move.w        MOY(a5), d0        
  1048.         cmp.w        work+2, d0                ; oberhalb des Sliders geclickt?
  1049.         bpl            .unterhalb                ; wenn nicht, dann .unterhalb
  1050.         
  1051.         sub.w        VIS_ITEMS(a3), d4        ; new_pos -= vis_items (Seite hoch)
  1052.         bra            .calc_delta                ; weiter bei .calc_delta
  1053.  
  1054. .unterhalb:
  1055.         add.w        VIS_ITEMS(a3), d4        ; new_pos += vis_items (Seite runter)
  1056.         bra            .calc_delta                ; weiter bei .calc_delta
  1057.  
  1058. .n12:
  1059.         cmp.w        SLIDER(a3), d3            ; obj = SLIDER-Objekt?
  1060.         bne            .calc_delta                ; weiter bei .calc_delta
  1061.  
  1062.         ;*** Slider verschieben und neue Position berechnen:
  1063.         moveq.l        #1, d2                    ; Vertikal verschieben
  1064.         move.w        d3, d1                    ; Objektnummer des Sliders
  1065.         move.w        PARENT(a3), d0            ; Slidebox
  1066.         movea.l        a4, a0                    ; Tree-Adresse
  1067.         jsr            graf_slidebox            ; AES-Funktion ausführen
  1068.         
  1069.         ext.l        d0                        ; d0 auf Long erweitern
  1070.         mulu.w        d6, d0                    ; mit max_pos multiplizieren
  1071.         
  1072.         divu.w        #1000, d0                ; neue Position berechnen
  1073.         move.w        d0, d4                    ; und in new_pos sichern
  1074.         
  1075.         swap        d0                        ; Rest betrachten
  1076.         cmpi.w        #500, d0                ; Rest > 500?
  1077.         bmi            .calc_delta                ; wenn nicht, dann weiter bei .calc_delta
  1078.         
  1079.         addq.l        #1, d4                    ; sonst noch 1 zu new_pos addieren
  1080.         
  1081. .calc_delta:
  1082.         ;*** erstmal neue Position betrachten:
  1083.         cmp.w        d4, d6                    ; new_pos > max_pos?
  1084.         bpl            .n13                    ; wenn nicht, dann weiter bei .n13
  1085.         
  1086.         move.w        d6, d4                    ; sonst new_pos = max_pos setzen
  1087.         bra            .n14                    ; weiter bei .n14
  1088.         
  1089. .n13:
  1090.         tst.w        d4                        ; new_pos < 0?
  1091.         bpl            .n14                    ; wenn nicht, dann weiter bei .n14
  1092.  
  1093.         clr.w        d4                        ; sonst new_pos = 0 setzen
  1094.                 
  1095. .n14:
  1096.         ;*** delta berechnen:
  1097.         move.w        d4, d7                    ; new_pos nach d7 kopieren
  1098.         sub.w        d5, d7                    ; delta = new_pos - old_pos
  1099.         
  1100.         ;*** muß was verschoben werden?
  1101.         tst.w        d7                        ; delta != 0?
  1102.         beq            lb_ende                    ; wenn nicht, dann Ende
  1103.  
  1104. *######* Scrollen!
  1105.  
  1106.         move.w        ACTIVE(a3), d5            ; aktiven Eintrag in d5 sichern
  1107.         
  1108.         ;*** erstmal aktiven Eintrag deselektieren:
  1109.         tst.w        d5                        ; ist aktiver Eintrag != -1?
  1110.         bmi            .no_active1                ; wenn nicht, dann weiter bei .no_active1
  1111.  
  1112.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1113.         bsr            in_listbox                ; aktiver Eintrag sichtbar?
  1114.         tst.w        d0                        ; sichtbar?
  1115.         beq            .no_active1                ; wenn nicht, dann .no_active1
  1116.         
  1117.         move.w        d5, d0                    ; aktiver Eintrag nach d0
  1118.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1119.         bsr            item2obj                ; Eintrag-Nr. in Objekt-Nr. wandeln
  1120.         movea.l        a4, a0                    ; Tree-Adresse nach a0
  1121.         move.w        SEL_STATE(a3), d1        ; Selektions-Art nach d1
  1122.         jsr            undo_state                ; MYDIAL: Status zurücksetzen        
  1123.  
  1124. .no_active1:
  1125.         move.w        d4, FIRST_ITEM(a3)        ; neues first_item ist new_pos
  1126.  
  1127.         ;*** aktiven Eintrag selektieren:
  1128.         tst.w        d5                        ; ist aktiver Eintrag != -1?
  1129.         bmi            .no_active2                ; wenn nicht, dann weiter bei .no_active2
  1130.  
  1131.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1132.         bsr            in_listbox                ; aktiver Eintrag sichtbar?
  1133.         tst.w        d0                        ; sichtbar?
  1134.         beq            .no_active2                ; wenn nicht, dann .no_active2
  1135.         
  1136.         move.w        d5, d0                    ; aktiver Eintrag nach d0
  1137.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1138.         bsr            item2obj                ; Eintrag-Nr. in Objekt-Nr. wandeln
  1139.         movea.l        a4, a0                    ; Tree-Adresse nach a0
  1140.         move.w        SEL_STATE(a3), d1        ; Selektions-Art nach d1
  1141.         jsr            do_state                ; MYDIAL: Status setzen
  1142.  
  1143. .no_active2:
  1144.  
  1145.         ;*** Adresse der Itemlist in Register schieben:
  1146.         movea.l        ITEMLIST(a3), a5        ; Adresse nach a5
  1147.  
  1148. ;            ######+++++###### Schleife ######++++++######
  1149.         clr.w        d4                        ; Schleifenzähler initialisieren
  1150.         
  1151. .loop2:
  1152.         ;*** aktuelle Objektnummer berechnen:
  1153.         moveq.l        #1, d5
  1154.         add.w        d4, d5
  1155.         add.w        ITEMS(a3), d5
  1156.         ext.l        d5
  1157.         
  1158.         ;*** Offset des aktuellen Objekts berechnen:
  1159.         move.l        d5, d2
  1160.         add.l        d2, d2
  1161.         add.l        d5, d2
  1162.         lsl.l        #3, d2
  1163.         
  1164.         move.w        OB_TYPE(a4, d2.l), d0    ; ob_type nach d0
  1165.  
  1166.         ;*** Adresse des Zielstrings holen:
  1167.         
  1168.         ;###### switch:
  1169.         cmpi.w        #28, d0                    ; ist ob_type == G_STRING
  1170.         beq            .sw3
  1171.         
  1172.         cmpi.w        #26, d0                    ; ist ob_type == G_BUTTON
  1173.         beq            .sw3
  1174.         
  1175.         bra            .sw4                    ; sonst ist ob_type G_TEXT,
  1176.                                             ; G_BOXTEXT, G_FTEXT oder G_FBOXTEXT
  1177. .sw3:
  1178.         movea.l        OB_SPEC(a4, d2.l), a0    ; Adresse des Textes
  1179.         bra            .n15                    ; weiter bei .n15
  1180.  
  1181. .sw4:
  1182.         movea.l        OB_SPEC(a4, d2.l), a0    ; Zeiger auf eine Tedinfo-Struktur
  1183.         movea.l        (a0), a0                ; Adresse des Textes
  1184.         
  1185. .n15:
  1186.         ;*** sichtbare Einträge in die Listbox kopieren:
  1187.         move.w        d4, d0                    ; aktuelle Nummer
  1188.         add.w        FIRST_ITEM(a3), d0        ; + erster sichtbarer Eintrag
  1189.         cmp.w        NUM_ITEMS(a3), d0        ; genügend Einträge vorhanden?
  1190.         bpl            .n16                    ; wenn nicht, dann mit '0' füllen
  1191.  
  1192. *** Fallunterscheidung:
  1193. ***    1. Verkettete Liste der Daten
  1194. *** 2. Direkter Zeiger
  1195. *** 3. Indirekter Zeiger
  1196.  
  1197.         ;*** Auf Verkettete Liste Testen:
  1198.         cmpi.w        #VERKETTET, INDIRECT(a3); Verkettete Liste?
  1199.         bne            .nicht_verkettety        ; wenn nicht, dann dort weiter
  1200.  
  1201.         ;*** Adresse des Struktur holen:
  1202.         movea.l        a5, a1                    ; Adresse der Itemlist nach a1
  1203.         move.w        ITEMSIZE(a3), d0        ; Größe der Liststruktur
  1204.         sub.w        #4, d0                    ; -4, da steht der Zeiger auf's nächste Element
  1205.         move.w        d4, d1                    ; counter
  1206.         
  1207. .roundy:
  1208.         sub.w        #1, d0                    ; counter um 1 erniedrigen
  1209.         bmi            .copy2                    ; wenn kleiner Null, dann Schluß
  1210.         movea.l        (a1, d1.w), a1            ; sonst nächstes Element holen
  1211.         bra            .roundy                    ; und weiter
  1212.  
  1213. .nicht_verkettety:
  1214.         
  1215.         ;*** Addresse des Items holen:
  1216.         move.w        FIRST_ITEM(a3), d1        ; Offset berechnen
  1217.         add.w        d4, d1                    ;
  1218.         mulu.w        ITEMSIZE(a3), d1        ;
  1219.         
  1220.         movea.l        a5, a1                    ; Adresse nach a1
  1221.         adda.l        d1, a1                    ; + Offset
  1222.  
  1223.         ;*** list->indirect testen:
  1224.         tst.w        INDIRECT(a3)            ; Test
  1225.         beq            .copy2                    ; wenn 0, dann nicht indirekt!
  1226.  
  1227.         movea.l        (a1), a1                ; Zeiger auf Zeiger! ;-)
  1228.         
  1229. .copy2:
  1230.         ;*** kopieren:
  1231.         move.w        WIDTH(a3), d0            ; Breite der Box
  1232.         ext.l        d0
  1233.         jsr            strncpy                    ; String kopieren
  1234.         
  1235.         bra            .for2                    ; weiter mit .for2
  1236.         
  1237. .n16:
  1238.         clr.b        (a0)                    ; mit '0' füllen
  1239.         
  1240. .for2:
  1241.         addq.l        #1, d4
  1242.         cmp.w        VIS_ITEMS(a3), d4        ; Schleife oft genug durchlaufen?
  1243.         bmi            .loop2                    ; wenn nicht, dann nochmal
  1244. ;        -------------------- Schleifenende --------------------
  1245.  
  1246.         ;*** Sliderposition neu berechnen:
  1247.         move.w        SLIDER(a3), d5            ; Objektnummer des Sliders holen
  1248.         ext.l        d5
  1249.         move.l        d5, d2                    ; Offset im Baum berechnen
  1250.         add.l        d5, d5                    ; \
  1251.         add.l        d2, d5                    ;  > Objektnummer * 24
  1252.         lsl.l        #3, d5                    ; /
  1253.  
  1254.         move.w        OB_Y(a4, d5.l), d4        ; altes ob_y sichern
  1255.         
  1256.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1257.         bsr            calc_pos                ; Neue Sliderposition berechnen
  1258.  
  1259.         move.w        d0, OB_Y(a4, d5.l)        ; neues ob_y sichern
  1260.         
  1261.         ;*** wenn alte Position != neue Position, dann neu zeichnen:
  1262.         cmp.w        d4, d0                    ; Vergleich alt <=> neu
  1263.         beq            .n17                    ; wenn gleich, dann weiter bei .n17
  1264.         
  1265.         clr.w        d1                        ; FALSE
  1266.         move.w        PARENT(a3), d0            ; ab Parent-Objekt neuzeichnen
  1267.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1268.         bsr            draw_listobj            ; neuzeichnen ...
  1269.         
  1270. .n17:
  1271.         ;*** testen, ob sich Scrollen lohnt (delta = -1 bzw. delta = 1):
  1272.         cmpi.w        #1, d7                    ; delta = 1?
  1273.         beq            .do_scroll                ; dann scrollen
  1274.         
  1275.         cmpi.w        #-1, d7                    ; oder delta = -1
  1276.         beq            .do_scroll                ; dann auch scrollen
  1277.  
  1278.         ;*** nur neuzeichnen:
  1279.         clr.w        d1                        ; FALSE
  1280.         move.w        ITEMS(a3), d0            ; Items zeichnen
  1281.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1282.         bsr            draw_listobj            ; neuzeichnen ...
  1283.         
  1284.         bra            lb_ende                    ; und fertig ...
  1285.         
  1286. .do_scroll:
  1287.         ;###### Scrollen:
  1288.         
  1289.         moveq.l        #1, d0                    ; Höhe berechnen
  1290.         add.w        ITEMS(a3), d0            ; 1 + Objektnummer items
  1291.         move.l        d0, d1                    ; Offset berechnen
  1292.         add.l        d0, d0                    ; \
  1293.         add.l        d1, d0                    ;  > * 24
  1294.         lsl.l        #3, d0                    ; /
  1295.         move.w        OB_HEIGHT(a4, d0.l), d3 ; ob_height in d3 sichern
  1296.         
  1297.         ;*** RECT der ITEM-Box holen:
  1298.         clr.w        d1                        ; FALSE
  1299.         lea            work, a1                ; hier soll das RECT hin
  1300.         move.w        ITEMS(a3), d0            ; Objektnummer der ITEM-Box
  1301.         movea.l        a4, a0                    ; Tree-Adresse
  1302.         jsr            objc_rect                ; MYDIAL: RECT einess Objekts holen
  1303.         
  1304.         ;*** hoch- oder runterscrollen berücksichtigen:
  1305.         tst.w        d7                        ; delta betrachten
  1306.         bmi            .runter_scrollen        ; spricht für sich ...
  1307.         
  1308.         add.w        d3, work+2                ; work.y + height
  1309.         sub.w        d3, work+6                ; work.h - height
  1310.         
  1311.         move.w        ITEMS(a3), d4            ; 
  1312.         add.w        VIS_ITEMS(a3), d4        ;
  1313.         
  1314.         bra            .scroll_and_draw        ; weiter bei .scroll_and_draw
  1315.         
  1316. .runter_scrollen:
  1317.         sub.w        d3, work+6                ; work.h - height
  1318.         
  1319.         move.w        ITEMS(a3), d4            ;
  1320.         addq.l        #1, d4                    ;
  1321.         
  1322. .scroll_and_draw:
  1323.         move.w        d7, d0                    ; delta nach d0
  1324.         muls.w        d3, d0                    ; delta * height
  1325.         lea            work, a0                ; RECT-Adresse nach a0
  1326.         bsr            scroll_area                ; und scrollen
  1327.         
  1328.         clr.w        d1                        ; FALSE
  1329.         move.w        d4, d0                    ; Objektnummer
  1330.         movea.l        a3, a0                    ; Listbox-Adresse nach a0
  1331.         bsr            draw_listobj            ; und zeichnen
  1332.         
  1333. lb_ende:
  1334.         movem.l        (sp)+, d3-d7/a3-a5        ; Register restaurieren
  1335.         rts
  1336.  
  1337. ;-------------------------------------------------------------------------------
  1338. ; Funktionsname:    draw_listobj
  1339. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1340. ;            d0:    Nummer des Objekts
  1341. ;            d1:    invertieren des Status, TRUE oder FALSE
  1342. ;        <-    nichts
  1343. ;
  1344. ; Die Funktion zeichnet ein Element der Listbox neu.
  1345. ;
  1346. draw_listobj:
  1347.         movem.l        d3-d5/a3-a4, -(sp)        ; Register retten
  1348.  
  1349.         movea.l        a0, a3                    ; Parameter verteilen
  1350.         move.w        d0, d3                    ; "
  1351.         ext.l        d3
  1352.         move.w        d1, d4                    ; "
  1353.  
  1354.         movea.l        TREE(a3), a4            ; Tree-Adresse nach a4
  1355.  
  1356.         ;*** RECT des zu zeichnenden Objekts holen:
  1357.         moveq.l        #1, d1                    ; d1 mit TRUE für Slider vorbesetzen
  1358.         cmp.w        SLIDER(a3), d3            ; ist Objekt der Slider?
  1359.         beq            .is_slider                ; wenn ja, dann weiter bei .is_slider
  1360.         clr.w        d1                        ; sonst d1 = FALSE
  1361. .is_slider:
  1362.         lea            work, a1                ; Adresse für RECT des Objekts
  1363.         move.w        d3, d0                    ; Objekt-Nummer
  1364.         movea.l        a4, a0                    ; Objekt-Baum
  1365.         jsr            objc_rect                ; MYDIAL: Rect des Objekts holen
  1366.  
  1367.         tst.w        d4                        ; Status invertieren gesetzt?
  1368.         beq            .no_invert                ; wenn nicht, dann weiter bei .no_invert
  1369.  
  1370.         ;*** Objekt invertieren:
  1371.         movea.l        a4, a0                    ; Adresse des Objektbaums holen
  1372.         move.l        d3, d0                    ; Objekt-Nr. nach d0
  1373.         add.l        d0, d0                    ; Offset berechnen
  1374.         add.l        d3, d0                    ;
  1375.         lsl.l        #3, d0                    ;
  1376.         move.w        10(a0, d0.l), d0        ; ob_state des Objekts
  1377.         eori.w        #1, d0                    ; Bit 0 setzen oder löschen
  1378.  
  1379.         move.w        #1, -(sp)                ; Objekt neu zeichnen
  1380.         move.w        d0, -(sp)                ; neuer Status
  1381.         move.l        work+4, -(sp)            ; wc, hc
  1382.         move.w        work+2, -(sp)            ; yc
  1383.         move.w        work, d2                ; xc
  1384.         clr.w        d1                        ; Reserviert, muß 0 sein
  1385.         move.w        d3, d0                    ; Objekt-Nr.
  1386.         jsr            objc_change                ; AES-Funktion ausführen
  1387.         lea            10(sp), sp                ; Stack restaurieren
  1388.         
  1389.         bra            dlo_ende                ; und schluß!
  1390.         
  1391.  
  1392. .no_invert:
  1393.         ;*** erstmal den Offset des Objekts berechnen:
  1394.         move.l        d3, d5                    ; Objektnummer nach d5
  1395.         add.l        d5, d5                    ; \
  1396.         add.l        d3, d5                    ;  > * 24
  1397.         lsl.l        #3, d5                    ; /
  1398.  
  1399.         move.w        OB_TYPE(a4, d5.l), d0    ; ob_type nach d0
  1400.         cmpi.w        #28, d0                    ; ob_type = G_STRING?
  1401.         beq            .draw1                    ; dann .draw1
  1402.     
  1403.         cmp.w        ITEMS(a3), d3            ; oder obj = items?
  1404.         beq            .draw1                    ; dann auch draw1
  1405.         
  1406.         lea            desk, a0                ; Adresse von desk holen
  1407.         move.l        4(a0), -(sp)            ; work.h und work.w auf den Stack
  1408.         move.w        2(a0), -(sp)            ; work.y auf den Stack
  1409.         move.w        (a0), d2                ; work.x nach d2
  1410.         moveq.l        #8, d1                    ; maximale Tiefe
  1411.         move.w        d3, d0                    ; obj
  1412.         movea.l        a4, a0                    ; Tree-Adresse
  1413.         jsr            objc_draw                ; AES-Funktion ausführen
  1414.         addq.l        #6, sp                    ; Stack aufräumen
  1415.                 
  1416.         bra            dlo_ende                ; Ende 
  1417.         
  1418. .draw1:
  1419.         lea            work, a0                ; Adresse von work holen
  1420.         move.l        4(a0), -(sp)            ; work.h und work.w auf den Stack
  1421.         move.w        2(a0), -(sp)            ; work.y auf den Stack
  1422.         move.w        (a0), d2                ; work.x nach d2
  1423.         moveq.l        #8, d1                    ; maximale Tiefe
  1424.         move.w        ITEMS(a3), d0            ; item-Box zeichnen
  1425.         movea.l        a4, a0                    ; Tree-Adresse
  1426.         jsr            objc_draw                ; AES-Funktion ausführen
  1427.         addq.l        #6, sp                    ; Stack aufräumen
  1428.                 
  1429. dlo_ende:
  1430.         movem.l        (sp)+, d3-d5/a3-a4        ; Register restaurieren
  1431.         rts        
  1432.  
  1433. ;-------------------------------------------------------------------------------
  1434. ; Funktionsname:    calc_pos
  1435. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1436. ;        <-    d0: aktuelle Position des Listbox-Sliders
  1437. ;
  1438. ; Die Funktion berechnet die aktuelle Position des Sliders einer Listbox.
  1439. ;
  1440. calc_pos:
  1441.         move.l        d3, -(sp)                ; Register retten
  1442.         
  1443.         move.w        NUM_ITEMS(a0), d3        ; num_items
  1444.         sub.w        VIS_ITEMS(a0), d3        ; - vis_items
  1445.         
  1446.         bgt            .else                    ; Differenz > 0? --> .else
  1447.         
  1448.         clr.w        d0                        ; sonst aktuelle Position 0 setzen
  1449.         bra            cp_ende                    ; und Ende ...
  1450.         
  1451. .else:
  1452.         movea.l        TREE(a0), a1            ; Adresse des Dialogbaums nach a1
  1453.         move.w        PARENT(a0), d1            ; Nummer des parent-Objekts
  1454.         ext.l        d1                        ; Offset im Baum berechnen
  1455.         move.l        d1, d2                    ; "
  1456.         add.l        d2, d2                    ; "
  1457.         add.l        d1, d2                    ; "
  1458.         lsl.l        #3, d2                    ; "
  1459.         move.w        OB_HEIGHT(a1, d2.l), d0    ; ob_height holen
  1460.         
  1461.         move.w        SLIDER(a0), d1            ; Nummer des slider-Objekts
  1462.         ext.l        d1                        ; Offset im Baum berechnen
  1463.         move.l        d1, d2                    ; "
  1464.         add.l        d2, d2                    ; "
  1465.         add.l        d1, d2                    ; "
  1466.         lsl.l        #3, d2                    ; "
  1467.         sub.w        OB_HEIGHT(a1, d2.l), d0    ; ob_height des Sliders von ob_height
  1468.                                             ; des parent-Objekts abziehen
  1469.         
  1470.         mulu.w        FIRST_ITEM(a0), d0        ; multiplizieren mit Nummer des 
  1471.                                             ; ersten sichtbaren Objekts
  1472.         divu.w        d3, d0                    ; und das ganze durch die 
  1473.                                             ; maximalen Positionen teilen
  1474.  
  1475. cp_ende:
  1476.         move.l        (sp)+, d3
  1477.         rts
  1478.  
  1479.  
  1480. ;-------------------------------------------------------------------------------
  1481. ; Funktionsname:    calc_size
  1482. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1483. ;        <-    d0: Größe des Listbox-Sliders
  1484. ;
  1485. ; Die Funktion berechnet die aktuelle Größe des Sliders einer Listbox.
  1486. ;
  1487. calc_size:
  1488.         movea.l        TREE(a0), a1            ; Adresse des Dialogbaums nach a1
  1489.         move.w        PARENT(a0), d1            ; Nummer des parent-Objekts
  1490.         ext.l        d1                        ; Offset im Baum berechnen
  1491.         move.l        d1, d2                    ; "
  1492.         add.l        d2, d2                    ; "
  1493.         add.l        d1, d2                    ; "
  1494.         lsl.l        #3, d2                    ; "
  1495.         move.w        22(a1, d2.l), d0        ; ob_height nach d0
  1496.  
  1497.         move.w        NUM_ITEMS(a0), d1        ; num_items > 0?
  1498.         beq            .no_item                ; wenn nicht, dann weiter bei .no_item
  1499.         
  1500.         cmp.w        VIS_ITEMS(a0), d1        ; vis_items <= num_items?
  1501.         bmi            .no_item                ; wenn nicht, dann weiter bei .no_item
  1502.  
  1503.         mulu.w        VIS_ITEMS(a0), d0        ; size * vis_items
  1504.         divu.w        d1, d0                    ; / num_items
  1505.         
  1506. .no_item:
  1507.  
  1508.         cmp.w        mygl_hbox, d0            ; size kleiner als box für ein Zeichen?
  1509.         bpl            cs_ende                    ; wenn nicht, dann Ende
  1510.  
  1511.         move.w        mygl_hbox, d0            ; size = gl_hbox setzen
  1512.  
  1513. cs_ende:
  1514.         rts
  1515.  
  1516.  
  1517. ;-------------------------------------------------------------------------------
  1518. ; Funktionsname:    in_listbox
  1519. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1520. ;        <-    d0: TRUE, wenn aktuelles Objekt in der Listbox zu sehen ist,
  1521. ;                sonst FALSE
  1522. ;
  1523. ; Die Funktion gibt zurück, ob das aktive Objekt in der Listbox zu sehen ist.
  1524. ;
  1525. in_listbox:
  1526.         clr.w        d0                        ; Rückgabe auf FALSE setzen
  1527.  
  1528.         ;*** Aktiver Eintrag in Listbox?
  1529.         move.w        ACTIVE(a0), d1            ; aktives Objekt der Listbox
  1530.         sub.w        FIRST_ITEM(a0), d1        ; - Nummer der ersten sichtbaren
  1531.         
  1532.         bmi            in_lb_ende                ; wenn kleiner Null dann nicht sichtbar
  1533.         
  1534.         ;*** min zwischen vis_items und num_items bestimmen:
  1535.         move.w        VIS_ITEMS(a0), d2        ; vis_items nach d2
  1536.         cmp.w        NUM_ITEMS(a0), d2        ; vergleichen mit num_items
  1537.         
  1538.         bmi            .n1                        ; wenn vis_items < num_items, weiter bei .n1
  1539.  
  1540.         move.w        NUM_ITEMS(a0), d2        ; sonst num_items nach d2
  1541. .n1:
  1542.         cmp.w        d1, d2                    ; sichtbar?
  1543.         blt            in_lb_ende                ; wenn nicht, dann Ende
  1544.                 
  1545.         moveq.l        #1, d0                    ; sonst TRUE.
  1546.         
  1547. in_lb_ende:
  1548.         rts
  1549.  
  1550. ;-------------------------------------------------------------------------------
  1551. ; Funktionsname:    item2obj
  1552. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1553. ;            d0: Nummer des Eintrags
  1554. ;        <-    d0: Objektnummer
  1555. ;
  1556. ; Wandelt eine Eintragnummer in eine Objektnummer um.
  1557. ;
  1558. item2obj:
  1559.                                             ; Nummer des Eintrags
  1560.         sub.w        FIRST_ITEM(a0), d0        ; - Nummer des ersten sichtbaren
  1561.         add.w        ITEMS(a0), d0            ; + Objektnummer der Box mit den Einträgen
  1562.         addq.w        #1, d0                    ; + 1
  1563.         
  1564.         rts
  1565.  
  1566. ;-------------------------------------------------------------------------------
  1567. ; Funktionsname:    obj2item
  1568. ;         ->    a0:    Zeiger auf Listbox-Struktur
  1569. ;            d0: Nummer des Objekts
  1570. ;        <-    d0: Nummer des Eintrages
  1571. ;
  1572. ; Wandelt eine Objektnummer in eine Eintragnummer um.
  1573. ;
  1574. obj2item:
  1575.                                             ; Nummer des Objekts
  1576.         add.w        FIRST_ITEM(a0), d0        ; + Nummer des ersten sichtbaren Eintrags
  1577.         sub.w        ITEMS(a0), d0            ; - Objektnummer der Box mit den Einträgen
  1578.         subq.l        #1, d0                    ; - 1
  1579.  
  1580.         rts
  1581.  
  1582. *****************************************************************************
  1583.  
  1584.         .DATA
  1585.         .EVEN
  1586.         
  1587.  
  1588. *****************************************************************************
  1589.  
  1590.         .BSS
  1591.         .EVEN
  1592.  
  1593. *** Übergabeparameter für obj_edit:
  1594. edit_obj:        ds.w    1
  1595. next_obj:        ds.w    1
  1596. idx:            ds.w    1
  1597.  
  1598. *** RECT eines Objekts:
  1599. work:            ds.w    4
  1600.  
  1601. *** Variablen für das Event-Handling:
  1602. evnt_strct:        ds.w    16
  1603. ev_rc:            ds.w    1
  1604. ev_mox:            ds.w    1
  1605. ev_moy:            ds.w    1
  1606. ev_mbutton:        ds.w    1
  1607. ev_kstate:        ds.w    1
  1608. ev_kreturn:        ds.w    1
  1609. ev_breturn:        ds.w    1
  1610. evnt_buff:        ds.w    8
  1611.  
  1612. *** MKINFO-Struktur:
  1613. mk:
  1614. mox:        ds.w    1
  1615. moy:        ds.w    1
  1616. momask:        ds.w    1
  1617. mobutton:    ds.w    1
  1618. kstate:        ds.w    1
  1619. kreturn:    ds.w    1
  1620. breturn:    ds.w    1
  1621. ascii_code:    ds.w    1
  1622. scan_code:    ds.w    1
  1623. shift:        ds.w    1
  1624. contrl:        ds.w    1
  1625. alt:        ds.w    1
  1626.  
  1627.         .END
  1628.  
  1629.