WebSVN – Kolibri OS – Diff – /programs/develop/mtdbg/gui.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 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              = 80
data_x_pos              = 12
data_x_size             = data_width*6
 
title_x_pos             = 30
title_y_pos             = 8
title_y_size            = 10
 
 
dump_y_pos              = (title_y_pos + title_y_size)
dump_height             = 6
dump_y_size             = (dump_height*10)
 
disasm_y_pos            = (dump_y_pos + dump_y_size + 4)
min_disasm_height       = 18
min_disasm_y_size       = (min_disasm_height*10)
 
messages_width          = data_width
messages_height         = 8
messages_x_pos          = data_x_pos
min_messages_y_pos      = (disasm_y_pos + min_disasm_y_size + 4)
messages_x_size         = messages_width*6
messages_y_size         = messages_height*10
 
cmdline_width           = data_width
cmdline_x_pos           = data_x_pos
min_cmdline_y_pos       = (min_messages_y_pos + messages_y_size + 4)
cmdline_x_size          = messages_x_size
cmdline_y_size          = 10
 
registers_x_pos         = (data_x_pos + messages_x_size + 4)
registers_y_pos         = (title_y_pos + title_y_size - 3)
registers_x_size        = 134+2*6
registers_y_size        = (min_cmdline_y_pos + cmdline_y_size - registers_y_pos+1)
 
wnd_x_size              = (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10
wnd_y_size              = (min_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 %X
    .format:
        lodsb   ; get 
        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
.cvt_buf  equ .str_buf+32
.bcd_man  equ .cvt_buf+16
.bcd_exp  equ .bcd_man+10
.exp      equ .bcd_exp+10
.tmp      equ .exp+4
.lcl_end  equ .tmp+4
 
        sub     esp, 32+16+10+10+4+4
 
        mov     edi, .str_buf
        shl     ebp, 16
        lea     eax, ['ST0:'+ebp]
        stosd
        mov     eax, 0x20202020
        stosd
        stosd
        stosd
        stosd
        stosd
 
        ;int3
        ;nop
 
        movzx   eax, word [_fsw]
        shr     eax, 11
        add     eax, ebp
        shr     ebp, 12
        and     eax, 7
        bt      dword [_ftw], eax
        jc     .A6M
 
        mov     dword [.str_buf+8],' emp'
        mov     word [.str_buf+8+4],'ty'
        jmp     .display
 
        mov     cx, [_st0+ebp+8]
        and     cx, 0x7FFF              ;clear sign flag
        jz      .A6M
 
        cmp     cx, 0x7FFF
        jne     .decode
 
        mov     dword [.str_buf+6], ' inv'
        mov     dword [.str_buf+6+4], 'alid'
        jmp     .display
 
.A6M:
 
        mov     eax, dword [_st0+ebp]
        or      eax, dword [_st0+ebp+4]
        jnz     .decode
 
        mov     dword [.str_buf+10], ' 0.0'
        jmp     .display
 
.decode:
        fld     tword [_st0+ebp]
        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     edi, [.cvt_buf]
        mov     edx, dword [.bcd_man]
        mov     ecx, 8
@@:
        xor     eax, eax
        shld    eax, edx, 4
        stosb
        shl     edx, 4
        loop    @B
 
        lea     esi, [.cvt_buf+7]
        lea     edi, [.str_buf+13]
        mov     ecx, 7
        mov     ah, 0x30
        std
.skip_z:
        lodsb
        test    al, al
        jnz     .body
        loop    .skip_z
.body:
        add     al, ah
        stosb
        lodsb
        jcxz    .point
        loop    .body
.point:
        dec     edi
        add     al, ah
        mov     ah, '.'
        stosw
 
        bt      word [_st0+ebp+8], 15
        jnc     .m_sign
        mov     al, '-'
        mov     [edi+1], al
 
.m_sign:
        cld
 
        mov     dx, word [.bcd_exp]
        test    dx, dx
        jz      .display
 
        lea     edi, [.str_buf+15]
        mov     ax, 'E '
        cmp     byte [.bcd_exp+9], 0x80
        jne     .w_e_sign
        mov     ax, 'E-'
 
.w_e_sign:
        stosw
 
        mov     ecx, 4
.skip_lz:
        xor     eax, eax
        shld    ax,dx,4
        shl     dx, 4
        test al, al
        jnz     .w_exp
        loop    .skip_lz
.w_exp:
        add al, 0x30
        stosb
        xor     eax, eax
        shld     ax, dx, 4
        shl     dx,4
        loop    .w_exp
 
.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+ebp]
        cmp     eax, dword [_st0+(oldcontext-context)+ebp]
        jne     .scol
 
        mov     eax, dword [_st0+ebp+4]
        cmp     eax, dword [_st0+(oldcontext-context)+ebp+4]
        jne     .scol
 
        mov     ax, word [_st0+ebp+8]
        cmp     ax, word [_st0+(oldcontext-context)+ebp+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, 21
        mov     edx, .str_buf
        mov     edi, COLOR_BG_NORMAL
        int     0x40
 
        shr     ebp, 4
        add     esp, 32+16+10+10+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

Rev 4912	Rev 4913
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	3	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4		4
5	;-----------------------------------------------------------------------------	5	;-----------------------------------------------------------------------------
6	; Color scheme	6	; Color scheme
7		7
8	BLACK_ON_WHITE equ 0	8	BLACK_ON_WHITE equ 0
9	MOVIEOS equ 1	9	MOVIEOS equ 1
10	WHITE_ON_BLACK equ 2	10	WHITE_ON_BLACK equ 2
11		11
12	; format - 0xRRGGBB	12	; format - 0xRRGGBB
13	if COLOR_THEME eq MOVIEOS	13	if COLOR_THEME eq MOVIEOS
14		14
15	COLOR_BG_NORMAL = 0x1d272f	15	COLOR_BG_NORMAL = 0x1d272f
16	COLOR_BG_BREAKPOINT = 0x0000aa	16	COLOR_BG_BREAKPOINT = 0x0000aa
17	COLOR_BG_SELECTED = 0xec9300	17	COLOR_BG_SELECTED = 0xec9300
18	COLOR_LINE = 0x00b9a0	18	COLOR_LINE = 0x00b9a0
19	COLOR_TXT_NORMAL = 0xffffff	19	COLOR_TXT_NORMAL = 0xffffff
20	COLOR_TXT_INACTIVE = 0x8f7948	20	COLOR_TXT_INACTIVE = 0x8f7948
21	COLOR_TXT_CHANGED = 0xec9300	21	COLOR_TXT_CHANGED = 0xec9300
22	COLOR_TXT_LABEL = 0x22b14c	22	COLOR_TXT_LABEL = 0x22b14c
23	COLOR_TXT_SELECTED = 0x1d272f	23	COLOR_TXT_SELECTED = 0x1d272f
24	COLOR_TXT_HEX = 0xec9300	24	COLOR_TXT_HEX = 0xec9300
25	COLOR_TXT_BREAKPOINT = 0xec9300	25	COLOR_TXT_BREAKPOINT = 0xec9300
26		26
27	else if COLOR_THEME eq WHITE_ON_BLACK	27	else if COLOR_THEME eq WHITE_ON_BLACK
28		28
29	COLOR_BG_NORMAL = 0x101010 ; dark grey	29	COLOR_BG_NORMAL = 0x101010 ; dark grey
30	COLOR_BG_BREAKPOINT = 0xFF0000 ; red	30	COLOR_BG_BREAKPOINT = 0xFF0000 ; red
31	COLOR_BG_SELECTED = 0x0000FF ; blue	31	COLOR_BG_SELECTED = 0x0000FF ; blue
32	COLOR_LINE = 0xFFFFFF ; white	32	COLOR_LINE = 0xFFFFFF ; white
33	COLOR_TXT_NORMAL = 0xFFFFFF ; white	33	COLOR_TXT_NORMAL = 0xFFFFFF ; white
34	COLOR_TXT_INACTIVE = 0x808080 ; grey	34	COLOR_TXT_INACTIVE = 0x808080 ; grey
35	COLOR_TXT_CHANGED = 0x00AA00 ; green	35	COLOR_TXT_CHANGED = 0x00AA00 ; green
36	COLOR_TXT_LABEL = COLOR_TXT_NORMAL	36	COLOR_TXT_LABEL = COLOR_TXT_NORMAL
37	COLOR_TXT_SELECTED = 0xFFFFFF ; white	37	COLOR_TXT_SELECTED = 0xFFFFFF ; white
38	COLOR_TXT_HEX = COLOR_TXT_NORMAL	38	COLOR_TXT_HEX = COLOR_TXT_NORMAL
39	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL	39	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL
40		40
41	else ; BLACK ON WHITE	41	else ; BLACK ON WHITE
42		42
43	COLOR_BG_NORMAL = 0xffffff ; white	43	COLOR_BG_NORMAL = 0xffffff ; white
44	COLOR_BG_BREAKPOINT = 0xFF0000 ; red	44	COLOR_BG_BREAKPOINT = 0xFF0000 ; red
45	COLOR_BG_SELECTED = 0x0000FF ; blue	45	COLOR_BG_SELECTED = 0x0000FF ; blue
46	COLOR_LINE = 0x000000 ; black	46	COLOR_LINE = 0x000000 ; black
47	COLOR_TXT_NORMAL = 0x000000 ; black	47	COLOR_TXT_NORMAL = 0x000000 ; black
48	COLOR_TXT_INACTIVE = 0x808080 ; grey	48	COLOR_TXT_INACTIVE = 0x808080 ; grey
49	COLOR_TXT_CHANGED = 0x00AA00 ; green	49	COLOR_TXT_CHANGED = 0x00AA00 ; green
50	COLOR_TXT_LABEL = COLOR_TXT_NORMAL	50	COLOR_TXT_LABEL = COLOR_TXT_NORMAL
51	COLOR_TXT_SELECTED = 0xFFFFFF ; white	51	COLOR_TXT_SELECTED = 0xFFFFFF ; white
52	COLOR_TXT_HEX = COLOR_TXT_NORMAL	52	COLOR_TXT_HEX = COLOR_TXT_NORMAL
53	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL	53	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL
54		54
55	end if	55	end if
56		56
57	;-----------------------------------------------------------------------------	57	;-----------------------------------------------------------------------------
58		58
59	data_width equ 80	59	data_width = 80
60	data_x_pos equ 12	60	data_x_pos = 12
61	data_x_size equ data_width*6	61	data_x_size = data_width*6
62		62
63	title_x_pos equ 30	63	title_x_pos = 30
64	title_y_pos equ 8	64	title_y_pos = 8
65	title_y_size equ 10	65	title_y_size = 10
66		-
67	;dump_y_pos equ (registers_y_pos + registers_y_size + 5)	66
68	dump_y_pos equ (title_y_pos + title_y_size)	67	dump_y_pos = (title_y_pos + title_y_size)
69	dump_height equ 6	68	dump_height = 6
70	dump_y_size equ (dump_height*10)	69	dump_y_size = (dump_height*10)
71		70
72	disasm_y_pos equ (dump_y_pos + dump_y_size + 4)	71	disasm_y_pos = (dump_y_pos + dump_y_size + 4)
73	disasm_height equ 18	72	min_disasm_height = 18
74	disasm_y_size equ (disasm_height*10)	73	min_disasm_y_size = (min_disasm_height*10)
75		74
76	messages_width equ data_width	75	messages_width = data_width
77	messages_height equ 8	76	messages_height = 8
78	messages_x_pos equ data_x_pos	77	messages_x_pos = data_x_pos
79	messages_y_pos equ (disasm_y_pos + disasm_y_size + 4)	78	min_messages_y_pos = (disasm_y_pos + min_disasm_y_size + 4)
80	messages_x_size equ messages_width*6	79	messages_x_size = messages_width*6
81	messages_y_size equ messages_height*10	80	messages_y_size = messages_height*10
82		81
83	cmdline_width equ data_width	82	cmdline_width = data_width
84	cmdline_x_pos equ data_x_pos	83	cmdline_x_pos = data_x_pos
85	cmdline_y_pos equ (messages_y_pos + messages_y_size + 4)	84	min_cmdline_y_pos = (min_messages_y_pos + messages_y_size + 4)
86	cmdline_x_size equ messages_x_size	85	cmdline_x_size = messages_x_size
87	cmdline_y_size equ 10	86	cmdline_y_size = 10
88		87
89	registers_x_pos equ (data_x_pos + messages_x_size + 4)	88	registers_x_pos = (data_x_pos + messages_x_size + 4)
90	registers_y_pos equ (title_y_pos + title_y_size - 3)	89	registers_y_pos = (title_y_pos + title_y_size - 3)
91	registers_x_size equ 134+2*6	90	registers_x_size = 134+2*6
92	registers_y_size equ (cmdline_y_pos + cmdline_y_size - registers_y_pos+1)	91	registers_y_size = (min_cmdline_y_pos + cmdline_y_size - registers_y_pos+1)
93		92
94	wnd_x_size equ (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10	93	wnd_x_size = (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10
95	wnd_y_size equ (cmdline_y_pos + cmdline_y_size + data_x_pos)	94	wnd_y_size = (min_cmdline_y_pos + cmdline_y_size + data_x_pos)
96		95
97	;-----------------------------------------------------------------------------	96	;-----------------------------------------------------------------------------
98	; Entry point	97	; Entry point
99		98
100	; TODO: split all gui part in independent function, move entry point into mtdbg.asm	99	; TODO: split all gui part in independent function, move entry point into mtdbg.asm
101		100
102	start:	101	start:
103	; initialize process heap	102	; initialize process heap
104	mcall 68, 11	103	mcall 68, 11
105		104
106	push eax	105	push eax
107	fstcw word [esp]	106	fstcw word [esp]
108	pop eax	107	pop eax
109	and ax, not (3 shl 10)	108	and ax, not (3 shl 10)
110	or ax, 1 shl 10 ; set round-to-minus infinity mode	109	or ax, 1 shl 10 ; set round-to-minus infinity mode
111	push eax	110	push eax
112	fldcw word [esp]	111	fldcw word [esp]
113	pop eax	112	pop eax
114		113
115	mov edi, messages	114	mov edi, messages
116	mov ecx, messages_width*messages_height	115	mov ecx, messages_width*messages_height
117	mov al, ' '	116	mov al, ' '
118	rep stosb	117	rep stosb
119	xor eax, eax	118	xor eax, eax
120	mov [messages_pos], eax	119	mov [messages_pos], eax
121	mov [cmdline_len], eax	120	mov [cmdline_len], eax
122	mov [cmdline_pos], eax	121	mov [cmdline_pos], eax
123	mov edi, needzerostart	122	mov edi, needzerostart
124	mov ecx, (needzeroend-needzerostart+3)/4	123	mov ecx, (needzeroend-needzerostart+3)/4
125	rep stosd	124	rep stosd
126	mov esi, begin_str	125	mov esi, begin_str
127	call put_message_nodraw	126	call put_message_nodraw
128	; set event mask - default events and debugging events	127	; set event mask - default events and debugging events
129	mcall 40, 0x107	128	mcall 40, 0x107
130	; set debug messages buffer	129	; set debug messages buffer
131	mov ecx, dbgbufsize	130	mov ecx, dbgbufsize
132	mov dword [ecx], 256	131	mov dword [ecx], 256
133	xor ebx, ebx	132	xor ebx, ebx
134	mov [ecx+4], ebx	133	mov [ecx+4], ebx
135	mov al, 69	134	mov al, 69
136	mcall	135	mcall
137	mov esi, i_param	136	mov esi, i_param
138	call get_arg.skip_spaces	137	call get_arg.skip_spaces
139	test al, al	138	test al, al
140	jz dodraw	139	jz dodraw
141	push esi	140	push esi
142	call draw_window	141	call draw_window
143	pop esi	142	pop esi
144	call OnLoadInit	143	call OnLoadInit
145	jmp waitevent	144	jmp waitevent
146		145
147	dodraw:	146	dodraw:
148	call draw_window	147	call draw_window
149		148
150	waitevent:	149	waitevent:
151	mcall 10	150	mcall 10
152	cmp al, 9	151	cmp al, 9
153	jz debugmsg	152	jz debugmsg
154	dec eax	153	dec eax
155	jz dodraw	154	jz dodraw
156	dec eax	155	dec eax
157	jz keypressed	156	jz keypressed
158	dec eax	157	dec eax
159	jnz waitevent	158	jnz waitevent
160	; button pressed - we have only one button (close)	159	; button pressed - we have only one button (close)
161	mcall -1	160	mcall -1
162		161
163	; TODO: split in more independent function	162	; TODO: split in more independent function
164	keypressed:	163	keypressed:
165	mov al, 2	164	mov al, 2
166	mcall	165	mcall
167	shr eax, 8	166	shr eax, 8
168	cmp al, 8	167	cmp al, 8
169	jz .backspace	168	jz .backspace
170	cmp al, 0xB0	169	cmp al, 0xB0
171	jz .left	170	jz .left
172	cmp al, 0xB3	171	cmp al, 0xB3
173	jz .right	172	jz .right
174	cmp al, 0x0D	173	cmp al, 0x0D
175	jz .enter	174	jz .enter
176	cmp al, 0xB6	175	cmp al, 0xB6
177	jz .del	176	jz .del
178	cmp al, 0xB4	177	cmp al, 0xB4
179	jz .home	178	jz .home
180	cmp al, 0xB5	179	cmp al, 0xB5
181	jz .end	180	jz .end
182	cmp al, 0xB1	181	cmp al, 0xB1
183	jz .down	182	jz .down
184	cmp al, 0xB2	183	cmp al, 0xB2
185	jz .up	184	jz .up
186	cmp ah, 0x41	185	cmp ah, 0x41
187	jz F7	186	jz F7
188	cmp ah, 0x42	187	cmp ah, 0x42
189	jz F8	188	jz F8
190	cmp [cmdline_len], cmdline_width	189	cmp [cmdline_len], cmdline_width
191	jae waitevent	190	jae waitevent
192	push eax	191	push eax
193	call clear_cmdline_end	192	call clear_cmdline_end
194	pop eax	193	pop eax
195	mov edi, cmdline	194	mov edi, cmdline
196	mov ecx, [cmdline_len]	195	mov ecx, [cmdline_len]
197	add edi, ecx	196	add edi, ecx
198	lea esi, [edi-1]	197	lea esi, [edi-1]
199	sub ecx, [cmdline_pos]	198	sub ecx, [cmdline_pos]
200	std	199	std
201	rep movsb	200	rep movsb
202	cld	201	cld
203	stosb	202	stosb
204	inc [cmdline_len]	203	inc [cmdline_len]
205	call draw_cmdline_end	204	call draw_cmdline_end
206	inc [cmdline_pos]	205	inc [cmdline_pos]
207	call draw_cursor	206	call draw_cursor
208	jmp waitevent	207	jmp waitevent
209		208
210	.backspace:	209	.backspace:
211	cmp [cmdline_pos], 0	210	cmp [cmdline_pos], 0
212	jz waitevent	211	jz waitevent
213	dec [cmdline_pos]	212	dec [cmdline_pos]
214		213
215	.delchar:	214	.delchar:
216	call clear_cmdline_end	215	call clear_cmdline_end
217	mov edi, [cmdline_pos]	216	mov edi, [cmdline_pos]
218	dec [cmdline_len]	217	dec [cmdline_len]
219	mov ecx, [cmdline_len]	218	mov ecx, [cmdline_len]
220	sub ecx, edi	219	sub ecx, edi
221	add edi, cmdline	220	add edi, cmdline
222	lea esi, [edi+1]	221	lea esi, [edi+1]
223	rep movsb	222	rep movsb
224	call draw_cmdline_end	223	call draw_cmdline_end
225	call draw_cursor	224	call draw_cursor
226	jmp waitevent	225	jmp waitevent
227		226
228	.del:	227	.del:
229	mov eax, [cmdline_pos]	228	mov eax, [cmdline_pos]
230	cmp eax, [cmdline_len]	229	cmp eax, [cmdline_len]
231	jae waitevent	230	jae waitevent
232	jmp .delchar	231	jmp .delchar
233		232
234	.left:	233	.left:
235	cmp [cmdline_pos], 0	234	cmp [cmdline_pos], 0
236	jz waitevent	235	jz waitevent
237	call hide_cursor	236	call hide_cursor
238	dec [cmdline_pos]	237	dec [cmdline_pos]
239	call draw_cursor	238	call draw_cursor
240	jmp waitevent	239	jmp waitevent
241		240
242	.right:	241	.right:
243	mov eax, [cmdline_pos]	242	mov eax, [cmdline_pos]
244	cmp eax, [cmdline_len]	243	cmp eax, [cmdline_len]
245	jae waitevent	244	jae waitevent
246	call hide_cursor	245	call hide_cursor
247	inc [cmdline_pos]	246	inc [cmdline_pos]
248	call draw_cursor	247	call draw_cursor
249	jmp waitevent	248	jmp waitevent
250		249
251	.home:	250	.home:
252	call hide_cursor	251	call hide_cursor
253	and [cmdline_pos], 0	252	and [cmdline_pos], 0
254	call draw_cursor	253	call draw_cursor
255	jmp waitevent	254	jmp waitevent
256		255
257	.end:	256	.end:
258	call hide_cursor	257	call hide_cursor
259	mov eax, [cmdline_len]	258	mov eax, [cmdline_len]
260	mov [cmdline_pos], eax	259	mov [cmdline_pos], eax
261	call draw_cursor	260	call draw_cursor
262		261
263	.up:	262	.up:
264	.down:	263	.down:
265	jmp waitevent	264	jmp waitevent
266		265
267	; We also trying to execute previous command, if empty command_line	266	; We also trying to execute previous command, if empty command_line
268	.enter:	267	.enter:
269	mov ecx, [cmdline_len]	268	mov ecx, [cmdline_len]
270	test ecx, ecx	269	test ecx, ecx
271	jnz .exec_cur	270	jnz .exec_cur
272	mov cl, byte [cmdline_prev]	271	mov cl, byte [cmdline_prev]
273	cmp cl, 0	272	cmp cl, 0
274	jz waitevent	273	jz waitevent
275		274
276	.exec_prev:	275	.exec_prev:
277	mov esi, cmdline_prev	276	mov esi, cmdline_prev
278	jmp .exec	277	jmp .exec
279		278
280	.exec_cur:	279	.exec_cur:
281	mov esi, cmdline	280	mov esi, cmdline
282		281
283	.exec:	282	.exec:
284	mov byte [esi+ecx], 0	283	mov byte [esi+ecx], 0
285	and [cmdline_pos], 0	284	and [cmdline_pos], 0
286	push esi	285	push esi
287	call clear_cmdline_end	286	call clear_cmdline_end
288	call draw_cursor	287	call draw_cursor
289	pop esi	288	pop esi
290	and [cmdline_len], 0	289	and [cmdline_len], 0
291	; skip leading spaces	290	; skip leading spaces
292	call get_arg.skip_spaces	291	call get_arg.skip_spaces
293	cmp al, 0	292	cmp al, 0
294	jz waitevent	293	jz waitevent
295	; now esi points to command	294	; now esi points to command
296	push esi	295	push esi
297	mov esi, prompt	296	mov esi, prompt
298	call put_message_nodraw	297	call put_message_nodraw
299	pop esi	298	pop esi
300	push esi	299	push esi
301	call put_message_nodraw	300	call put_message_nodraw
302		301
303	; TODO: add meaningful name	302	; TODO: add meaningful name
304	z1:	303	z1:
305	mov esi, newline	304	mov esi, newline
306	call put_message	305	call put_message
307	pop esi	306	pop esi
308	push esi	307	push esi
309	call get_arg	308	call get_arg
310	mov [curarg], esi	309	mov [curarg], esi
311	pop edi	310	pop edi
312	mov esi, commands	311	mov esi, commands
313	call find_cmd	312	call find_cmd
314	mov eax, aUnknownCommand	313	mov eax, aUnknownCommand
315	jc .x11	314	jc .x11
316		315
317	; check command requirements	316	; check command requirements
318	; flags field:	317	; flags field:
319	; &1: command may be called without parameters	318	; &1: command may be called without parameters
320	; &2: command may be called with parameters	319	; &2: command may be called with parameters
321	; &4: command may be called without loaded program	320	; &4: command may be called without loaded program
322	; &8: command may be called with loaded program	321	; &8: command may be called with loaded program
323	mov eax, [esi+8]	322	mov eax, [esi+8]
324	mov ecx, [curarg]	323	mov ecx, [curarg]
325	cmp byte [ecx], 0	324	cmp byte [ecx], 0
326	jz .noargs	325	jz .noargs
327	test byte [esi+16], 2	326	test byte [esi+16], 2
328	jz .x11	327	jz .x11
329	jmp @f	328	jmp @f
330		329
331	.noargs:	330	.noargs:
332	test byte [esi+16], 1	331	test byte [esi+16], 1
333	jz .x11	332	jz .x11
334		333
335	@@:	334	@@:
336	cmp [debuggee_pid], 0	335	cmp [debuggee_pid], 0
337	jz .nodebuggee	336	jz .nodebuggee
338	mov eax, aAlreadyLoaded	337	mov eax, aAlreadyLoaded
339	test byte [esi+16], 8	338	test byte [esi+16], 8
340	jz .x11	339	jz .x11
341	jmp .x9	340	jmp .x9
342		341
343	.nodebuggee:	342	.nodebuggee:
344	mov eax, need_debuggee	343	mov eax, need_debuggee
345	test byte [esi+16], 4	344	test byte [esi+16], 4
346	jnz .x9	345	jnz .x9
347		346
348	.x11:	347	.x11:
349	xchg esi, eax	348	xchg esi, eax
350	call put_message	349	call put_message
351		350
352	; store cmdline for repeating	351	; store cmdline for repeating
353	.x10:	352	.x10:
354	mov esi, cmdline	353	mov esi, cmdline
355	mov ecx, [cmdline_len]	354	mov ecx, [cmdline_len]
356		355
357	@@:	356	@@:
358	cmp ecx, 0	357	cmp ecx, 0
359	jle .we	358	jle .we
360	mov al, [esi + ecx]	359	mov al, [esi + ecx]
361	mov [cmdline_prev + ecx], al	360	mov [cmdline_prev + ecx], al
362	dec ecx	361	dec ecx
363	jmp @b	362	jmp @b
364		363
365	.we:	364	.we:
366	mov [cmdline_len], 0	365	mov [cmdline_len], 0
367	jmp waitevent	366	jmp waitevent
368		367
369	.x9:	368	.x9:
370	call dword [esi+4]	369	call dword [esi+4]
371	jmp .x10	370	jmp .x10
372		371
373	;-----------------------------------------------------------------------------	372	;-----------------------------------------------------------------------------
374	; Cmdline handling	373	; Cmdline handling
375		374
376	clear_cmdline_end:	375	clear_cmdline_end:
377	mov ebx, [cmdline_pos]	376	mov ebx, [cmdline_pos]
378	mov ecx, [cmdline_len]	377	mov ecx, [cmdline_len]
379	sub ecx, ebx	378	sub ecx, ebx
380	imul ebx, 6	379	imul ebx, 6
381	imul ecx, 6	380	imul ecx, 6
382	inc ecx	381	inc ecx
383	add ebx, cmdline_x_pos	382	add ebx, cmdline_x_pos
384	shl ebx, 16	383	shl ebx, 16
385	or ebx, ecx	384	or ebx, ecx
386	mov ecx, [cmdline_y_pos_dd]	385	mov ecx, [cmdline_y_pos_dd]
387	mov cx, cmdline_y_size	386	mov cx, cmdline_y_size
388	mov edx, COLOR_BG_NORMAL	387	mov edx, COLOR_BG_NORMAL
389	; draw container rectangle/box for cmdline	388	; draw container rectangle/box for cmdline
390	mcall 13	389	mcall 13
391	ret	390	ret
392		391
393	draw_cmdline:	392	draw_cmdline:
394	xor ebx, ebx	393	xor ebx, ebx
395	jmp @f	394	jmp @f
396		395
397	; TODO: make it local	396	; TODO: make it local
398	draw_cmdline_end:	397	draw_cmdline_end:
399	mov ebx, [cmdline_pos]	398	mov ebx, [cmdline_pos]
400		399
401	@@:	400	@@:
402	mov esi, [cmdline_len]	401	mov esi, [cmdline_len]
403	sub esi, ebx	402	sub esi, ebx
404		403
405	mov ecx, COLOR_TXT_NORMAL	404	mov ecx, COLOR_TXT_NORMAL
406	lea edx, [cmdline+ebx]	405	lea edx, [cmdline+ebx]
407	imul ebx, 6	406	imul ebx, 6
408	add ebx, cmdline_x_pos	407	add ebx, cmdline_x_pos
409	shl ebx, 16	408	shl ebx, 16
410	mov bx, word[cmdline_y_pos_dd+4]	409	mov bx, word[cmdline_y_pos_dd+4]
411	inc bx	410	inc bx
412	; draw a text string in the window	411	; draw a text string in the window
413	mcall 4	412	mcall 4
414	ret	413	ret
415		414
416	;-----------------------------------------------------------------------------	415	;-----------------------------------------------------------------------------
417	; Working with messages	416	; Working with messages
418	; in: esi->ASCIIZ message	417	; in: esi->ASCIIZ message
419	put_message_nodraw:	418	put_message_nodraw:
420	mov edx, [messages_pos]	419	mov edx, [messages_pos]
421		420
422	.m:	421	.m:
423	lea edi, [messages+edx]	422	lea edi, [messages+edx]
424		423
425	.l:	424	.l:
426	lodsb	425	lodsb
427	cmp al, 0	426	cmp al, 0
428	jz .done	427	jz .done
429	call test_scroll	428	call test_scroll
430	cmp al, 10	429	cmp al, 10
431	jz .newline	430	jz .newline
432	cmp al, '%'	431	cmp al, '%'
433	jnz @f	432	jnz @f
434	cmp dword [esp], z1	433	cmp dword [esp], z1
435	jnz .format	434	jnz .format
436		435
437	@@:	436	@@:
438	stosb	437	stosb
439	inc edx	438	inc edx
440	jmp .l	439	jmp .l
441		440
442	.newline:	441	.newline:
443	push edx	442	push edx
444	mov ecx, messages_width	443	mov ecx, messages_width
445	xor eax, eax	444	xor eax, eax
446	xchg eax, edx	445	xchg eax, edx
447	div ecx	446	div ecx
448	xchg eax, edx	447	xchg eax, edx
449	pop edx	448	pop edx
450	test eax, eax	449	test eax, eax
451	jz .m	450	jz .m
452	sub edx, eax	451	sub edx, eax
453	add edx, ecx	452	add edx, ecx
454	jmp .m	453	jmp .m
455		454
456	.done:	455	.done:
457	mov [messages_pos], edx	456	mov [messages_pos], edx
458	ret	457	ret
459		458
460	; at this moment all format specs must be %X	459	; at this moment all format specs must be %X
461	.format:	460	.format:
462	lodsb ; get	461	lodsb ; get
463	sub al, '0'	462	sub al, '0'
464	movzx ecx, al	463	movzx ecx, al
465	lodsb	464	lodsb
466	pop eax	465	pop eax
467	pop ebp	466	pop ebp
468	push eax	467	push eax
469	; write number in ebp with ecx digits	468	; write number in ebp with ecx digits
470	dec ecx	469	dec ecx
471	shl ecx, 2	470	shl ecx, 2
472		471
473	.writenibble:	472	.writenibble:
474	push ecx	473	push ecx
475	call test_scroll	474	call test_scroll
476	pop ecx	475	pop ecx
477	mov eax, ebp	476	mov eax, ebp
478	shr eax, cl	477	shr eax, cl
479	and al, 0xF	478	and al, 0xF
480	cmp al, 10	479	cmp al, 10
481	sbb al, 69h	480	sbb al, 69h
482	das	481	das
483	stosb	482	stosb
484	inc edx	483	inc edx
485	sub ecx, 4	484	sub ecx, 4
486	jns .writenibble	485	jns .writenibble
487	jmp .l	486	jmp .l
488		487
489	test_scroll:	488	test_scroll:
490	cmp edx, messages_width*messages_height	489	cmp edx, messages_width*messages_height
491	jnz .ret	490	jnz .ret
492	push esi	491	push esi
493	mov edi, messages	492	mov edi, messages
494	lea esi, [edi+messages_width]	493	lea esi, [edi+messages_width]
495	mov ecx, (messages_height-1)*messages_width/4	494	mov ecx, (messages_height-1)*messages_width/4
496	rep movsd	495	rep movsd
497	push eax	496	push eax
498	mov al, ' '	497	mov al, ' '
499	push edi	498	push edi
500	push messages_width	499	push messages_width

Subversion Repositories Kolibri OS

(root)/programs/develop/mtdbg/gui.inc @ 4912 – Rev 4912 → 4913