;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;-----------------------------------------------------------------------------
;                             Color scheme

BLACK_ON_WHITE  equ 0
MOVIEOS         equ 1
WHITE_ON_BLACK  equ 2

;                         format - 0xRRGGBB
if COLOR_THEME eq MOVIEOS

        COLOR_BG_NORMAL           = 0x1d272f
        COLOR_BG_BREAKPOINT       = 0x0000aa
        COLOR_BG_SELECTED         = 0xec9300
        COLOR_LINE                = 0x00b9a0
        COLOR_TXT_NORMAL          = 0xffffff
        COLOR_TXT_INACTIVE        = 0x8f7948
        COLOR_TXT_CHANGED         = 0xec9300
        COLOR_TXT_LABEL           = 0x22b14c
        COLOR_TXT_SELECTED        = 0x1d272f
        COLOR_TXT_HEX             = 0xec9300
        COLOR_TXT_BREAKPOINT      = 0xec9300

else if COLOR_THEME eq WHITE_ON_BLACK

        COLOR_BG_NORMAL           = 0x101010 ; dark grey
        COLOR_BG_BREAKPOINT       = 0xFF0000 ; red
        COLOR_BG_SELECTED         = 0x0000FF ; blue
        COLOR_LINE                = 0xFFFFFF ; white
        COLOR_TXT_NORMAL          = 0xFFFFFF ; white
        COLOR_TXT_INACTIVE        = 0x808080 ; grey
        COLOR_TXT_CHANGED         = 0x00AA00 ; green
        COLOR_TXT_LABEL           = COLOR_TXT_NORMAL
        COLOR_TXT_SELECTED        = 0xFFFFFF ; white
        COLOR_TXT_HEX             = COLOR_TXT_NORMAL
        COLOR_TXT_BREAKPOINT      = COLOR_TXT_NORMAL

else  ; BLACK ON WHITE

        COLOR_BG_NORMAL           = 0xffffff ; white
        COLOR_BG_BREAKPOINT       = 0xFF0000 ; red
        COLOR_BG_SELECTED         = 0x0000FF ; blue
        COLOR_LINE                = 0x000000 ; black
        COLOR_TXT_NORMAL          = 0x000000 ; black
        COLOR_TXT_INACTIVE        = 0x808080 ; grey
        COLOR_TXT_CHANGED         = 0x00AA00 ; green
        COLOR_TXT_LABEL           = COLOR_TXT_NORMAL
        COLOR_TXT_SELECTED        = 0xFFFFFF ; white
        COLOR_TXT_HEX             = COLOR_TXT_NORMAL
        COLOR_TXT_BREAKPOINT      = COLOR_TXT_NORMAL

end if

;-----------------------------------------------------------------------------

data_width      equ 80
data_x_pos      equ 12
data_x_size     equ data_width*6

title_x_pos     equ 30
title_y_pos     equ 8
title_y_size    equ 10

;dump_y_pos      equ (registers_y_pos + registers_y_size + 5)
dump_y_pos      equ (title_y_pos + title_y_size)
dump_height     equ 6
dump_y_size     equ (dump_height*10)

disasm_y_pos    equ (dump_y_pos + dump_y_size + 4)
disasm_height   equ 18
disasm_y_size   equ (disasm_height*10)

messages_width  equ data_width
messages_height equ 8
messages_x_pos  equ data_x_pos
messages_y_pos  equ (disasm_y_pos + disasm_y_size + 4)
messages_x_size equ messages_width*6
messages_y_size equ messages_height*10

cmdline_width   equ data_width
cmdline_x_pos   equ data_x_pos
cmdline_y_pos   equ (messages_y_pos + messages_y_size + 4)
cmdline_x_size  equ messages_x_size
cmdline_y_size  equ 10

registers_x_pos equ (data_x_pos + messages_x_size + 4)
registers_y_pos equ (title_y_pos + title_y_size - 3)
registers_x_size equ 134+2*6
registers_y_size equ (cmdline_y_pos + cmdline_y_size - registers_y_pos+1)

wnd_x_size      equ (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10
wnd_y_size      equ (cmdline_y_pos + cmdline_y_size + data_x_pos)

;-----------------------------------------------------------------------------
;                          Entry point

; TODO: split all gui part in independent function, move entry point into mtdbg.asm

start:
        ; initialize process heap
        mcall   68, 11

        push    eax
        fstcw   word [esp]
        pop     eax
        and     ax, not (3 shl 10)
        or      ax, 1 shl 10    ; set round-to-minus infinity mode
        push    eax
        fldcw   word [esp]
        pop     eax

        mov     edi, messages
        mov     ecx, messages_width*messages_height
        mov     al, ' '
        rep stosb
        xor     eax, eax
        mov     [messages_pos], eax
        mov     [cmdline_len], eax
        mov     [cmdline_pos], eax
        mov     edi, needzerostart
        mov     ecx, (needzeroend-needzerostart+3)/4
        rep stosd
        mov     esi, begin_str
        call    put_message_nodraw
        ; set event mask - default events and debugging events
        mcall   40, 0x107
        ; set debug messages buffer
        mov     ecx, dbgbufsize
        mov     dword [ecx], 256
        xor     ebx, ebx
        mov     [ecx+4], ebx
        mov     al, 69
        mcall
        mov     esi, i_param
        call    get_arg.skip_spaces
        test    al, al
        jz      dodraw
        push    esi
        call    draw_window
        pop     esi
        call    OnLoadInit
        jmp     waitevent

dodraw:
        call    draw_window

waitevent:
        mcall   10
        cmp     al, 9
        jz      debugmsg
        dec     eax
        jz      dodraw
        dec     eax
        jz      keypressed
        dec     eax
        jnz     waitevent
        ; button pressed - we have only one button (close)
        mcall   -1

; TODO: split in more independent function
keypressed:
        mov     al, 2
        mcall
        shr     eax, 8
        cmp     al, 8
        jz      .backspace
        cmp     al, 0xB0
        jz      .left
        cmp     al, 0xB3
        jz      .right
        cmp     al, 0x0D
        jz      .enter
        cmp     al, 0xB6
        jz      .del
        cmp     al, 0xB4
        jz      .home
        cmp     al, 0xB5
        jz      .end
        cmp     al, 0xB1
        jz      .down
        cmp     al, 0xB2
        jz      .up
        cmp     ah, 0x41
        jz      F7
        cmp     ah, 0x42
        jz      F8
        cmp     [cmdline_len], cmdline_width
        jae     waitevent
        push    eax
        call    clear_cmdline_end
        pop     eax
        mov     edi, cmdline
        mov     ecx, [cmdline_len]
        add     edi, ecx
        lea     esi, [edi-1]
        sub     ecx, [cmdline_pos]
        std
        rep movsb
        cld
        stosb
        inc     [cmdline_len]
        call    draw_cmdline_end
        inc     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent

    .backspace:
        cmp     [cmdline_pos], 0
        jz      waitevent
        dec     [cmdline_pos]

    .delchar:
        call    clear_cmdline_end
        mov     edi, [cmdline_pos]
        dec     [cmdline_len]
        mov     ecx, [cmdline_len]
        sub     ecx, edi
        add     edi, cmdline
        lea     esi, [edi+1]
        rep movsb
        call    draw_cmdline_end
        call    draw_cursor
        jmp     waitevent

    .del:
        mov     eax, [cmdline_pos]
        cmp     eax, [cmdline_len]
        jae     waitevent
        jmp     .delchar

    .left:
        cmp     [cmdline_pos], 0
        jz      waitevent
        call    hide_cursor
        dec     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent

    .right:
        mov     eax, [cmdline_pos]
        cmp     eax, [cmdline_len]
        jae     waitevent
        call    hide_cursor
        inc     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent

    .home:
        call    hide_cursor
        and     [cmdline_pos], 0
        call    draw_cursor
        jmp     waitevent

    .end:
        call    hide_cursor
        mov     eax, [cmdline_len]
        mov     [cmdline_pos], eax
        call    draw_cursor

    .up:
    .down:
        jmp     waitevent

        ; We also trying to execute previous command, if empty command_line
    .enter:
        mov     ecx, [cmdline_len]
        test    ecx, ecx
        jnz     .exec_cur
        mov     cl, byte [cmdline_prev]
        cmp     cl, 0
        jz      waitevent

    .exec_prev:
        mov     esi, cmdline_prev
        jmp     .exec

    .exec_cur:
        mov     esi, cmdline

    .exec:
        mov     byte [esi+ecx], 0
        and     [cmdline_pos], 0
        push    esi
        call    clear_cmdline_end
        call    draw_cursor
        pop     esi
        and     [cmdline_len], 0
        ; skip leading spaces
        call    get_arg.skip_spaces
        cmp     al, 0
        jz      waitevent
        ; now esi points to command
        push    esi
        mov     esi, prompt
        call    put_message_nodraw
        pop     esi
        push    esi
        call    put_message_nodraw

; TODO: add meaningful name
z1:
        mov     esi, newline
        call    put_message
        pop     esi
        push    esi
        call    get_arg
        mov     [curarg], esi
        pop     edi
        mov     esi, commands
        call    find_cmd
        mov     eax, aUnknownCommand
        jc      .x11

        ; check command requirements
        ; flags field:
        ; &1: command may be called without parameters
        ; &2: command may be called with parameters
        ; &4: command may be called without loaded program
        ; &8: command may be called with loaded program
        mov     eax, [esi+8]
        mov     ecx, [curarg]
        cmp     byte [ecx], 0
        jz      .noargs
        test    byte [esi+16], 2
        jz      .x11
        jmp     @f

    .noargs:
        test    byte [esi+16], 1
        jz      .x11

    @@:
        cmp     [debuggee_pid], 0
        jz      .nodebuggee
        mov     eax, aAlreadyLoaded
        test    byte [esi+16], 8
        jz      .x11
        jmp     .x9

    .nodebuggee:
        mov     eax, need_debuggee
        test    byte [esi+16], 4
        jnz     .x9

    .x11:
        xchg    esi, eax
        call    put_message

        ; store cmdline for repeating
    .x10:
        mov     esi, cmdline
        mov     ecx, [cmdline_len]

    @@:
        cmp     ecx, 0
        jle     .we
        mov     al, [esi + ecx]
        mov     [cmdline_prev + ecx], al
        dec     ecx
        jmp     @b

    .we:
        mov     [cmdline_len], 0
        jmp     waitevent

    .x9:
        call    dword [esi+4]
        jmp     .x10

;-----------------------------------------------------------------------------
;                            Cmdline handling

clear_cmdline_end:
        mov     ebx, [cmdline_pos]
        mov     ecx, [cmdline_len]
        sub     ecx, ebx
        imul    ebx, 6
        imul    ecx, 6
        inc     ecx
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        or      ebx, ecx
        mov     ecx, [cmdline_y_pos_dd]
        mov     cx, cmdline_y_size
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box for cmdline
        mcall   13
        ret

draw_cmdline:
        xor     ebx, ebx
        jmp     @f

; TODO: make it local
draw_cmdline_end:
        mov     ebx, [cmdline_pos]

    @@:
        mov     esi, [cmdline_len]
        sub     esi, ebx

        mov     ecx, COLOR_TXT_NORMAL
        lea     edx, [cmdline+ebx]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        mov     bx, word[cmdline_y_pos_dd+4]
        inc     bx
        ; draw a text string in the window
        mcall   4
        ret

;-----------------------------------------------------------------------------
;                        Working with messages
; in: esi->ASCIIZ message
put_message_nodraw:
        mov     edx, [messages_pos]

    .m:
        lea     edi, [messages+edx]

    .l:
        lodsb
        cmp     al, 0
        jz      .done
        call    test_scroll
        cmp     al, 10
        jz      .newline
        cmp     al, '%'
        jnz     @f
        cmp     dword [esp], z1
        jnz     .format

    @@:
        stosb
        inc     edx
        jmp     .l

    .newline:
        push    edx
        mov     ecx, messages_width
        xor     eax, eax
        xchg    eax, edx
        div     ecx
        xchg    eax, edx
        pop     edx
        test    eax, eax
        jz      .m
        sub     edx, eax
        add     edx, ecx
        jmp     .m

    .done:
        mov     [messages_pos], edx
        ret

        ; at this moment all format specs must be %<digit>X
    .format:
        lodsb   ; get <digit>
        sub     al, '0'
        movzx   ecx, al
        lodsb
        pop     eax
        pop     ebp
        push    eax
        ; write number in ebp with ecx digits
        dec     ecx
        shl     ecx, 2

    .writenibble:
        push    ecx
        call    test_scroll
        pop     ecx
        mov     eax, ebp
        shr     eax, cl
        and     al, 0xF
        cmp     al, 10
        sbb     al, 69h
        das
        stosb
        inc     edx
        sub     ecx, 4
        jns     .writenibble
        jmp     .l

test_scroll:
        cmp     edx, messages_width*messages_height
        jnz     .ret
        push    esi
        mov     edi, messages
        lea     esi, [edi+messages_width]
        mov     ecx, (messages_height-1)*messages_width/4
        rep movsd
        push    eax
        mov     al, ' '
        push    edi
        push    messages_width
        pop     ecx
        sub     edx, ecx
        rep stosb
        pop     edi
        pop     eax
        pop     esi

    .ret:
        ret

;-----------------------------------------------------------------------------

put_message:
        call    put_message_nodraw

draw_messages:
        ; draw container rectangle/box
        mov     ebx, messages_x_pos shl 16
        add     ebx, [messages_x_size_dd+4]
        mov     ecx, [messages_y_pos_dd]
        mov     cx, messages_y_size
        mcall   13, , , COLOR_BG_NORMAL
        mov     edx, messages
        push    messages_width
        pop     esi
        mov     ecx, COLOR_TXT_NORMAL
        mov     ebx, messages_x_pos*10000h
        mov     bx, word[messages_y_pos_dd+4]

    @@:
        ; display text string in the window
        mcall   4
        add     edx, esi
        add     ebx, 10
        cmp     edx, messages+messages_width*messages_height
        jb      @b
        ret

;-----------------------------------------------------------------------------
;                     Show/hide cursor in command line

; TODO: make it cursor.draw and cursor.hide ???
draw_cursor:
        mov     ecx, [cmdline_y_pos_dd+2]
        add     cx, cmdline_y_size-1
        mov     ebx, [cmdline_pos]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        mov     edx, ebx
        shl     ebx, 16
        or      ebx, edx
        mov     edx, COLOR_TXT_NORMAL
        ; draw line
        mcall   38
        ret

hide_cursor:
        mov     ebx, [cmdline_pos]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        inc     ebx
        mov     ecx, [cmdline_y_pos_dd]
        mov     cx, cmdline_y_size
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box
        mcall   13
        mov     ebx, [cmdline_pos]
        cmp     ebx, [cmdline_len]
        jae     .ret
        ; setting up text color scheme and attributes
        mov     ecx, COLOR_TXT_NORMAL
        lea     edx, [cmdline+ebx]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        mov     bx, word[cmdline_y_pos_dd+4]
        inc     bx
        push    1
        pop     esi
        ; draw text string in the window
        mcall   4

    .ret:
        ret

;-----------------------------------------------------------------------------
;                       Draw program window title

; FIXME: something wrong here
redraw_title:
        ; draw container rectangle/box
        mov     ebx, [data_x_size_dd+4]
        add     ebx, title_x_pos*10000h+data_x_pos-title_x_pos
        mcall   13, , title_y_pos*10000h+title_y_size, COLOR_BG_NORMAL

draw_title:
        mcall   38, (data_x_pos-2)*10000h+title_x_pos-5, (title_y_pos+5)*10001h, COLOR_LINE
        push    NoPrgLoaded_len
        pop     esi
        cmp     [debuggee_pid], 0
        jz      @f
        mov     esi, [prgname_len]

    @@:
        imul    ebx, esi, 6
        add     ebx, title_x_pos+4
        shl     ebx, 16
        mov     bx, data_x_pos-10-5-6*7
        add     bx, word[data_x_size_dd+4]
        cmp     [bSuspended], 0
        jz      @f
        add     ebx, 6

    @@:
        ; draw line with COLOR_LINE (in edx)
        mcall
        mov     ebx, [data_x_size_dd+2]
        add     ebx, (data_x_pos-10+4)*0x10000 + data_x_pos+2
        ; draw line with COLOR_LINE (in edx)
        mcall
        mov     al, 4
        mov     ebx, title_x_pos*10000h+title_y_pos
        ; setting up text color scheme and attributes
        mov     ecx, COLOR_TXT_NORMAL
        mov     edx, NoPrgLoaded_str
        cmp     [debuggee_pid], 0
        jz      @f
        mov     edx, [prgname_ptr]

    @@:
        ; draw text string in the window
        mcall
        cmp     [debuggee_pid], 0
        jz      .nodebuggee
        mov     ebx, [data_x_size_dd]
        add     ebx, (data_x_pos-10-6*7)*10000h + title_y_pos
        mov     edx, aRunning
        push    7
        pop     esi
        cmp     [bSuspended], 0
        jz      @f
        add     ebx, 6*10000h
        mov     edx, aPaused
        dec     esi

    @@:
        ; draw line with COLOR_LINE (in edx) in one case
        ; and draw text string with color COLOR_TXT_NORMAL (in ecx) in another
        mcall
        ret

    .nodebuggee:
        mov     al, 38
        mov     ebx, [data_x_size_dd+2]
        add     ebx, (data_x_pos-10-6*7-5)*0x10000 + data_x_pos+2
        mov     ecx, (title_y_pos+5)*10001h
        mov     edx, COLOR_LINE
        jmp     @b

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; REGISTERS PANEL ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;-----------------------------------------------------------------------------
;                      Display common register content

; TODO: add format support (e.g. numerical value, or address offset/pointer)

; in: esi->value, edx->string, ecx = string length, ebx = coord
draw_register:
        push    esi
        push    edx
        push    ecx
        push    ebp

        mov     ebp, ecx

        mov     eax, [esi]

        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .cd
        cmp     [bSuspended], 0
        jz      .cd

        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        cmp     eax, dword [esi+oldcontext-context]
        je      .cd
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
.cd:
        push    eax                       ;store reg value

        mov     esi, ebp
        ; draw a text string in the window
        mcall   4

        imul    esi, 60000h
        lea     edx, [ebx+esi]
        mov     esi, ecx
        pop     ecx

        ; draw a number in the window
        rol     ecx, 16
        mcall   47, 0x00040100

        shr     ecx, 16
        add     edx, (4*6+3) shl 16
        mcall   47

        pop     ebp
        pop     ecx
        pop     edx
        pop     esi
        add     edx, ecx
        ret

;-----------------------------------------------------------------------------
;                  Display FPU register (ST0 - ST7) content
;
; in: ebp->index, ebx = coord

draw_fpu_register_2:

.str_buf  equ esp
.bcd_man  equ .str_buf+32
.bcd_exp  equ .bcd_man+12
.exp      equ .bcd_exp+12
.tmp      equ .exp+4

        sub     esp, 32+12+12+4+4

        mov     eax, 0x20202020
        mov     edi, .str_buf
        stosd
        stosd
        stosd
        stosd

        ;int3
        ;nop

        mov     edx, ebp
        shl     edx, 4

        movzx   eax, word [_fsw]
        shr     eax, 11
        add     eax, ebp
        and     eax, 7

        bt      dword [_ftw], eax
        jc     .A6M

        mov     dword [.str_buf],' emp'
        mov     word [.str_buf+4],'ty'
        jmp     .display

        mov     cx, [_st0+edx+8]
        and     cx, 0x7FFF              ;clear sign flag
        jz      .A6M

        cmp     cx, 0x7FFF
        jne     .decode

        mov     dword [.str_buf], ' inv'
        mov     dword [.str_buf+4], 'alid'
        jmp     .display

.A6M:

        mov     eax, dword [_st0+edx]
        or      eax, dword [_st0+edx+4]
        jnz     .decode

        mov     dword [.str_buf], ' 0.0'
        jmp     .display

.decode:
        fld     tword [_st0+edx]
        fabs
        fld     st0
        fldlg2
        fld     st1
        fyl2x
        frndint
        fist    dword [.exp]
        fld     st0
        fbstp   tword [.bcd_exp]

        fldl2t
        fmulp
        fld     st0
        frndint
        fxch
        fsub    st,st1

        f2xm1
        fld1
        faddp
        fscale
        fstp    st1
        fdivp

        fist    dword [.tmp]
        cmp     dword [.tmp], 10
        jae     .fixup

        fstp    st1
        jmp     .done

.fixup:
        fstp st0

        inc     dword [.exp]
        fild    dword [.exp]
        fld     st0
        fbstp tword [.bcd_exp]

        fldl2t
        fmulp
        fld st0
        frndint
        fxch
        fsub st,st1

        f2xm1
        fld1
        faddp
        fscale
        fstp st1
        fdivp
.done:
        fimul dword [n_digits]
        fbstp   tword [.bcd_man]

        lea     esi, [.bcd_man-1]
        mov     edi, .str_buf

        mov     ecx, 9
        mov     eax, 0x10000

        mov     al, [esi+ecx+1]
        cmp     al, 0x80            ; check for sign
        jne     .mantis_2_str
        mov     al, '-'
        stosb

.mantis_2_str:

        mov     al, [esi+ecx]
        test    al, al
        jnz     @f

        bt      eax, 16
        jc      .skip_lb
@@:
        mov     ah, al
        shr     al, 4
        jnz     .write_h

        bt      eax, 16
        jc      .skip_hb

.write_h:
        add     al, 0x30
        stosb
        btr     eax, 16
        jnc     .skip_hb
        mov     al, '.'
        stosb

.skip_hb:
        mov     al, ah
        and     al, 0x0F
        jnz     .write_lb

        bt      eax, 16
        jc      .skip_lb

.write_lb:
        add     al,0x30
        stosb
        btr     eax, 16
        jnc     .skip_lb
        mov     al, '.'
        stosb

.skip_lb:
        loop    .mantis_2_str

        mov     eax, [.exp]
        test    eax, eax
        jz      .display

        mov     ax, ' e'
        stosw

        lea     esi, [.bcd_exp-1]
        mov     ecx, 9
        mov     eax,0x10000
        mov     al, [esi+ecx+1]
        cmp     al, 0x80
        jne     .exp_2_str
        mov     al, '-'
        stosb

.exp_2_str:
        mov     al, [esi+ecx]
        test    al, al
        jnz     @f

        bt      eax, 16
        jc      .skip_lb2
@@:
        mov     ah, al
        shr     al, 4
        jnz     .write_h2

        bt      eax, 16
        jc      .skip_hb2

.write_h2:
        add     al, 0x30
        stosb
        btr     eax, 16

.skip_hb2:

        mov     al, ah
        and     al, 0x0F
        jnz     .write_lb2

        bt      eax, 16
        jc      .skip_lb2

.write_lb2:

        add     al, 0x30
        stosb
        btr     eax, 16

.skip_lb2:
        loop    .exp_2_str

.display:

        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .do_label
        cmp     [bSuspended], 0
        jz      .do_label

        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)

        mov     eax, dword [_st0+edx]
        cmp     eax, dword [_st0+(oldcontext-context)+edx]
        jne     .scol

        mov     eax, dword [_st0+edx+4]
        cmp     eax, dword [_st0+(oldcontext-context)+edx+4]
        jne     .scol

        mov     ax, word [_st0+edx+8]
        cmp     ax, word [_st0+(oldcontext-context)+edx+8]
        je      .do_label

.scol:
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)

.do_label:
        ; draw a text string in the window

        mov     eax, 4
        mov     esi, eax
        lea     edx, [fpu_strs+ebp*4]
        mov     edi, COLOR_BG_NORMAL
        int     0x40

        mov     esi, 16
        mov     edx, .str_buf
        add     ebx, 0x180000
        int     0x40

        sub     ebx, 0x180000
        add     esp, 32+12+12+4+4

        ret


;-----------------------------------------------------------------------------
;                      Show FPU MMX register content
;
; in: ebp index, ebx = coord

draw_mmx_register_2:

        shl     ebp, 4

        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .cd
        cmp     [bSuspended], 0
        jz      .cd

        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)

        mov     eax, dword [_mm0+ebp]
        cmp     eax, dword [_mm0+(oldcontext-context)+ebp]
        jne     .scol

        mov     eax, dword [_mm0+ebp+4]
        cmp     eax, dword [_mm0+(oldcontext-context)+ebp+4]
        je     .cd

.scol:
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
.cd:
        mov     eax, ebp
        shl     eax, 16-4
        add     eax, 'MM0='
        push    eax                           ;write label into stack

        ; draw a text string in the window

        mov     eax, 4
        mov     esi, eax
        mov     edx, esp
        mov     edi, COLOR_BG_NORMAL
        int     0x40

        mov     esi, ecx
        mov     [esp], ebx

        mov     ecx, dword [_mm0+ebp+4]
        rol     ecx, 16
        lea     edx, [ebx+0x180000]
        mov     ebx, 0x00040100
        mcall   47                        ;word #3

        shr     ecx, 16
        add     edx, (4*6+3) shl 16
        mcall   47                        ;word #2

        mov     ecx, dword [_mm0+ebp]
        rol     ecx, 16
        add     edx, (4*6+3) shl 16
        mcall   47                        ;word #1

        shr     ecx, 16
        add     edx, (4*6+3) shl 16
        mcall   47                        ;word #0

        pop     ebx

        shr     ebp, 4
        ret

; TODO add SSE registers
; TODO add AVX registers

;-----------------------------------------------------------------------------
;                   Display contents of EFLAGS register
draw_flag:
        movzx   edi, byte [edx+7]
        bt      [_eflags], edi
        jc      .on
        or      byte [edx], 20h
        jmp     .onoff

    .on:
        and     byte [edx], not 20h

    .onoff:
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .doit
        cmp     [bSuspended], 0
        jz      .doit

        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        bt      [_eflags], edi
        lahf
        bt      dword [_eflags + oldcontext - context], edi
        rcl     ah, 1
        test    ah, 3
        jp      .doit
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)

    .doit:
        mov     ah, 0
        mov     edi, COLOR_BG_NORMAL
        ; draw a text string in the window in one case
        ; and a number in another
        ; color scheme same as for previously called function (was in ecx)
        mcall
        ret

;-----------------------------------------------------------------------------
;                      Draw registers frame title

; Also show current register set (common + MMX, SSE or AVX)
draw_reg_title:
        mov     edi, COLOR_BG_NORMAL
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        mov     esi, 7
        cmp     [reg_mode], REG_MODE_CPU
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aMain
        ; draw a text string in the window
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 4*10000h+registers_y_pos+2
        mcall   4

        cmp     [reg_mode], REG_MODE_SSE
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aSSE
        ; draw a text string in the window
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 46*10000h+registers_y_pos+2
        mcall   4

        cmp     [reg_mode], REG_MODE_AVX
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aAVX
        ; draw a text string in the window
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 88*10000h+registers_y_pos+2
        mcall   4
        ret

;-----------------------------------------------------------------------------
;                Display common registers set + MMX + FPU

draw_main_registers:
; TODO: add support for FPU ST0-ST7 registers
        mov     edi, COLOR_BG_NORMAL
        mov     esi, _eax
        push    4
        pop     ecx
        mov     edx, regs_strs
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+22
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+32
        add     esi, _ebx-_eax
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+42
        add     esi, _ecx-_ebx
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+52
        add     esi, _edx-_ecx
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+62
        add     esi, _esi-_edx
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+72
        add     esi, _edi-_esi
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+82
        add     esi, _ebp-_edi
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+92
        add     esi, _esp-_ebp
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+102
        add     esi, _eip-_esp
        call    draw_register
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+112

        mov     cl, 7
        add     esi, _eflags-_eip
        call    draw_register
        mov     cl, 4

    ; MMX registers

        push    ebp

        push    8
        xor     ebp, ebp
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+142

align 4
.draw_mmx_regs:

        call    draw_mmx_register_2
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_mmx_regs

;FPU registers

        ;int3
        ;nop

        mov     [esp], byte 8
        xor     ebp, ebp
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+232

align 4
.draw_fpu_regs:

        call    draw_fpu_register_2
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_fpu_regs
        pop     eax                         ;restore stack
        pop     ebp

        mov     ecx, COLOR_TXT_INACTIVE
        cmp     [debuggee_pid], 0
        jz      @f
        cmp     [bSuspended], 0
        jz      @f
        mov     ecx, COLOR_TXT_NORMAL
    @@:
        mov     edx, aColon
        xor     esi, esi
        inc     esi
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 10*10000h+registers_y_pos+122
        mcall   4
        mov     edx, flags

    @@:
        add     ebx, 2*6*10000h
        call    draw_flag
        inc     edx
        cmp     dl, flags_bits and 0xFF
        jnz     @b
        ret

;-----------------------------------------------------------------------------
;                  Draw SSE registers set

draw_sse_registers:

        ret

;-----------------------------------------------------------------------------
;                  Draw AVX registers set

draw_avx_registers:

        ret

;-----------------------------------------------------------------------------
;                 Draw all registers sets
draw_registers:

        ; draw container rectangle/box with COLOR_BG_NORMAL
        mov     ebx, [registers_x_pos_dd]
        add     ebx, (-1)*10000h+(registers_x_size+2)
        mov     ecx, [registers_y_size_dd+4]
        add     ecx, (registers_y_pos-1)*10000h+2
        mcall   13, , , COLOR_BG_NORMAL
        call    draw_reg_title

    .redraw:
        cmp     [reg_mode], REG_MODE_CPU
        jnz     @f
        call    draw_main_registers
        ret

    @@:
        cmp     [reg_mode], REG_MODE_SSE
        jnz     @f
        call    draw_sse_registers
        ret

    @@:
        call    draw_avx_registers
        ret

;-----------------------------------------------------------------------------
;                     Display memory dump

draw_dump:
        ; draw container rectangle/box in the window
        mov     ebx, [data_x_size_dd+4]
        add     ebx, data_x_pos*10000h
        mcall   13, , dump_y_pos*10000h+dump_y_size, COLOR_BG_NORMAL

    .redraw:
        ; addresses
        mov     ebx, 80100h
        mov     edx, data_x_pos*10000h + dump_y_pos
        mov     ecx, [dumppos]
        mov     edi, COLOR_BG_NORMAL
        mov     esi, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      @f
        cmp     [bSuspended], 0
        jz      @f
        mov     esi, (COLOR_TXT_NORMAL or 0x40000000)
    @@:
        ; draw a number in the window
        mcall   47
        add     ecx, 10h
        add     edx, 10
        cmp     dl, dump_y_pos + dump_y_size
        jb      @b
        ; hex dump of data
        mov     ecx, dumpdata
        push    ecx
        xor     ebx, ebx
        mov     edx, (data_x_pos+12*6)*10000h + dump_y_pos
        cmp     [dumpread], ebx
        jz      .hexdumpdone1

    .hexdumploop1:
        push    ebx
        mov     ebx, 20101h
        ; draw a number in the window
        mcall
        pop     ebx
        add     edx, 3*6*10000h
        inc     ecx
        inc     ebx
        test    bl, 15
        jz      .16
        test    bl, 7
        jnz     @f
        add     edx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h

    .16:
        add     edx, 10 - 6*(3*10h+2)*10000h

    @@:
        cmp     ebx, [dumpread]
        jb      .hexdumploop1

    .hexdumpdone1:
        mov     al, 4
        ; copy color value from esi to ecx
        ; to draw text string with 'mcall 4'
        mov     ecx, esi
        xchg    ebx, edx
        push    2
        pop     esi

    .hexdumploop2:
        cmp     edx, dump_height*10h
        jae     .hexdumpdone2
        push    edx
        mov     edx, aQuests
        ; draw text string with color in ecx, copied from esi
        mcall
        pop     edx
        add     ebx, 3*6*10000h
        inc     edx
        test    dl, 15
        jz      .16x
        test    dl, 7
        jnz     .hexdumploop2
        add     ebx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h

    .16x:
        add     ebx, 10 - 6*(3*10h+2)*10000h
        jmp     .hexdumploop2

    .hexdumpdone2:
        dec     esi
        ; colon, minus signs
        mov     ebx, (data_x_pos+8*6)*10000h + dump_y_pos
        mov     edx, aColon

    @@:
        mcall
        add     ebx, 10
        cmp     bl, dump_y_pos+dump_height*10
        jb      @b
        mov     ebx, (data_x_pos+(12+3*8)*6)*10000h + dump_y_pos
        mov     edx, aMinus

    @@:
        mcall
        add     ebx, 10
        cmp     bl, dump_y_pos+dump_height*10
        jb      @b
        ; ASCII data
        mov     ebx, (data_x_pos+(12+3*10h+2+2)*6)*10000h + dump_y_pos
        pop     edx
        push    dump_height*10h

    .asciiloop:
        push    edx
        cmp     byte [edx], 20h
        jae     @f
        mov     edx, aPoint

    @@:
        ; draw a text string in the window, color in ecx
        mcall
        pop     edx
        inc     edx
        add     ebx, 6*10000h
        dec     dword [esp]
        jz      .asciidone
        test    byte [esp], 15
        jnz     .asciiloop
        add     ebx, 10 - 6*10h*10000h
        jmp     .asciiloop

    .asciidone:
        pop     ecx
        ret

;-----------------------------------------------------------------------------
;                   Display disassembled code

draw_disasm:

        mov     eax, [disasm_start_pos]
        mov     [disasm_cur_pos], eax
        and     [disasm_cur_str], 0

    .loop:
        mov     eax, [disasm_cur_pos]
        call    find_symbol
        jc      .nosymb
        mov     ebx, [disasm_cur_str]
        imul    ebx, 10
        push    ebx
        lea     ecx, [ebx+disasm_y_pos-1]
        shl     ecx, 16
        mov     cl, 11
        ; setting up background color for disassembled text
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box with color COLOR_BG_NORMAL (was 0xFFFFFF - white)
        mov     ebx, [data_x_size_dd+4]
        add     ebx, data_x_pos*10000h
        mcall   13
        pop     ebx
        ; copy color value from edx (COLOR_BG_NORMAL)
        mov     edi, edx
        add     ebx, (data_x_pos+6*2)*10000h+disasm_y_pos
        mov     edx, esi

    @@:
        lodsb
        test    al, al
        jnz     @b
        mov     byte [esi-1], ':'
        sub     esi, edx
        ; normal color
        ; was 0x40000000
        mov     ecx, (COLOR_TXT_LABEL or 0x40000000)
        mov     al, 4
        ; draw a text string in the window with color COLOR_TXT_NORMAL in ecx
        mcall
        mov     byte [esi+edx-1], 0
        lea     esi, [esi*3]
        movzx   ecx, bx
        shr     ebx, 16
        lea     ebx, [ebx+esi*2]
        shl     ecx, 16
        mov     cl, 10
        imul    ebx, 10001h
        sub     bx, data_x_pos
        sub     bx, word[data_x_size_dd+4]
        neg     bx
        mov     al, 13
        ; copy color value from edi
        mov     edx, edi
        ; draw container rectangle/box for disassembled text, color in edx
        mcall
        inc     [disasm_cur_str]
        mov     eax, [disasm_height_dd]
        cmp     [disasm_cur_str], eax
        jae     .loopend

    .nosymb:
        push    [disasm_cur_pos]
        call    disasm_instr
        pop     ebp
        jc      .loopend
        mov     edx, COLOR_BG_NORMAL
        mov     esi, COLOR_TXT_NORMAL
        mov     ebx, data_x_pos*10000h
        add     ebx, [data_x_size_dd+4]
        mov     ecx, [disasm_cur_str]
        imul    ecx, 10*10000h
        add     ecx, (disasm_y_pos-1)*10000h + 10
        mov     eax, ebp
        pushad
        call    find_enabled_breakpoint
        popad
        jnz     .nobp
        mov     edx, COLOR_BG_BREAKPOINT
        mov     esi, COLOR_TXT_BREAKPOINT
    .nobp:

        mov     eax, [_eip]
        cmp     eax, ebp
        jnz     .notcurrent
        mov     edx, COLOR_BG_SELECTED
        mov     esi, COLOR_TXT_SELECTED
    .notcurrent:
        push    esi     ; Save color value for disassembled text

        ; draw container rectangle/box for disassembled text
        ; color in edx
        mcall   13

        mov     edx, [disasm_cur_str]
        imul    edx, 10
        add     edx, data_x_pos*10000h + disasm_y_pos
        ; draw a number in the window, color in esi
        mcall   47, 80100h, ebp

        lea     ebx, [edx+8*6*10000h]
        mov     ecx, esi    ; text color
        push    2
        pop     esi
        mov     edx, aColon
        ; draw the colon
        mcall   4
        push    9
        pop     edi
        lea     edx, [ebx+2*6*10000h]
        mov     ecx, ebp
        sub     ecx, [disasm_start_pos]
        add     ecx, disasm_buffer

        mov     esi, COLOR_TXT_HEX
        mov     eax, [_eip]
        cmp     eax, ebp
        jnz     @f
        mov     esi, COLOR_TXT_SELECTED
  @@:
    .drawhex:
        ; draw a number in the window, color in esi
        mcall   47, 20101h
        add     edx, 6*3*10000h
        inc     ecx
        inc     ebp
        cmp     ebp, [disasm_cur_pos]
        jae     .hexdone
        dec     edi
        jnz     .drawhex
        push    esi
        mov     esi, [disasm_cur_pos]
        dec     esi
        cmp     esi, ebp
        pop     esi
        jbe     .drawhex

        lea     ebx, [edx-6*10000h]
        ; copy color value from esi
        mov     ecx, esi
        push    3
        pop     esi
        mov     edx, aDots
        ; draw a text string in the window, color in ecx
        mcall   4

    .hexdone:
        pop     esi
        xor     eax, eax
        mov     edi, disasm_string
        mov     edx, edi
        or      ecx, -1
        repnz scasb
        not     ecx
        dec     ecx
        xchg    ecx, esi
        mov     ebx, [disasm_cur_str]
        imul    ebx, 10
        add     ebx, (data_x_pos+6*40)*10000h+disasm_y_pos

        ; draw a text string in the window, color in ecx
        mcall   4
        inc     [disasm_cur_str]
        mov     eax, [disasm_height_dd]
        cmp     [disasm_cur_str], eax
        jb      .loop

    .loopend:
        mov     ecx, [disasm_height_dd]
        sub     ecx, [disasm_cur_str]
        jz      @f
        imul    ecx, 10
        inc     ecx
        mov     eax, disasm_y_pos
        add     eax, [disasm_y_size_dd+4]
        sub     eax, ecx
        shl     eax, 16
        add     ecx, eax
        ; Draw filled rectangle
        mov     ebx, [data_x_size_dd+4]
        add     ebx, data_x_pos*10000h
        mcall   13, , , COLOR_BG_NORMAL

    @@:
        ret

;-----------------------------------------------------------------------------

; TODO: cleanup of this function, make some global labels local
update_disasm_eip:
; test if instruction at eip is showed
        mov     ecx, [disasm_height_dd+4]
        mov     eax, [disasm_start_pos]
        mov     [disasm_cur_pos], eax

    .l:
        mov     eax, [disasm_cur_pos]
        call    find_symbol
        jc      @f
        dec     ecx
        jz      .m

    @@:
        cmp     [_eip], eax
        jz      draw_disasm
        push    ecx
        call    disasm_instr
        pop     ecx
        jc      .m
        loop    .l

    .m:

update_disasm_eip_force:
        mov     eax, [_eip]
        mov     [disasm_start_pos], eax

update_disasm:
        cmp     [debuggee_pid], 0
        jz      .no

        mcall   69, 6, [debuggee_pid], 256, [disasm_start_pos], disasm_buffer
        cmp     eax, -1
        jnz     @f
        mov     esi, read_mem_err
        call    put_message

    .no:
        xor     eax, eax

    @@:
        mov     [disasm_buf_size], eax
        call    restore_from_breaks
        jmp     draw_disasm


;-----------------------------------------------------------------------------
;                               Draw main window

draw_window:
        ; start window redraw
        mcall   12, 1

        ; define window
        mcall   0, wnd_x_size, wnd_y_size, (COLOR_BG_NORMAL or 0x33000000), ,caption_str

        ; Get actual window size
        mcall   9, thread_info, -1

        ; Check if window is rolled up
        test    [thread_info.wnd_state], 100b
        jnz     .done

        ; Check if window isnt smaller then permisseable
        mov     eax, [thread_info.box.width]            ; window xsize
        mov     ebx, [thread_info.box.height]           ; ysize
        mov     edx, [thread_info.client_box.width]     ; work area xsize
        mov     esi, [thread_info.client_box.height]    ; ysize
        sub     eax, edx
        sub     ebx, esi

        cmp     edx, wnd_x_size
        jae     .x_ok
        mov     edx, wnd_x_size
  .x_ok:
        add     edx, eax

        cmp     esi, wnd_y_size
        jae     .y_ok
        mov     esi, wnd_y_size
  .y_ok:
        add     esi, ebx
        mcall   67, -1, -1      ; set the new sizes

        ; (re)calculate coordinates of GUI elements
        mov     eax, [thread_info.client_box.width]
        sub     eax, data_x_pos + data_x_pos + registers_x_size+3
        mov     [data_x_size_dd+4], eax
        mov     [messages_x_size_dd+4], eax
        shl     eax, 16
        mov     [data_x_size_dd], eax
        mov     [messages_x_size_dd], eax
        shr     eax, 16
        add     eax, data_x_pos + 4
        mov     [registers_x_pos_dd+4], eax
        shl     eax, 16
        mov     [registers_x_pos_dd], eax

        mov     eax, [thread_info.client_box.height]
        sub     eax, cmdline_y_size + data_x_pos
        mov     [cmdline_y_pos_dd+4], eax
        shl     eax, 16
        mov     [cmdline_y_pos_dd], eax
        shr     eax, 16
        sub     eax, messages_y_size + 4
        mov     [messages_y_pos_dd+4], eax
        shl     eax, 16
        mov     [messages_y_pos_dd], eax
        shr     eax, 16
        sub     eax, disasm_y_pos + 4
        mov     [disasm_y_size_dd+4], eax
        shl     eax, 16
        mov     [disasm_y_size_dd], eax
        shr     eax, 16
        mov     ecx, 10
        xor     edx, edx
        div     ecx
        mov     [disasm_height_dd], eax

        mov     eax, [thread_info.client_box.height]
        sub     eax, data_x_pos + registers_y_pos-1
        mov     [registers_y_size_dd+4], eax
        shl     eax, 16
        mov     [registers_y_size_dd], eax

        ; messages frame
        mov     ebx, [messages_x_size_dd+4]
        add     ebx, (messages_x_pos-2)*10000h + (messages_x_pos+2)
        push    ebx
        mov     ecx, [messages_y_pos_dd+2]
        add     ecx, -2*10001h
        mov     edx, COLOR_LINE
        mcall   38
        add     ecx, (messages_y_size+2+2)*10001h
        mcall
        mov     ebx, (messages_x_pos-2)*10001h
        push    ebx
        mov     ecx, [messages_y_pos_dd+2]
        add     ecx, (-2*10000h) + (messages_y_size+2)
        mcall
        mov     ebx, [messages_x_size_dd+2]
        add     ebx, (messages_x_pos+2)*10001h
        push    ebx
        mcall

        ; command line frame
        mov     ecx, [cmdline_y_pos_dd+2]
        add     ecx, (-2*10000h) + (cmdline_y_size+2)
        pop     ebx
        mcall
        pop     ebx
        mcall
        pop     ebx
        mov     ecx, [cmdline_y_pos_dd+2]
        add     ecx, (cmdline_y_size+2)*10001h

        mcall
        mov     ecx, [cmdline_y_pos_dd+2]
        add     ecx, (-2*10001h)
        mcall

        ; registers frame
        mov     ebx, [registers_x_pos_dd]
        add     ebx, (-2) shl 16 + (registers_x_size+3)
        mov     ecx, (registers_y_pos-2) shl 16 + 1
        mov     edx, COLOR_LINE
        mcall   13                      ; top
        mov     ebx, [registers_x_pos_dd]
        add     ebx, ((-2)+(registers_x_size+3)) shl 16 +1
        mov     ecx, [registers_y_size_dd+4]
        add     ecx, (registers_y_pos-2) shl 16 + (+3+1)
        mcall                           ; right
        mov     ebx, [registers_x_pos_dd]
        add     ebx, (-2) shl 16 + (registers_x_size+3)
        mov     ecx, [registers_y_size_dd]
        add     ecx, ((registers_y_pos-2)+(+3)) shl 16 + 1
        mcall                           ; bottom

        ; messages
        call    draw_messages

        ; command line & cursor
        call    draw_cmdline
        call    draw_cursor

        ; title & registers & dump & disasm
        mov     ebx, (data_x_pos-2)*10001h
        mov     ecx, (title_y_pos+5)*10000h + (-2)
        add     ecx, [messages_y_pos_dd+4]
        mov     edx, COLOR_LINE
        mcall   38
        mov     ebx, [data_x_size_dd+2]
        add     ebx, (data_x_pos+2)*10001h
        mcall
        mov     ebx, [data_x_size_dd+4]
        add     ebx, (data_x_pos-2)*10000h + (data_x_pos+2)
        mov     ecx, (disasm_y_pos-4)*10001h
        mcall

        ; redraw whole window again
        call    redraw_title
        call    draw_registers
        call    draw_dump
        call    draw_disasm


  .done:
        ; end of window redraw
        mcall   12, 2
        ret

; vim: ft=fasm tabstop=4