;**********************************************************************;
;*                 A T O M I C   W I N D O W S                        *;
;*--------------------------------------------------------------------*;
;*    doel           : Interpreter en statements voor toolbox         *;
;*--------------------------------------------------------------------*;
;*    filenaam       : INT36PC.INC                                    *;
;*    auteur         : Kees van Oss                                   *;
;*    conversie      : Roland Leurs                                   *;
;*                     The Atomic Development Studio                  *;
;*    ontwikkeld     : juli 1997                                      *;
;*    laatste update : 12 oktober 1998                                *;
;*--------------------------------------------------------------------*;
;*    wijzigingen    : v36 - DLGEND commando werkte met actieve loop  *;
;*                           loop commando's niet goed,  3x PHA/PLA   *;
;*                           toegevoegd                               *;
;*                         - DLGLISTBOX gecorrigeerd met maxitems=0/1 *;
;*                         - Commando's aangepast voor aanroep in asm *;
;*                         - Ruimte bespaard door JSR,RTS -> JMP      *;
;*                         - String bij AW ingekort voor extra ruimte *;
;*--------------------------------------------------------------------*;
;*    assembleren    : opnemen als includefile in AWPC.ASM            *;
;*--------------------------------------------------------------------*;
;*    oproep         : -                                              *;
;**********************************************************************;

; === INITIALISATIE VARIABELEN
stackpointer   equ $4                  ; Standaard Atom adressen
stack1         equ $16
stack2         equ $25

read_param     equ $C8BC               ; Standaard Atom routines
read_text      equ $CEB1
next_param     equ $C231
print_text     equ $F7D1
scan_toets     equ $FE71
wait_key       equ $FE94
no_com         equ $C558
new_line       equ $FFED

osbyte         equ $FFC2               ; Atom-in-PC routines
leesbyte       equ $FFC5
zendbyte       equ $FFC8

ret            equ $0D                 ; Constante variabelen
esc            equ $1B
bsp            equ $7F
copy           equ $0E
delete         equ $0F
spatie         equ $00
escape         equ $3B

data           equ $80                 ; Werkruimte voor hulproutines
x_tmp          equ data
y_tmp          equ data+1
b_tmp          equ data+2
h_tmp          equ data+3
m_tmp          equ data+4

nulblock       equ $90                 ; Werkruimte voor commando's
tmp_adres      equ nulblock
foc_ptr_lo     equ nulblock+2
foc_ptr_hi     equ nulblock+3

dlg_buffer     equ $140                ; Buffer

parameter      equ $16B

dlg_base_lo    equ parameter           ; Globale variabelen
dlg_base_hi    equ parameter+1
dlg_ptr_lo     equ parameter+2
dlg_ptr_hi     equ parameter+3

x_base         equ parameter+4         ; Lokale variabelen
y_base         equ parameter+5
x_min          equ parameter+6
x_max          equ parameter+7
y_min          equ parameter+8
y_max          equ parameter+9
store_mode     equ parameter+10
store_var      equ parameter+11
store_len      equ parameter+12
store_style    equ parameter+13
store_x        equ parameter+14
store_y        equ parameter+15
store_width    equ parameter+16
store_height   equ parameter+17
store_var1     equ parameter+18
store_var2     equ parameter+19

; === INTERPRETER
                LDX #$FF

next_com        LDY $5E
                DEY
next_chr        INX
                INY
next_vec        LDA com_tab,X
                BMI com_ok
                CMP ($05),Y
                BEQ next_chr
int2            INX
                LDA com_tab-1,X
                BPL int2
                LDA  ($05),Y
                CMP #$2E
                BNE next_com
                INY
                DEX
                BCS next_vec
com_ok          STA $53
                LDA com_tab+1,X
                STA $52
                STY $3
                LDX #0
                STX $4
                JSR exec_com
                LDX #0
                STX $4
                JMP $C558
exec_com        JMP ($0052)

com_tab         .db "DLGBASE"          ; Algemene commando's
                .db >dlgbase,<dlgbase
                .db "DLGCLS"
                .db >dlgcls,<dlgcls
                .db "DLGCREATE"
                .db >dlgcreate,<dlgcreate
                .db "DLGEND"
                .db >dlgend,<dlgend
                .db "DLGPOINTER"
                .db >dlgpointer,<dlgpointer
                .db "AW"
                .db >aw,<aw

                .db "DLGPUSHBUTTON"    ; Actieve Dialogbox commando's
                .db >dlgpushbutton,<dlgpushbutton
                .db "DLGRADIOBUTTON"
                .db >dlgradiobutton,<dlgradiobutton
                .db "DLGCHECKBOX"
                .db >dlgcheckbox,<dlgcheckbox
                .db "DLGOPTION"
                .db >dlgoption,<dlgoption
                .db "DLGTEXT"
                .db >dlgtext,<dlgtext
                .db "DLGHOTSPOT"
                .db >dlghotspot,<dlghotspot
                .db "DLGICON"
                .db >dlgicon,<dlgicon
                .db "DLGLISTBOX"
                .db >dlglistbox,<dlglistbox

                .db "DLGLABEL"         ; Passieve Dialogbox commando's
                .db >dlglabel,<dlglabel
                .db "DLGFRAME"
                .db >dlgframe,<dlgframe

                .db >no_com,<no_com    ; Einde commando tabel

; === COMMANDO AW
aw              JSR print_text
                .db "AWPC ROM V0.1 - rev. 9902143"
                NOP
                JMP new_line

; === COMMANDO DLGBASE Adres
dlgbase         JSR read_num           ; Lees adres in stack
                STA dlg_base_lo        ; dlg_base = adres + #700
                CLC
                LDA stack2
                ADC #7
                STA dlg_base_hi

                LDA dlg_base_lo
                STA dlg_ptr_lo         ; dlg_ptr  = adres + #700
                LDA dlg_base_hi
                STA dlg_ptr_hi

                JSR m_init             ; Initialiseer de muis
                JSR _dlgbase_ext       ; Regel Atom-in-PC extensies
standaard_atom  RTS

; === COMMANDO DLGCLS
dlgcls          JSR setsem             ; Zet semafoor voor PC-communicatie
                LDX #24                ; Initialiseer het scherm
                LDY #cls_std-pccomtab
                JSR pccom
                JMP clrsem

; === COMMANDO DLGCREATE Var,Text$,Style,X,Y,B,H
dlgcreate       LDA #0                 ; Mode = dlgcreate
                STA store_mode
                JSR param              ; Lees Var,Text$,Style,X,Y,B,H

                LDA dlg_base_lo        ; Reset DlgPointer
                STA dlg_ptr_lo
                LDA dlg_base_hi
                STA dlg_ptr_hi

                LDA store_x            ; Bepaal x_min
                STA x_base
                STA x_min

                LDA store_y            ; Bepaal y_min
                STA y_base
                STA y_min

                CLC                    ; Bepaal x_max
                LDA x_min
                ADC store_width
                STA x_max

                CLC                    ; Bepaal y_max
                LDA y_min
                ADC store_height
                STA y_max

                LDA store_style
                PHA
                AND #$EF
                STA store_style
                JSR store_dat          ; Zet parameters in tabel
                PLA
                STA store_style

                LDA x_min              ; Plaats kader
                STA x_tmp
                LDA y_min
                STA y_tmp
                LDA store_width
                STA b_tmp
                LDA store_height
                STA h_tmp
                JSR kader

                LDA #$FF
                STA m_tmp
                JSR block              ; Plaats wit blok

                LDA store_len          ; Test of titel$ gezet moet worden
                BEQ chk_ok

                LDA #$00               ; Plaats zwart blok voor titel$
                STA m_tmp
                LDA #$01
                STA h_tmp
                LDA store_style
                AND #32
                BEQ no_bigkop
                INC h_tmp
no_bigkop       JSR block

                SEC                    ; Bepaal positie titel$ en plaats deze
                LDA store_width
                SBC store_len
                LSR A
                CLC
                ADC x_min
                TAX
                LDY y_min
                LDA store_len
                JSR txt

chk_ok          LDA #1                 ; Mode = PushButton
                STA store_mode

                SEC                    ; Bepaal X-pos OK-Button
                LDA store_width
                SBC #$05
                STA store_x

                LDY store_height       ; Bepaal Y-pos alleen OK-Button
                DEY
                DEY
                STY store_y

                LDA store_style        ; Filter OK- en Cancel-Button eruit
                AND #$C0
                STA store_style
                AND #$40               ; Check of Ok-knop gezet moet worden
                BNE ok_knop

                SEC                    ; Bepaal X-pos alleen Cancel-Button
                LDA store_width
                SBC #$09
                STA store_x

chk_cancel      LDA store_style        ; Check of Cancel-knop gezet moet worden
                AND #$80
                BNE cancel_knop

end             RTS

cancel_knop     LDA #"C"               ; Plaats Cancel-knop
                STA dlg_buffer
                LDA #"a"
                STA dlg_buffer+1
                LDA #"n"
                STA dlg_buffer+2
                LDA #"c"
                STA dlg_buffer+3
                LDA #"e"
                STA dlg_buffer+4
                LDA #"l"
                STA dlg_buffer+5
                LDA #$06
                STA store_len
                LDA #$FF
                STA store_var
                JSR pb_set
                JMP end

ok_knop         LDA #"O"               ; Plaats Ok-knop
                STA dlg_buffer
                LDA #"k"
                STA dlg_buffer+1
                LDA #2
                STA store_len
                LDA #0
                STA store_var
                JSR pb_set

                SEC                    ; Pas X-pos aan voor Ok- + Cancel-knop
                LDA store_width
                SBC #$0E
                STA store_x
                JMP chk_cancel

param           JSR get                ; Lees Var
                JSR get2               ; Lees Text$,Style,X,Y
                JSR get3               ; Lees Width
                JMP get4               ; Lees Height

; === COMMANDO DLGPUSHBUTTON Exit,Text$,Style,X,Y
dlgpushbutton   LDA #1                 ; Mode = PushButton
                STA store_mode
                JSR param1             ; Lees Exit,Text$,Style,X,Y

pb_set          JSR limits             ; Bepaal x_min,x_max,y_min,y_max
                INC x_max              ; Pas x_max aan
                INC x_max
                JSR store_dat          ; Zet parameters in tabel

                LDA x_min              ; Plaats kader
                STA x_tmp
                LDA y_min
                STA y_tmp
                CLC
                LDA store_len
                ADC #2
                STA b_tmp
                LDA #1
                STA h_tmp
                LDA store_style
                AND #32
                BEQ pb_low
                INC h_tmp
pb_low          LDA #0
                JSR colour
                JSR kader
                LDA store_style        ; Filtreer grijs uit style
                ORA #4
                STA store_style

                LDA #" "               ; Plaats spatie
                LDX x_min
                LDY y_min
                JSR sprite

                LDA store_len          ; Plaats Text op knop
                BEQ no_pb_text
                INX
                JSR txt

no_pb_text      LDA store_style
                AND #$FD
                STA store_style
                LDA #" "               ; Plaats spatie met vert.streep
                LDX x_max
                DEX
                JMP sprite

pb_click        LDA x_min              ; Inverteer knop
                STA x_tmp
                LDA y_min
                STA y_tmp
                SEC
                LDA x_max
                SBC x_min
                STA b_tmp
                SEC
                LDA y_max
                SBC y_min
                STA h_tmp
                LDA #$FE
                STA m_tmp
                JSR block

pb_wait         JSR block              ; Inverteer knop

pb_cont         LDA dlg_base_lo        ; Plaats Exit in Var-DLGCREATE
                STA tmp_adres
                LDA dlg_base_hi
                STA tmp_adres+1
                LDY #5
                LDA (tmp_adres),Y
                TAX
                LDA store_var

setvar          STA $2E1,X
                LDA #0
                STA $2FC,X
                STA $317,X
                STA $332,X
                RTS

; === COMMANDO DLGOPTION Exit,Text$,Style,X,Y
dlgoption       LDA #4                 ; Mode = option
                STA store_mode
                JSR param1             ; Lees Exit,Text$,Style,X,Y

                LDA store_len          ; Test of string leeg is
                BEQ no_opt_text

                JSR limits             ; Bepaal x_min,x_max,y_min,y_max
                JSR store_dat          ; Plaats parameters in tabel

                LDA store_len          ; Plaats text
                LDX x_min
                LDY y_min
                JSR txt

no_opt_text     RTS

op_click        JMP pb_cont

param1          JSR get5               ; Lees Exit-code
                JMP get2               ; Lees Text$,Style,X,Y

; === COMMANDO DLGICON Exit,IconNr,Text$,Style,X,Y
icon_nr    equ store_height
xpos_txt   equ data

dlgicon         LDA #7                 ; Mode = icon
                STA store_mode
                JSR param2             ; Lees Exit,ASCII,Text$,Style,X,Y
                JSR limits             ; Bepaal x_min,x_max,y_min,y_max

                LDX x_min              ; Pas x_max aan
                INX
                INX
                STX x_max

                LDY y_min              ; Pas y_max aan
                INY
                INY
                STY y_max
                LDA store_style
                AND #32
                BEQ no_bigicon
                INC y_max
                INC y_max

no_bigicon      JSR store_dat          ; Zet parameters in tabel

                LDA store_len          ; Check op plaatsen text
                BEQ no_text

                LDY y_min              ; Plaats text onder icoon
                INY
                INY
                LDA store_style        
                AND #32                ; Test op dubbele hoogte
                BEQ not_big4
                INY
                INY
not_big4        LDA store_len
                LSR A
                STA xpos_txt
                SEC
                LDA x_min
                SBC xpos_txt
                TAX
                INX
                LDA store_len
                JSR txt

no_text         LDA store_style        ; Filtreer style op dubbele hoogte
                AND #32
                STA store_style

                LDA icon_nr            ; 0<=Icon<=31
                AND #31
                ASL A                  ; Karakter = Icon * 4 +128
                ASL A
                CLC
                ADC #128
                TAX

                STX dlg_buffer         ; Plaats iconen links-+rechtsboven
                INX
                INX
                STX dlg_buffer+1
                LDX x_min
                LDY y_min
                LDA #2
                JSR txt

                INC dlg_buffer         ; Plaats iconen links-+rechtsonder
                INC dlg_buffer+1
                INY
                LDA store_style        ; Test op dubbele hoogte
                AND #32
                BEQ not_big
                INY
not_big         LDA #2
                JMP txt

ic_click        JMP pb_cont

param2          JSR get5               ; Lees Exit-code
                JSR get4               ; Lees IconNr
                JMP get2               ; Lees Text$,Style,X,Y

; === COMMANDO DLGLABEL Text$,Style,X,Y
dlglabel        
                JSR param3             ; Lees Text$,Style,X,Y

                CLC                    ; Plaats text$
                LDA x_base
                ADC store_x
                TAX
                CLC
                LDA y_base
                ADC store_y
                TAY
                LDA store_len
                JMP txt

param3          JMP get2               ; Lees Text$,Style,X,Y

; === COMMANDO DLGRADIOBUTTON Var,Text$,Style,X,Y
tmp_var    equ  nulblock+4
bitmask    equ  nulblock+5
r_ptr_lo   equ  nulblock+6
r_ptr_hi   equ  nulblock+7

dlgradiobutton  LDA #2                 ; Mode = radiobutton
                STA store_mode
                JSR param4             ; Lees Var,Text$,Style,X,Y
                JSR limits             ; Bepaal x_min,x_max,y_min,y_max

                INC x_max              ; Pas x_max aan
                INC x_max

                JSR store_dat          ; Zet parameters in tabel

                LDX x_min              ; Plaats text
                INX
                INX
                LDY y_min
                LDA store_len
                JSR txt

rb_cont         LDA #1                 ; Masker = bit 1
                STA bitmask

                LDA dlg_base_lo        ; Zet Pointer op begin tabel
                STA r_ptr_lo
                LDA dlg_base_hi
                STA r_ptr_hi

                LDA store_var          ; Bewaar Var-letter
                STA tmp_var

rb_loop         JSR inc_r_ptr          ; Lees volgende item

                LDA r_ptr_hi           ; Test op einde tabel
                CMP dlg_ptr_hi
                BEQ test_lo
                JMP test_ok
test_lo         LDA r_ptr_lo
                CMP dlg_ptr_lo
                BEQ rb_end

test_ok         LDA r_ptr_lo           ; Lees parameters in buffer
                STA tmp_adres
                LDA r_ptr_hi
                STA tmp_adres+1
                JSR dat_read

                LDA store_mode         ; Test of item radiobutton is
                CMP #2
                BNE rb_loop

                LDA store_var          ; Test op radiobutton met dezelfde Var
                CMP tmp_var
                BNE rb_loop

                LDA bitmask            ; Bewaar bitnr in tabel
                LDY #11
                STA (r_ptr_lo),Y

                LDX store_var          ; Test of bitnr gezet is
                LDA $2E1,X
                AND bitmask
                BEQ rb_leeg

                LDA bitmask            ; Plaats bitnr in Var
                JSR setvar

                LDA #5                 ; Radiobutton = vol
                JMP rb_set

rb_leeg         LDA #6                 ; Radiobutton = leeg

rb_set          LDY #0                 ; Style = normaal
                STY store_style
                LDX x_min
                LDY y_min
                JSR sprite             ; Plaats radiobutton

                LDA bitmask            ; Bitnr = volgende
                ASL A
                STA bitmask
                JMP rb_loop

rb_end          RTS

rb_click        LDA foc_ptr_lo         ; Lees parameters focus in buffer
                STA tmp_adres
                LDA foc_ptr_hi
                STA tmp_adres+1
                JSR dat_read

                LDA store_var          ; Plaats bitnr in Var
                STA tmp_var
                TAX
                LDY #11
                LDA (foc_ptr_lo),Y
                JSR setvar

                JSR un_foc_item        ; Haal focus weg
                JSR rb_cont            ; Plaats radiobutton
                JMP foc_item           ; Zet focus

inc_r_ptr       CLC                    ; Verhoog Pointer met 18
                LDA r_ptr_lo
                ADC #12
                STA r_ptr_lo
                BCC end_inc_ptr
                INC r_ptr_hi
end_inc_ptr     RTS

; === COMMANDO DLGCHECKBOX Var,Text$,Style,X,Y
dlgcheckbox     LDA #3                 ; Mode = checkbox
                STA store_mode
                JSR param4             ; Lees Var,Text$,Style,X,Y
                JSR limits

                INC x_max              ; Pas x_max aan
                INC x_max

                JSR store_dat          ; Zet parameters in tabel

                LDX x_min              ; Plaats text$
                INX
                INX
                LDY y_min
                LDA store_len
                JSR txt

cb_set          LDA #0                 ; Style = normaal
                STA store_style

                LDX store_var          ; Lees Variabele
                LDA $2E1,X
                BEQ cb_empty

                LDA #7                 ; Checkbox = vol
                JMP cb_put

cb_empty        LDA #8                 ; Checkbox = leeg

cb_put          LDX x_min              ; Plaats checkbox
                LDY y_min
                JMP sprite

cb_click        LDX store_var          ; Lees Variabele
                LDA $2E1,X
                BEQ cb_on

                LDA #0                 ; Variabele = 0
                JSR setvar
                JMP cb_set

cb_on           LDA #1                 ; Variabele = 1
                JSR setvar
                JMP cb_set

param4          JSR get                ; Lees Var
                JMP get2               ; Lees Text$,Style,X,Y

; === COMMANDO DLGTEXT Var,Text$,Style,X,Y,Width
tx_curs_pos   equ  nulblock+4

dlgtext         LDA #5                 ; Mode = text
                STA store_mode
                JSR param5             ; Lees Var,Text$,Style,X,Y,Width
                JSR limits             ; Bepaal x_min,x_max,y_min,y_max

                LDX x_min              ; Plaats text$
                LDY y_min
                LDA store_len
                JSR txt

                JSR tx_buf             ; Lees string in buffer

                CLC                    ; Pas breedte focus aan
                LDA x_min
                ADC store_len
                STA x_min

                LDA x_min
                ADC store_width
                STA x_max

                LDY y_min              ; Zet focushoogte op 1
                INY
                STY y_max
                JSR store_dat          ; Bewaar parameters in tabel

                CLC                    ; Plaats kader
                LDA x_min
                STA x_tmp
                LDA y_min
                STA y_tmp
                LDA store_width
                STA b_tmp
                LDA #1
                STA h_tmp
                JSR kader

                LDA #0                 ; Style = normaal
                STA store_style
                JMP tx_string          ; Plaats string

tx_click        JSR read_dat           ; Lees parameters in buffer
                JSR tx_buf             ; Lees string in buffer

                LDA #0                 ; Style = normaal
                STA store_style

                STA tx_curs_pos        ; Reset cursorpositie

tx_loop         JSR tx_string          ; Plaats string

                JSR tx_curs_inv        ; Inverteer karakter onder cursor
                CLC
                LDA x_min
                ADC tx_curs_pos
                TAX
                LDY tx_curs_pos
                LDA dlg_buffer,Y
                LDY y_min
                JSR sprite

                JSR tx_curs_inv        ; Inverteer karakter onder cursor

tx_scanloop     JSR wait_key           ; Lees toets

                CMP #esc               ; Toets = Escape
                BEQ tx_esc

                CMP #ret               ; Toets = Return
                BEQ tx_ret

                CMP #bsp               ; Toets = Backspace
                BEQ tx_bsp

                CMP #32                ; Toets = ASCII karakter
                BMI tx_scanloop
                CMP #127
                BPL tx_scanloop

                LDX tx_curs_pos
                STA dlg_buffer,X
                JSR tx_curs_verhoog
                JMP tx_loop

tx_curs_verlaag LDA tx_curs_pos        ; Cursor 1 positie naar links
                BEQ tx_curs_end        ; Test op uiterste positie links
                DEC tx_curs_pos
                RTS

tx_curs_verhoog INC tx_curs_pos        ; Cursor 1 positie naar rechts
                LDA tx_curs_pos
                CMP store_width        ; Test op uiterste positie rechts
                BNE tx_curs_end
                DEC tx_curs_pos
tx_curs_end     RTS

tx_bsp          LDA tx_curs_pos        ; Check op positie cursor
                BEQ tx_scanloop
                JSR tx_curs_verlaag    ; Cursorpositie 1 positie naar links

                LDX tx_curs_pos        ; Plaats spatie op cursorpositie
                LDA #32
                STA dlg_buffer,X
                JMP tx_loop

tx_ret          LDX store_var          ; Lees string adres
                LDA $2E1,X
                STA tmp_adres
                LDA $2FC,X
                STA tmp_adres+1

                LDY store_width
                DEY

tx_loop1        LDA dlg_buffer,Y
                CMP #32
                BNE tx_next
                LDA #13
                STA dlg_buffer,Y
                DEY
                BPL tx_loop1

tx_next         LDY #$FF               ; Plaats buffer op stringadres
tx_buf_copy     INY
                LDA dlg_buffer,Y
                STA (tmp_adres),Y
                CMP #$0D
                BNE tx_buf_copy

                JSR tx_string          ; Plaats string
                JSR chk_ret_key        ; Test op loslaten Return
tx_esc          RTS

tx_buf          LDX store_var          ; Lees stringadres
                LDA $2E1,X
                STA tmp_adres
                LDA $2FC,X
                STA tmp_adres+1

                LDY #0
                LDA #32
tx_loop2        STA dlg_buffer,Y
                INY
                CPY store_width
                BNE tx_loop2
                LDA #13
                STA dlg_buffer,Y

                LDY #0                 ; Plaats string in buffer
tx_copy         LDA (tmp_adres),Y
                CMP #$0D
                BEQ tx_end
                STA dlg_buffer,Y
                INY
                CPY store_width        ; Zet breedte
                BNE tx_copy

tx_end          RTS

tx_string       LDX x_min              ; Plaats string
                LDY y_min
                LDA store_width
                JMP txt

tx_curs_inv     LDA store_style        ; Inverteer Style-inverteer bit
                EOR #8
                STA store_style
                RTS

param5          JSR get                ; Lees Var
                JSR get2               ; Lees Text$,Style,X,Y
                JMP get3               ; Lees Width

; === COMMANDO DLGLISTBOX Exit,Var,X,Y,B,H,MaxRec,Pointer
arraypointer    equ store_var1
maxrec          equ store_var2
toprecord       equ nulblock+6
scrteller       equ nulblock+7
scrpointer      equ nulblock+8
arrayadres      equ nulblock+9

          
dlglistbox      LDA #8                 ; Mode = listbox
                STA store_mode
                JSR param7             ; Lees Exit,Var,X,Y,B,H,MaxRec,Pointer

                JSR limits             ; Bepaal x_min,x_max,y_min,y_max

                CLC                    ; Pas x_max aan
                LDA x_min
                ADC store_width
                STA x_max
                INC x_max

                CLC                    ; Pas y_max aan
                LDA y_min
                ADC store_height
                STA y_max

                JSR store_dat

                LDA x_min              ; Plaats kader
                STA x_tmp
                LDA y_min
                STA y_tmp
                LDA store_width
                STA b_tmp
                INC b_tmp
                LDA store_height
                STA h_tmp
                JSR kader

scherm_vul      JSR bepaal_adres       ; Bepaal adres voor variabelen
                LDY #1
                LDA maxrec
                STA (tmp_adres),Y      ; Schrijf maxrec in array
                INY
                LDA toprecord
                STA (tmp_adres),Y      ; Schrijf toprecord in array
                INY
                LDA arraypointer
                STA (tmp_adres),Y      ; Schrijf arraypointer in array

                JSR schuifbalk
                JSR vul_venster
                LDA maxrec
                BEQ no_copykeus
                JSR copy_keuze
no_copykeus     RTS

schuifbalk      LDA #0                 ; Style = normaal
                STA store_style

                LDX x_max              ; Plaats pijl hoog schuifbalk
                DEX
                LDY y_min
                LDA #2
                JSR sprite

raster_loop     INY                    ; Plaats raster schuifbalk
                CPY y_max
                BEQ end_schuif
                LDA #4
                JSR sprite
                JMP raster_loop

end_schuif      DEY                    ; Plaats pijl neer schuifbalk
                LDA #3
                JSR sprite

                SEC                    ; Bepaal positie schuifknop
                LDA store_height       ; Bereken Y=H-3
                SBC #3
                TAY
                LDX toprecord          ; X=pointer
                JSR multiply
                TAX                    ; X=pointer * (H-3)
                LDY maxrec
                BEQ no_schuif
                DEY                    ; Y=maxrec - 1
                BEQ no_schuif
                JSR divide
                CLC                    ; Y=(pointer * (H-3))/(maxrec-1) +
                ADC y_min              ; y_min + 1
                TAY
                INY

                LDX x_max              ; Plaats schuifknop
                DEX
                LDA #1
                JSR sprite

no_schuif       RTS

item_adres      JSR bepaal_adres       ; Bepaal adres 1e arrayitem
                CLC
                LDA tmp_adres
                ADC #4
                STA tmp_adres
                BCC no_adres_inc
                INC tmp_adres+1

no_adres_inc    LDX scrpointer         ; Bepaal Adres arrayitem
                BEQ skip_ok

adres_loop      CLC                    ; Zet adres op volgende item
                LDY store_width
                INY
                TYA
                ADC tmp_adres
                STA tmp_adres
                BCC not_adres_inc
                INC tmp_adres+1

not_adres_inc   DEX
                BNE adres_loop
skip_ok         RTS

vul_venster     LDA #0                 ; Reset scrteller
                STA scrteller

scr_loop        CLC                    ; Bereken scrpointer=toprecord+teller
                LDA toprecord
                ADC scrteller
                STA scrpointer
                JSR item_adres

                LDX #0                 ; Als scrpointer=arraypointer, invert
                LDA scrpointer
                CMP arraypointer
                BNE not_invert
                LDX #8
not_invert      STX store_style

                LDA scrpointer
                CMP maxrec
                BMI not_empty
                LDX #0
                LDA #32
empty_loop      STA dlg_buffer,X
                INX
                CPX store_width
                BNE empty_loop
                LDA #13
                STA dlg_buffer,X
                JMP plaats_text

not_empty       LDA tmp_adres          ; Plaats Adres$ in listbox
                STA $52
                LDA tmp_adres+1
                STA $53
                JSR copy_text

plaats_text     LDX x_min
                CLC
                LDA y_min
                ADC scrteller
                TAY
                LDA store_width
                JSR txt

                INC scrteller          ; Check of listbox vol is
                LDA scrteller
                CMP store_height
                BEQ end_lb
                JMP scr_loop

end_lb          RTS

copy_keuze      LDX store_var
                LDA $2E1,X
                STA arrayadres
                LDA $2FC,X
                STA arrayadres+1

                LDA arraypointer
                STA scrpointer
                JSR item_adres

                LDY #0
next_char       LDA (tmp_adres),Y
                STA (arrayadres),Y
                INY
                CMP #13
                BNE next_char
                RTS

lb_click
x_mouse_tmp     equ data
y_mouse_tmp     equ data+1

                JSR read_adres         ; Lees parameters in buffer

                JSR rd_x_mouse         ; Bepaal x-positie in listbox
                LSR A
                LSR A
                LSR A
                STA x_mouse_tmp

                JSR rd_y_mouse         ; Bepaal y-positie in listbox
                EOR #255
                LSR A
                LSR A
                LSR A
                STA y_mouse_tmp

                LDX x_max              ; Kijk of x-muis in schuifbalk staat
                DEX
                CPX x_mouse_tmp
                BEQ in_balk
                JMP file

in_balk         CMP y_min              ; Kijk of muis op pijl hoog staat
                BEQ pijl_hoog

                LDX y_max
                DEX
                TXA
                CMP y_mouse_tmp        ; Kijk of pijl op pijl neer staat
                BEQ pijl_neer

                JMP scanloop           ; Pijl staat op raster schuifbalk

file            SEC                    ; Pijl staat op vak met regels
                SBC y_min
                CLC
                ADC toprecord
                CMP maxrec             ; Kijk of regel leeg is
                BMI invert_file

                JMP scanloop           ; Regel is leeg

invert_file     STA arraypointer       ; Inverteer regel
                JSR copy_keuze         ; Copieer regel naar $array
                JSR scherm_vul         ; Teken regelvak opnieuw

                LDA dlg_base_lo        ; Plaats Exit in Var-DLGCREATE
                STA tmp_adres
                LDA dlg_base_hi
                STA tmp_adres+1
                LDY #5
                LDA (tmp_adres),Y
                TAX
                LDA store_len
                JSR setvar
                JMP un_foc_item

pijl_hoog       JSR read_adres

                LDA toprecord          ; Als venster niet op 1e regel dan hoog
                BEQ top_of_screen
                DEC toprecord
                
top_of_screen   JSR scherm_vul
                JMP scanloop

pijl_neer       JSR read_adres

                LDX toprecord          ; Als niet op laatste regel dan omlaag
                INX
                CPX maxrec
                BEQ end_of_screen
                INC toprecord
                
end_of_screen   JSR scherm_vul
                JMP scanloop

bepaal_adres    LDX store_var          ; Bepaal adres array
                LDA $2E1,X
                STA tmp_adres
                LDA $2FC,X
                STA tmp_adres+1

                CLC                    ; Zet adres op 1e arrayitem
                LDA tmp_adres
                ADC store_width
                STA tmp_adres
                BCC go_adres
                INC tmp_adres+1

go_adres        RTS

read_adres      JSR read_dat
                JSR bepaal_adres

                LDY #1                 ; Lees maxrec uit array
                LDA (tmp_adres),Y
                STA maxrec

                INY                    ; Lees toprecord uit array
                LDA (tmp_adres),Y
                STA toprecord

                INY                    ; Lees arraypointer uit array
                LDA (tmp_adres),Y
                STA arraypointer

                RTS

multiply                               ; Vermenigvuldig A = X x Y
dummy           equ data
uitkomst        equ data+1
                STX dummy
                STX uitkomst

mult_loop       DEY
                BEQ end_mult
                CLC
                LDA uitkomst
                ADC dummy
                STA uitkomst
                JMP mult_loop

end_mult        LDA uitkomst
                RTS                

divide                                 ; Delen A = X / Y
rest            equ data
deler           equ data+1
som             equ data+2

                STX rest
                STY deler
                LDA #0
                STA som

div_loop        SEC
                LDA rest
                SBC deler
                STA rest
                BCC end_div
                INC som
                JMP div_loop

end_div         LDA som
                RTS

param7          JSR read_num           ; Lees Exitcode in store_len
                STA store_len
                JSR get                ; Lees Var
                JSR get6               ; Lees X,Y
                JSR get3               ; Lees Width
                JSR get4               ; Lees Height
                JSR read_num           ; Lees MaxRec
                STA maxrec
                JSR read_num           ; Lees ArrayPointer
                CMP maxrec
                BMI pointer_ok
                LDX maxrec
                DEX
                TXA
pointer_ok      STA arraypointer       
                LDA #0
                STA toprecord          ; Reset TopRecord
                RTS

; === COMMANDO DLGFRAME Text$,Style,X,Y,B,H
dlgframe        JSR param6             ; Lees Text$,Style,X,Y,Width,Height

                CLC                    ; Plaats kader
                LDA x_base
                ADC store_x
                STA x_min
                STA x_tmp
                CLC
                LDA y_base
                ADC store_y
                STA y_min
                STA y_tmp
                LDA store_width
                STA b_tmp
                LDA store_height
                STA h_tmp
                JSR kader

                SEC                    ; Bepaal positie text$
                LDA store_width
                SBC store_len
                LSR A
                CLC
                ADC x_min
                TAX
                LDY y_min
                DEY
                LDA store_len
                JMP txt                ; Plaats text$ in midden van kaderlijn

param6          JSR get2               ; Lees Text$,Style,X,Y
                JSR get3               ; Lees Width
                JMP get4               ; Lees Height

; === COMMANDO DLGHOTSPOT Exit,X,Y,B,H,VarX,VarY
dlghotspot      LDA #6
                STA store_mode

                JSR get5               ; Lees Exitcode
                PHA                    ; Bewaar Exitcode
                JSR get6               ; Lees X,Y
                JSR get3               ; Lees B
                JSR get4               ; Lees H
                JSR get                ; Lees VarX op store_len
                LDA store_var
                STA store_len
                JSR get                ; Lees VarY op store_style
                LDA store_var
                STA store_style

                PLA                    ; Plaats Exitcode op store_var
                STA store_var

                JSR limits             ; Bepaal x_min,x_max,y_min,y_max

                CLC                    ; Pas x_max aan
                LDA x_min
                ADC store_width
                STA x_max

                CLC                    ; Pas y_max aan
                LDA y_min
                ADC store_height
                STA y_max

                JMP store_dat          ; Bewaar parameters in tabel

hs_click        JSR rd_x_mouse         ; Lees X-muis
                LSR A
                LSR A
                LSR A
                SEC
                SBC x_min
                LDX store_len
                JSR setvar             ; X-muispointer = X-muis/8

                JSR rd_y_mouse         ; Lees Y-muis
                EOR #$FF               ; Maak nul positie linksboven 
                LSR A
                LSR A
                LSR A
                SEC
                SBC y_min
                LDX store_style
                JSR setvar             ; Y-muispointer = Y-muis/8

                JMP pb_cont

; === COMMANDO DLGEND
dlgend          LDA dlg_base_lo        ; Reset focuspointer
                STA foc_ptr_lo
                LDA dlg_base_hi
                STA foc_ptr_hi

                JSR inc_foc_ptr        ; focuspointer op eerste item
                JSR test_end_tabel     ; Test op einde tabel
                BCC not_end
                JMP end_sub
not_end         JSR foc_item           ; Focus item

scanloop        JSR scan_toets         ; Lees toets
                BCC end_scan           ; Check of toets is ingedrukt

                JSR scan_muis          ; Scan muis
                BCS scanloop           ; Test op toets muis is ingedrukt

end_scan        CPY #copy              ; Copy-toets ingedrukt
                BEQ copy_key

                CPY #delete            ; Delete-toets ingedrukt
                BEQ del_key

                CPY #spatie            ; Spatie-balk ingedrukt
                BEQ ret_key

                CPY #escape            ; Escape-toets ingedrukt
                BNE scanloop
                RTS

copy_key        JSR un_foc_item        ; Haal focus weg
                JSR inc_foc_ptr        ; Focuspointer op volgende item

                JSR test_end_tabel     ; Test op einde tabel
                BCC copy_end

                LDA dlg_base_lo        ; Reset focuspointer
                STA foc_ptr_lo
                LDA dlg_base_hi
                STA foc_ptr_hi
                JSR inc_foc_ptr        ; Zet focuspointer op eerste item
copy_end        JSR foc_item           ; Zet focus

copy_wait       JSR scan_toets         ; Test op loslaten copy-toets
                CPY #copy
                BEQ copy_wait
                JMP scanloop

del_key         JSR un_foc_item        ; Haal focuspointer weg
                JSR dec_foc_ptr        ; Zet focuspointer op vorige item

                LDA foc_ptr_lo         ; Test op eerste item
                CMP dlg_base_lo
                BNE del_end
                LDA foc_ptr_hi
                CMP dlg_base_hi
                BNE del_end

                LDA dlg_ptr_lo         ; Zet focuspointer op einde tabel
                STA foc_ptr_lo
                LDA dlg_ptr_hi
                STA foc_ptr_hi
                JSR dec_foc_ptr        ; Zet focuspointer op laatste item
del_end         JSR foc_item           ; Zet focus

del_wait        JSR scan_toets         ; Test op loslaten delete-toets
                CPY #delete
                BEQ del_wait
                JMP scanloop

ret_key         JSR read_dat           ; Lees parameters in buffer
                JSR chk_ret_key        ; Check op loslaten Spatiebalk

                LDA store_mode         ; Test of item pushbutton is
                CMP #1
                BNE chk_rb
                JSR un_foc_item        ; Haal focus weg
                JMP pb_click

chk_rb          CMP #2                 ; Test of item radiobutton is
                BNE chk_cb
                PHA
                JSR rb_click
                PLA

chk_cb          CMP #3                 ; Test of item checkbox is
                BNE chk_op
                PHA
                JSR cb_click
                PLA

chk_op          CMP #4                 ; Test of item option is
                BNE chk_te
                JSR un_foc_item        ; Haal focus weg
                JMP op_click

chk_te          CMP #5                 ; Test of item textbox is
                BNE chk_hs
                PHA
                JSR tx_click
                PLA

chk_hs          CMP #6                 ; Test of item hotspot is
                BNE chk_ic
                JSR un_foc_item        ; Haal focus weg
                JMP hs_click

chk_ic          CMP #7                 ; Test of item icon is
                BNE chk_lb
                JSR un_foc_item        ; Haal focus weg
                JMP ic_click

chk_lb          CMP #8                 ; Test of item listbox is
                BNE chk_end
                JMP lb_click

chk_end         JMP scanloop

un_foc_item                            ; Inverteer focus
foc_item        LDY #0                 ; Inverteer focus
copy_data       LDA  (foc_ptr_lo),Y    ; Lees coordinaten
                STA x_tmp,Y
                INY
                CPY #4
                BNE copy_data
                JMP focus              ; Zet focus

inc_foc_ptr     CLC                    ; Zet focus op volgende item
                LDA foc_ptr_lo
                ADC #12
                STA foc_ptr_lo
                BCC end_sub
                INC foc_ptr_hi
                RTS

dec_foc_ptr     SEC                    ; Zet focus op vorige item
                LDA foc_ptr_lo
                SBC #12
                STA foc_ptr_lo
                BCS end_sub
                DEC foc_ptr_hi
end_sub         RTS

test_end_tabel  LDA dlg_ptr_lo         ; Test op laatste item
                CMP foc_ptr_lo
                BNE no_end_tabel
                LDA dlg_ptr_hi
                CMP foc_ptr_hi
                BNE no_end_tabel
                SEC
                RTS
no_end_tabel    CLC
                RTS

; === COMMANDO DLGPOINTER PointerNr
dlgpointer      JSR read_num
                JMP ch_mouse_cursor

; === LEES PARAMETERS
get             JMP read_var           ; Lees Var-letter

get2            JSR read_txt           ; Lees Text$

                LDX #$FF               ; Bepaal lengte string
count           INX
                LDA dlg_buffer,X
                CMP #$0D
                BNE count
                STX store_len

                JSR read_num           ; Lees Style
                STA store_style

get6            JSR read_num           ; Lees X
                STA store_x

                JSR read_num           ; Lees Y
                STA store_y
                RTS

get3            JSR read_num           ; Lees Width
                STA store_width
                RTS

get4            JSR read_num           ; Lees Height
                STA store_height
                RTS

get5            JSR read_num           ; Lees Var-waarde
                STA store_var
                RTS

; === LEES VARIABELE  (A-Z)
read_var        LDY $3
                JSR skip_spc           ; Negeer spaties

                CMP #"A"               ; Test of karakter, letter is
                BMI no_var
                CMP #"["
                BPL no_var
                STA store_var

                INY                    ; Spring naar einde parameter
                STY $3
                JMP next_param

no_var          BRK

; === LEES GETAL OF BEREKENING
read_num        JSR read_param         ; Lees expressie
                JSR next_param         ; Spring naar einde expressie

                LDA stack1             ; Zet lo-byte in accu
                LDY #0                 ; Reset stackpointer
                STY stackpointer
                RTS

; === LEES TEXT
read_txt        JSR read_text          ; Lees string in buffer

copy_text       LDX #0                 ; Kopieer string naar buffer
                LDY #0
next_letter     LDA ($52),Y
                STA dlg_buffer,X
                INX
                INY
                CMP #$0D
                BNE next_letter

var_ok          JMP next_param         ; Spring naar einde string

; === SKIP SPATIES
skip            INY                    ; Negeer spaties in interpreter regel
skip_spc        LDA ($05),Y
                CMP #" "
                BEQ skip
                RTS

; === ZET PARAMETERS IN TABEL
store_dat       LDA store_mode
                CMP #6
                BEQ no_filter

                LDA store_style        ; Indien Style = grijs, niet in tabel
                AND #16
                BNE no_inc

no_filter       LDA dlg_ptr_lo         ; Pointer=Einde tabel
                STA tmp_adres
                LDA dlg_ptr_hi
                STA tmp_adres+1

                LDX #x_min-dlg_buffer-1; Zet parameters uit buffer in tabel
                LDY #$FF
volgende        INX
                INY
                LDA dlg_buffer,X
                STA (tmp_adres),Y
                CPX #store_height-dlg_buffer
                BNE volgende
                INY
                CLC
                TYA
                ADC dlg_ptr_lo
                STA dlg_ptr_lo
                BCC no_inc
                INC dlg_ptr_hi
no_inc          RTS

; === LEES PARAMETERS UIT TABEL
read_dat        LDA foc_ptr_lo         ; Pointer = focuspointer
                STA tmp_adres
                LDA foc_ptr_hi
                STA tmp_adres+1

dat_read        LDX #x_min-dlg_buffer-1; Lees waardes uit tabel in buffer
                LDY #$FF
read_nxt        INX
                INY
                LDA (tmp_adres),Y
                STA dlg_buffer,X
                CPX #store_height-dlg_buffer

                BNE read_nxt
                RTS

; === ZET FOCUSGRENZEN
limits          CLC                    ; Bepaal x_min
                LDA x_base
                ADC store_x
                STA x_min

                CLC                    ; Bepaal x_max
                LDA x_min
                ADC store_len
                STA x_max

                CLC                    ; Bepaal y_min
                LDA y_base
                ADC store_y
                STA y_min

                STA y_max              ; Bepaal y_max
                INC y_max
                LDA store_style
                AND #32
                BEQ lim_end
                INC y_max
lim_end         RTS

; === CHECK OP LOSLATEN RETURN TOETS
chk_ret_key     JSR scan_toets         ; Lees toets
                CPY #spatie
                BEQ chk_ret_key
                RTS

; === SCAN MUIS
tmp_x           equ nulblock+8
tmp_y           equ nulblock+9

scan_muis       JSR rd_mouse_button    ; Zet carry als geen muistoets gedrukt is
                AND #1
                BEQ scan_knop
no_key          SEC
                RTS

scan_knop       JSR rd_mouse_button    ; Test op loslaten muistoets
                AND #1
                BEQ scan_knop

                JSR rd_x_mouse         ; Lees X-muis
                LSR A
                LSR A
                LSR A
                STA tmp_x              ; X-muispointer = X-muis/8

                JSR rd_y_mouse         ; Lees Y-muis
                EOR #$FF               ; Maak nul positie linksboven 
                LSR A
                LSR A
                LSR A
                STA tmp_y              ; Y-muispointer = Y-muis/8

                LDA dlg_base_lo        ; Reset pointer op begin tabel
                STA r_ptr_lo
                LDA dlg_base_hi
                STA r_ptr_hi

chk_loop        JSR inc_r_ptr          ; Zet pointer op volgende item

                LDA r_ptr_hi           ; Test op laatste item
                CMP dlg_ptr_hi
                BNE tab_read
                LDA r_ptr_lo
                CMP dlg_ptr_lo
                BEQ no_key

tab_read        LDA r_ptr_lo           ; Lees parameters van tabel in buffer
                STA tmp_adres
                LDA r_ptr_hi
                STA tmp_adres+1
                JSR dat_read

                LDA tmp_x              ; Test of x-muispointer in focus zit
                CMP x_min
                BMI chk_loop
                CMP x_max
                BPL chk_loop

                LDA tmp_y              ; Test of y-muispointer item selecteerd
                CMP y_min
                BMI chk_loop
                CMP y_max
                BPL chk_loop

                JSR un_foc_item        ; Unfocus item
                LDA r_ptr_hi           ; Zet focus op item muispointer
                STA foc_ptr_hi
                LDA r_ptr_lo
                STA foc_ptr_lo
                JSR foc_item           ; Zet focus

                LDY #spatie            ; Indien op focus toets = spatie
                CLC
                RTS

not_sel         JSR un_foc_item        ; Unfocus item
                LDA r_ptr_hi           ; Zet focus op item muispointer
                STA foc_ptr_hi
                LDA r_ptr_lo
                STA foc_ptr_lo
                JSR foc_item           ; Zet focus
                JMP no_key

mul8            CLC                    ; Horizontale verschuiving
                LDA $00,x
                ADC #4
                STA $00,x
                LDY #3                 ; Vermenigvuldig X en Y met 8
mul8loop        ASL $00,x
                ROL $01,x
                ASL $02,x
                ROL $03,x
                DEY
                BNE mul8loop
                RTS