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
 
struc fpcvt
{
  .str_buf  rb 32
  .cvt_buf  rb 16
  .bcd_man  rb 10
  .bcd_exp  rb 10
  .exp      rd 1
  .digits   rq 1
  .sizeof:
}
 
 
 
;-----------------------------------------------------------------------------
 
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
        mcall   17
        test    al, al
        jnz     waitevent
        movzx   eax, ah
        jmp     dword [.jmp_table+eax*4]
 
.close:
        mcall -1
.mmx:
        movzx   edx, [fpu_mode]
        xor     dl, 1
        mov     [fpu_mode], dl
        push    edx
        jnz     .fpu
        call    draw_mmx_regs
        jmp     .draw_label
.fpu:
        call    draw_fpu_regs
.draw_label:
        pop     edx
        mov     edx, [btn2_tab+edx*4]
        mov     edi, COLOR_BG_NORMAL
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        mov     esi, 7
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 4*10000h+registers_y_pos+2
        mcall   4
        jmp     waitevent
 
align 4
.jmp_table:
        dd waitevent
        dd .close
        dd .mmx
 
 
; 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
 
 
; in: edi=cvt buffer, st0 = value
 
;align 4
;fp2str:
 
 
 
;-----------------------------------------------------------------------------
;                  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
 
        movzx   eax, word [_fsw]
        shr     eax, 11
        add     eax, ebp
        shr     ebp, 12
        and     eax, 7
        bt      dword [_ftw], eax
        jc     .exam
 
        mov     dword [.str_buf+8],' emp'
        mov     word [.str_buf+8+4],'ty'
        jmp     .display
 
.exam:
        fld     tword [_st0+ebp]
        fxam
        fstsw   ax
        fstp    st1
        sahf
 
        jz      .c3
        jp      .c2
 
;C0 leaf
        jc      .nan
 
; C3 = 0 C2 = 0 C0 = 0 - invalid
        mov     dword [.str_buf+6], ' inv'
        mov     dword [.str_buf+6+4], 'alid'
        jmp     .display
 
; C3 = 0 C2 = 0 C0 = 1 - Not a Number
.nan:
        mov     dword [.str_buf+10], ' NaN'
        jmp     .display
 
;C2 leaf - valid or infinity
 
.c2:
; C3 = 0 C2 = 1 C0 = 0 - valid number
 
        jnc     .decode
 
; C3 = 0 C2 = 1 C0 = 1 - Infinty
 
;check sign flag
        test    ah, 0x02
        jnz     @F
        mov     dword [.str_buf+10], '+Inf'
        jmp     .display
@@:
        mov     dword [.str_buf+10], '-Inf'
        jmp     .display
 
.c3:
        jp      .denormal
        jc      .empty
 
; C3 = 1 C2 = 1 C0 = 0 - Zero
 
        mov     dword [.str_buf+10], ' 0.0'
        jmp     .display
 
.empty:
        mov     dword [.str_buf+8],' emp'
        mov     word [.str_buf+8+4],'ty'
        jmp     .display
 
; C3 = 1 C2 = 1 C0 = 0 - Denormal number
 
.denormal:
        test    ah, 0x02
        jnz     @F
 
        mov     dword [.str_buf+6], '+den'
        mov     dword [.str_buf+6+4], 'orm '
        jmp     .display
@@:
        mov     dword [.str_buf+6], '-den'
        mov     dword [.str_buf+6+4], 'orm '
        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, 23
        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:
 
        sub     esp, 24
        lea     edi, [esp+4]
 
        shl     ebp, 4
        mov     eax, ebp
        shl     eax, 16-4
        add     eax, 'MM0:'
        mov     [esp], eax
 
        mov     edx, dword [_mm0+ebp+4]
        call    .hex_2_str
        mov     al, ' '
        stosb
        call    .hex_2_str
        mov     al, ' '
        stosb
 
        mov     edx, dword [_mm0+ebp]
        call    .hex_2_str
        mov     al, ' '
        stosb
        call    .hex_2_str
 
        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:
        ; draw a text string in the window
 
        mov     eax, 4
        mov     esi, 23
        mov     edx, esp
        mov     edi, COLOR_BG_NORMAL
        int     0x40
        shr     ebp, 4
        add     esp, 24
        ret
 
align 4
.hex_2_str:
        mov     ecx, 4
@@:
        xor     eax, eax
        shld    eax, edx, 4
        aaa
        adc     al, 0x30
        aad     16
        shl     edx, 4
        stosb
        loop @B
        ret
 
align 4
draw_fpu_regs:
        push    ebp
        push    8
        xor     ebp, ebp
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+142
.draw_regs:
        call    draw_fpu_register_2
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_regs
        pop     eax                         ;restore stack
        pop     ebp
        ret
 
align 4
draw_mmx_regs:
        push    ebp
        push    8
        xor     ebp, ebp
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+142
.draw_regs:
        call    draw_mmx_register_2
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_regs
        pop     eax
        pop     ebp
        ret
 
align 4
draw_sse_regs:
        push    ebp
        push    8
        xor     ebp, ebp
        mov     ebx, [registers_x_pos_dd]
        add     ebx, 2*10000h+registers_y_pos+232
.draw_regs:
     ;   call    draw_sse_register
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_regs
        pop     eax
        pop     ebp
        ret
 
; 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)
    @@:
        movzx   edx, [fpu_mode]
        mov     edx, [btn2_tab+edx*4]
 
        ; 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
 
        cmp     [fpu_mode], 1
        je      .fpu
        call    draw_mmx_regs
        jmp     @f
.fpu:
        call    draw_fpu_regs
@@:
        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]
        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+10, wnd_y_size+30, (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
 
        mov     ebx, [registers_x_pos_dd]
        add     ebx, (4 shl 16) + 42
        mov     ecx, (registers_y_pos shl 16) + 11
        mov     edx, (1 shl 30)+2
        mov     esi, 0x00808080
        mcall   8
 
 
        ; 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 5206	Rev 5696
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	struc fpcvt	57	struc fpcvt
58	{	58	{
59	.str_buf rb 32	59	.str_buf rb 32
60	.cvt_buf rb 16	60	.cvt_buf rb 16
61	.bcd_man rb 10	61	.bcd_man rb 10
62	.bcd_exp rb 10	62	.bcd_exp rb 10
63	.exp rd 1	63	.exp rd 1
64	.digits rq 1	64	.digits rq 1
65	.sizeof:	65	.sizeof:
66	}	66	}
67		67
68		68
69		69
70	;-----------------------------------------------------------------------------	70	;-----------------------------------------------------------------------------
71		71
72	data_width = 80	72	data_width = 80
73	data_x_pos = 12	73	data_x_pos = 12
74	data_x_size = data_width*6	74	data_x_size = data_width*6
75		75
76	title_x_pos = 30	76	title_x_pos = 30
77	title_y_pos = 8	77	title_y_pos = 8
78	title_y_size = 10	78	title_y_size = 10
79		79
80	dump_y_pos = (title_y_pos + title_y_size)	80	dump_y_pos = (title_y_pos + title_y_size)
81	dump_height = 6	81	dump_height = 6
82	dump_y_size = (dump_height*10)	82	dump_y_size = (dump_height*10)
83		83
84	disasm_y_pos = (dump_y_pos + dump_y_size + 4)	84	disasm_y_pos = (dump_y_pos + dump_y_size + 4)
85	min_disasm_height = 18	85	min_disasm_height = 18
86	min_disasm_y_size = (min_disasm_height*10)	86	min_disasm_y_size = (min_disasm_height*10)
87		87
88	messages_width = data_width	88	messages_width = data_width
89	messages_height = 8	89	messages_height = 8
90	messages_x_pos = data_x_pos	90	messages_x_pos = data_x_pos
91	min_messages_y_pos = (disasm_y_pos + min_disasm_y_size + 4)	91	min_messages_y_pos = (disasm_y_pos + min_disasm_y_size + 4)
92	messages_x_size = messages_width*6	92	messages_x_size = messages_width*6
93	messages_y_size = messages_height*10	93	messages_y_size = messages_height*10
94		94
95	cmdline_width = data_width	95	cmdline_width = data_width
96	cmdline_x_pos = data_x_pos	96	cmdline_x_pos = data_x_pos
97	min_cmdline_y_pos = (min_messages_y_pos + messages_y_size + 4)	97	min_cmdline_y_pos = (min_messages_y_pos + messages_y_size + 4)
98	cmdline_x_size = messages_x_size	98	cmdline_x_size = messages_x_size
99	cmdline_y_size = 10	99	cmdline_y_size = 10
100		100
101	registers_x_pos = (data_x_pos + messages_x_size + 4)	101	registers_x_pos = (data_x_pos + messages_x_size + 4)
102	registers_y_pos = (title_y_pos + title_y_size - 3)	102	registers_y_pos = (title_y_pos + title_y_size - 3)
103	registers_x_size = 134+2*6	103	registers_x_size = 134+2*6
104	registers_y_size = (min_cmdline_y_pos + cmdline_y_size - registers_y_pos+1)	104	registers_y_size = (min_cmdline_y_pos + cmdline_y_size - registers_y_pos+1)
105		105
106	wnd_x_size = (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10	106	wnd_x_size = (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3) + 10
107	wnd_y_size = (min_cmdline_y_pos + cmdline_y_size + data_x_pos)	107	wnd_y_size = (min_cmdline_y_pos + cmdline_y_size + data_x_pos)
108		108
109	;-----------------------------------------------------------------------------	109	;-----------------------------------------------------------------------------
110	; Entry point	110	; Entry point
111		111
112	; TODO: split all gui part in independent function, move entry point into mtdbg.asm	112	; TODO: split all gui part in independent function, move entry point into mtdbg.asm
113		113
114	start:	114	start:
115	; initialize process heap	115	; initialize process heap
116	mcall 68, 11	116	mcall 68, 11
117		117
118	push eax	118	push eax
119	fstcw word [esp]	119	fstcw word [esp]
120	pop eax	120	pop eax
121	and ax, not (3 shl 10)	121	and ax, not (3 shl 10)
122	or ax, 1 shl 10 ; set round-to-minus infinity mode	122	or ax, 1 shl 10 ; set round-to-minus infinity mode
123	push eax	123	push eax
124	fldcw word [esp]	124	fldcw word [esp]
125	pop eax	125	pop eax
126		126
127	mov edi, messages	127	mov edi, messages
128	mov ecx, messages_width*messages_height	128	mov ecx, messages_width*messages_height
129	mov al, ' '	129	mov al, ' '
130	rep stosb	130	rep stosb
131	xor eax, eax	131	xor eax, eax
132	mov [messages_pos], eax	132	mov [messages_pos], eax
133	mov [cmdline_len], eax	133	mov [cmdline_len], eax
134	mov [cmdline_pos], eax	134	mov [cmdline_pos], eax
135	mov edi, needzerostart	135	mov edi, needzerostart
136	mov ecx, (needzeroend-needzerostart+3)/4	136	mov ecx, (needzeroend-needzerostart+3)/4
137	rep stosd	137	rep stosd
138	mov esi, begin_str	138	mov esi, begin_str
139	call put_message_nodraw	139	call put_message_nodraw
140	; set event mask - default events and debugging events	140	; set event mask - default events and debugging events
141	mcall 40, 0x107	141	mcall 40, 0x107
142	; set debug messages buffer	142	; set debug messages buffer
143	mov ecx, dbgbufsize	143	mov ecx, dbgbufsize
144	mov dword [ecx], 256	144	mov dword [ecx], 256
145	xor ebx, ebx	145	xor ebx, ebx
146	mov [ecx+4], ebx	146	mov [ecx+4], ebx
147	mov al, 69	147	mov al, 69
148	mcall	148	mcall
149	mov esi, i_param	149	mov esi, i_param
150	call get_arg.skip_spaces	150	call get_arg.skip_spaces
151	test al, al	151	test al, al
152	jz dodraw	152	jz dodraw
153	push esi	153	push esi
154	call draw_window	154	call draw_window
155	pop esi	155	pop esi
156	call OnLoadInit	156	call OnLoadInit
157	jmp waitevent	157	jmp waitevent
158		158
159	dodraw:	159	dodraw:
160	call draw_window	160	call draw_window
161		161
162	waitevent:	162	waitevent:
163	mcall 10	163	mcall 10
164	cmp al, 9	164	cmp al, 9
165	jz debugmsg	165	jz debugmsg
166	dec eax	166	dec eax
167	jz dodraw	167	jz dodraw
168	dec eax	168	dec eax
169	jz keypressed	169	jz keypressed
170	dec eax	170	dec eax
171	jnz waitevent	171	jnz waitevent
172	;button pressed	172	;button pressed
173	mcall 17	173	mcall 17
174	test al, al	174	test al, al
175	jnz waitevent	175	jnz waitevent
176	movzx eax, ah	176	movzx eax, ah
177	jmp dword [.jmp_table+eax*4]	177	jmp dword [.jmp_table+eax*4]
178		178
179	.close:	179	.close:
180	mcall -1	180	mcall -1
181	.mmx:	181	.mmx:
182	movzx edx, [fpu_mode]	182	movzx edx, [fpu_mode]
183	xor dl, 1	183	xor dl, 1
184	mov [fpu_mode], dl	184	mov [fpu_mode], dl
185	push edx	185	push edx
186	jnz .fpu	186	jnz .fpu
187	call draw_mmx_regs	187	call draw_mmx_regs
188	jmp .draw_label	188	jmp .draw_label
189	.fpu:	189	.fpu:
190	call draw_fpu_regs	190	call draw_fpu_regs
191	.draw_label:	191	.draw_label:
192	pop edx	192	pop edx
193	mov edx, [btn2_tab+edx*4]	193	mov edx, [btn2_tab+edx*4]
194	mov edi, COLOR_BG_NORMAL	194	mov edi, COLOR_BG_NORMAL
195	mov ecx, (COLOR_TXT_NORMAL or 0x40000000)	195	mov ecx, (COLOR_TXT_NORMAL or 0x40000000)
196	mov esi, 7	196	mov esi, 7
197	mov ebx, [registers_x_pos_dd]	197	mov ebx, [registers_x_pos_dd]
198	add ebx, 4*10000h+registers_y_pos+2	198	add ebx, 4*10000h+registers_y_pos+2
199	mcall 4	199	mcall 4
200	jmp waitevent	200	jmp waitevent
201		201
202	align 4	202	align 4
203	.jmp_table:	203	.jmp_table:
204	dd waitevent	204	dd waitevent
205	dd .close	205	dd .close
206	dd .mmx	206	dd .mmx
207		207
208		208
209	; TODO: split in more independent function	209	; TODO: split in more independent function
210	keypressed:	210	keypressed:
211	mov al, 2	211	mov al, 2
212	mcall	212	mcall
213	shr eax, 8	213	shr eax, 8
214	cmp al, 8	214	cmp al, 8
215	jz .backspace	215	jz .backspace
216	cmp al, 0xB0	216	cmp al, 0xB0
217	jz .left	217	jz .left
218	cmp al, 0xB3	218	cmp al, 0xB3
219	jz .right	219	jz .right
220	cmp al, 0x0D	220	cmp al, 0x0D
221	jz .enter	221	jz .enter
222	cmp al, 0xB6	222	cmp al, 0xB6
223	jz .del	223	jz .del
224	cmp al, 0xB4	224	cmp al, 0xB4
225	jz .home	225	jz .home
226	cmp al, 0xB5	226	cmp al, 0xB5
227	jz .end	227	jz .end
228	cmp al, 0xB1	228	cmp al, 0xB1
229	jz .down	229	jz .down
230	cmp al, 0xB2	230	cmp al, 0xB2
231	jz .up	231	jz .up
232	cmp ah, 0x41	232	cmp ah, 0x41
233	jz F7	233	jz F7
234	cmp ah, 0x42	234	cmp ah, 0x42
235	jz F8	235	jz F8
236	cmp [cmdline_len], cmdline_width	236	cmp [cmdline_len], cmdline_width
237	jae waitevent	237	jae waitevent
238	push eax	238	push eax
239	call clear_cmdline_end	239	call clear_cmdline_end
240	pop eax	240	pop eax
241	mov edi, cmdline	241	mov edi, cmdline
242	mov ecx, [cmdline_len]	242	mov ecx, [cmdline_len]
243	add edi, ecx	243	add edi, ecx
244	lea esi, [edi-1]	244	lea esi, [edi-1]
245	sub ecx, [cmdline_pos]	245	sub ecx, [cmdline_pos]
246	std	246	std
247	rep movsb	247	rep movsb
248	cld	248	cld
249	stosb	249	stosb
250	inc [cmdline_len]	250	inc [cmdline_len]
251	call draw_cmdline_end	251	call draw_cmdline_end
252	inc [cmdline_pos]	252	inc [cmdline_pos]
253	call draw_cursor	253	call draw_cursor
254	jmp waitevent	254	jmp waitevent
255		255
256	.backspace:	256	.backspace:
257	cmp [cmdline_pos], 0	257	cmp [cmdline_pos], 0
258	jz waitevent	258	jz waitevent
259	dec [cmdline_pos]	259	dec [cmdline_pos]
260		260
261	.delchar:	261	.delchar:
262	call clear_cmdline_end	262	call clear_cmdline_end
263	mov edi, [cmdline_pos]	263	mov edi, [cmdline_pos]
264	dec [cmdline_len]	264	dec [cmdline_len]
265	mov ecx, [cmdline_len]	265	mov ecx, [cmdline_len]
266	sub ecx, edi	266	sub ecx, edi
267	add edi, cmdline	267	add edi, cmdline
268	lea esi, [edi+1]	268	lea esi, [edi+1]
269	rep movsb	269	rep movsb
270	call draw_cmdline_end	270	call draw_cmdline_end
271	call draw_cursor	271	call draw_cursor
272	jmp waitevent	272	jmp waitevent
273		273
274	.del:	274	.del:
275	mov eax, [cmdline_pos]	275	mov eax, [cmdline_pos]
276	cmp eax, [cmdline_len]	276	cmp eax, [cmdline_len]
277	jae waitevent	277	jae waitevent
278	jmp .delchar	278	jmp .delchar
279		279
280	.left:	280	.left:
281	cmp [cmdline_pos], 0	281	cmp [cmdline_pos], 0
282	jz waitevent	282	jz waitevent
283	call hide_cursor	283	call hide_cursor
284	dec [cmdline_pos]	284	dec [cmdline_pos]
285	call draw_cursor	285	call draw_cursor
286	jmp waitevent	286	jmp waitevent
287		287
288	.right:	288	.right:
289	mov eax, [cmdline_pos]	289	mov eax, [cmdline_pos]
290	cmp eax, [cmdline_len]	290	cmp eax, [cmdline_len]
291	jae waitevent	291	jae waitevent
292	call hide_cursor	292	call hide_cursor
293	inc [cmdline_pos]	293	inc [cmdline_pos]
294	call draw_cursor	294	call draw_cursor
295	jmp waitevent	295	jmp waitevent
296		296
297	.home:	297	.home:
298	call hide_cursor	298	call hide_cursor
299	and [cmdline_pos], 0	299	and [cmdline_pos], 0
300	call draw_cursor	300	call draw_cursor
301	jmp waitevent	301	jmp waitevent
302		302
303	.end:	303	.end:
304	call hide_cursor	304	call hide_cursor
305	mov eax, [cmdline_len]	305	mov eax, [cmdline_len]
306	mov [cmdline_pos], eax	306	mov [cmdline_pos], eax
307	call draw_cursor	307	call draw_cursor
308		308
309	.up:	309	.up:
310	.down:	310	.down:
311	jmp waitevent	311	jmp waitevent
312		312
313	; We also trying to execute previous command, if empty command_line	313	; We also trying to execute previous command, if empty command_line
314	.enter:	314	.enter:
315	mov ecx, [cmdline_len]	315	mov ecx, [cmdline_len]
316	test ecx, ecx	316	test ecx, ecx
317	jnz .exec_cur	317	jnz .exec_cur
318	mov cl, byte [cmdline_prev]	318	mov cl, byte [cmdline_prev]
319	cmp cl, 0	319	cmp cl, 0
320	jz waitevent	320	jz waitevent
321		321
322	.exec_prev:	322	.exec_prev:
323	mov esi, cmdline_prev	323	mov esi, cmdline_prev
324	jmp .exec	324	jmp .exec
325		325
326	.exec_cur:	326	.exec_cur:
327	mov esi, cmdline	327	mov esi, cmdline
328		328
329	.exec:	329	.exec:
330	mov byte [esi+ecx], 0	330	mov byte [esi+ecx], 0
331	and [cmdline_pos], 0	331	and [cmdline_pos], 0
332	push esi	332	push esi
333	call clear_cmdline_end	333	call clear_cmdline_end
334	call draw_cursor	334	call draw_cursor
335	pop esi	335	pop esi
336	and [cmdline_len], 0	336	and [cmdline_len], 0
337	; skip leading spaces	337	; skip leading spaces
338	call get_arg.skip_spaces	338	call get_arg.skip_spaces
339	cmp al, 0	339	cmp al, 0
340	jz waitevent	340	jz waitevent
341	; now esi points to command	341	; now esi points to command
342	push esi	342	push esi
343	mov esi, prompt	343	mov esi, prompt
344	call put_message_nodraw	344	call put_message_nodraw
345	pop esi	345	pop esi
346	push esi	346	push esi
347	call put_message_nodraw	347	call put_message_nodraw
348		348
349	; TODO: add meaningful name	349	; TODO: add meaningful name
350	z1:	350	z1:
351	mov esi, newline	351	mov esi, newline
352	call put_message	352	call put_message
353	pop esi	353	pop esi
354	push esi	354	push esi
355	call get_arg	355	call get_arg
356	mov [curarg], esi	356	mov [curarg], esi
357	pop edi	357	pop edi
358	mov esi, commands	358	mov esi, commands
359	call find_cmd	359	call find_cmd
360	mov eax, aUnknownCommand	360	mov eax, aUnknownCommand
361	jc .x11	361	jc .x11
362		362
363	; check command requirements	363	; check command requirements
364	; flags field:	364	; flags field:
365	; &1: command may be called without parameters	365	; &1: command may be called without parameters
366	; &2: command may be called with parameters	366	; &2: command may be called with parameters
367	; &4: command may be called without loaded program	367	; &4: command may be called without loaded program
368	; &8: command may be called with loaded program	368	; &8: command may be called with loaded program
369	mov eax, [esi+8]	369	mov eax, [esi+8]
370	mov ecx, [curarg]	370	mov ecx, [curarg]
371	cmp byte [ecx], 0	371	cmp byte [ecx], 0
372	jz .noargs	372	jz .noargs
373	test byte [esi+16], 2	373	test byte [esi+16], 2
374	jz .x11	374	jz .x11
375	jmp @f	375	jmp @f
376		376
377	.noargs:	377	.noargs:
378	test byte [esi+16], 1	378	test byte [esi+16], 1
379	jz .x11	379	jz .x11
380		380
381	@@:	381	@@:
382	cmp [debuggee_pid], 0	382	cmp [debuggee_pid], 0
383	jz .nodebuggee	383	jz .nodebuggee
384	mov eax, aAlreadyLoaded	384	mov eax, aAlreadyLoaded
385	test byte [esi+16], 8	385	test byte [esi+16], 8
386	jz .x11	386	jz .x11
387	jmp .x9	387	jmp .x9
388		388
389	.nodebuggee:	389	.nodebuggee:
390	mov eax, need_debuggee	390	mov eax, need_debuggee
391	test byte [esi+16], 4	391	test byte [esi+16], 4
392	jnz .x9	392	jnz .x9
393		393
394	.x11:	394	.x11:
395	xchg esi, eax	395	xchg esi, eax
396	call put_message	396	call put_message
397		397
398	; store cmdline for repeating	398	; store cmdline for repeating
399	.x10:	399	.x10:
400	mov esi, cmdline	400	mov esi, cmdline
401	mov ecx, [cmdline_len]	401	mov ecx, [cmdline_len]
402		402
403	@@:	403	@@:
404	cmp ecx, 0	404	cmp ecx, 0
405	jle .we	405	jle .we
406	mov al, [esi + ecx]	406	mov al, [esi + ecx]
407	mov [cmdline_prev + ecx], al	407	mov [cmdline_prev + ecx], al
408	dec ecx	408	dec ecx
409	jmp @b	409	jmp @b
410		410
411	.we:	411	.we:
412	mov [cmdline_len], 0	412	mov [cmdline_len], 0
413	jmp waitevent	413	jmp waitevent
414		414
415	.x9:	415	.x9:
416	call dword [esi+4]	416	call dword [esi+4]
417	jmp .x10	417	jmp .x10
418		418
419	;-----------------------------------------------------------------------------	419	;-----------------------------------------------------------------------------
420	; Cmdline handling	420	; Cmdline handling
421		421
422	clear_cmdline_end:	422	clear_cmdline_end:
423	mov ebx, [cmdline_pos]	423	mov ebx, [cmdline_pos]
424	mov ecx, [cmdline_len]	424	mov ecx, [cmdline_len]
425	sub ecx, ebx	425	sub ecx, ebx
426	imul ebx, 6	426	imul ebx, 6
427	imul ecx, 6	427	imul ecx, 6
428	inc ecx	428	inc ecx
429	add ebx, cmdline_x_pos	429	add ebx, cmdline_x_pos
430	shl ebx, 16	430	shl ebx, 16
431	or ebx, ecx	431	or ebx, ecx
432	mov ecx, [cmdline_y_pos_dd]	432	mov ecx, [cmdline_y_pos_dd]
433	mov cx, cmdline_y_size	433	mov cx, cmdline_y_size
434	mov edx, COLOR_BG_NORMAL	434	mov edx, COLOR_BG_NORMAL
435	; draw container rectangle/box for cmdline	435	; draw container rectangle/box for cmdline
436	mcall 13	436	mcall 13
437	ret	437	ret
438		438
439	draw_cmdline:	439	draw_cmdline:
440	xor ebx, ebx	440	xor ebx, ebx
441	jmp @f	441	jmp @f
442		442
443	; TODO: make it local	443	; TODO: make it local
444	draw_cmdline_end:	444	draw_cmdline_end:
445	mov ebx, [cmdline_pos]	445	mov ebx, [cmdline_pos]
446		446
447	@@:	447	@@:
448	mov esi, [cmdline_len]	448	mov esi, [cmdline_len]
449	sub esi, ebx	449	sub esi, ebx
450		450
451	mov ecx, COLOR_TXT_NORMAL	451	mov ecx, COLOR_TXT_NORMAL
452	lea edx, [cmdline+ebx]	452	lea edx, [cmdline+ebx]
453	imul ebx, 6	453	imul ebx, 6
454	add ebx, cmdline_x_pos	454	add ebx, cmdline_x_pos
455	shl ebx, 16	455	shl ebx, 16
456	mov bx, word[cmdline_y_pos_dd+4]	456	mov bx, word[cmdline_y_pos_dd+4]
457	inc bx	457	inc bx
458	; draw a text string in the window	458	; draw a text string in the window
459	mcall 4	459	mcall 4
460	ret	460	ret
461		461
462	;-----------------------------------------------------------------------------	462	;-----------------------------------------------------------------------------
463	; Working with messages	463	; Working with messages
464	; in: esi->ASCIIZ message	464	; in: esi->ASCIIZ message
465	put_message_nodraw:	465	put_message_nodraw:
466	mov edx, [messages_pos]	466	mov edx, [messages_pos]
467		467
468	.m:	468	.m:
469	lea edi, [messages+edx]	469	lea edi, [messages+edx]
470		470
471	.l:	471	.l:
472	lodsb	472	lodsb
473	cmp al, 0	473	cmp al, 0
474	jz .done	474	jz .done
475	call test_scroll	475	call test_scroll
476	cmp al, 10	476	cmp al, 10
477	jz .newline	477	jz .newline
478	cmp al, '%'	478	cmp al, '%'
479	jnz @f	479	jnz @f
480	cmp dword [esp], z1	480	cmp dword [esp], z1
481	jnz .format	481	jnz .format
482		482
483	@@:	483	@@:
484	stosb	484	stosb
485	inc edx	485	inc edx
486	jmp .l	486	jmp .l
487		487
488	.newline:	488	.newline:
489	push edx	489	push edx
490	mov ecx, messages_width	490	mov ecx, messages_width
491	xor eax, eax	491	xor eax, eax
492	xchg eax, edx	492	xchg eax, edx
493	div ecx	493	div ecx
494	xchg eax, edx	494	xchg eax, edx
495	pop edx	495	pop edx
496	test eax, eax	496	test eax, eax
497	jz .m	497	jz .m
498	sub edx, eax	498	sub edx, eax
499	add edx, ecx	499	add edx, ecx
500	jmp .m	500	jmp .m

Subversion Repositories Kolibri OS

(root)/programs/develop/mtdbg/gui.inc – Rev 5206 → 5696