WebSVN – Kolibri OS – Diff – /kernel/trunk/gui/window.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1526 $
 
;==============================================================================
;///// public functions ///////////////////////////////////////////////////////
;==============================================================================
 
window.BORDER_SIZE = 5
 
macro FuncTable name, table_name, [label]
{
  common
    align 4
    \label name#.#table_name dword
  forward
    dd name#.#label
  common
    name#.sizeof.#table_name = $ - name#.#table_name
}
 
uglobal
  common_colours rd 32
  draw_limits    RECT
endg
 
align 4
;------------------------------------------------------------------------------
syscall_draw_window: ;///// system function 0 /////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        mov     eax, edx
        shr     eax, 24
        and     al, 0x0f
        cmp     al, 5
        jae     .exit
 
        push    eax
        inc     [mouse_pause]
        call    [_display.disable_mouse]
        call    window._.sys_set_window
        call    [_display.disable_mouse]
        pop     eax
 
        or      al, al
        jnz     @f
 
        ; type I - original style
        call    drawwindow_I
        jmp     window._.draw_window_caption.2
 
    @@: dec     al
        jnz     @f
 
        ; type II - only reserve area, no draw
        call    sys_window_mouse
        dec     [mouse_pause]
        call    [draw_pointer]
        jmp     .exit
 
    @@: dec     al
        jnz     @f
 
        ; type III  - new style
        call    drawwindow_III
        jmp     window._.draw_window_caption.2
 
        ; type IV & V - skinned window (resizable & not)
    @@: mov     eax, [TASK_COUNT]
        movzx   eax, word[WIN_POS + eax * 2]
        cmp     eax, [CURRENT_TASK]
        setz    al
        movzx   eax, al
        push    eax
        call    drawwindow_IV
        jmp     window._.draw_window_caption.2
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
syscall_display_settings: ;///// system function 48 ///////////////////////////
;------------------------------------------------------------------------------
;; Redraw screen:
;< ebx = 0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set button style:
;< ebx = 1
;< ecx = 0 (flat) or 1 (with gradient)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set system color palette:
;< ebx = 2
;< ecx = pointer to color table
;< edx = size of color table
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get system color palette:
;< ebx = 3
;< ecx = pointer to color table buffer
;< edx = size of color table buffer
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get skinned caption height:
;< ebx = 4
;> eax = height in pixels
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get screen working area:
;< ebx = 5
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set screen working area:
;< ebx = 6
;< ecx = pack[16(left), 16(right)]
;< edx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get skin margins:
;< ebx = 7
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set skin:
;< ebx = 8
;< ecx = pointer to FileInfoBlock struct
;> eax = FS error code
;------------------------------------------------------------------------------
        cmp     ebx, .sizeof.ftable / 4
        ja      @f
        jmp     [.ftable + ebx * 4]
    @@: ret
 
 
align 4
syscall_display_settings.00:
        xor     eax, eax
        inc     ebx
        cmp     [windowtypechanged], ebx
        jne     .exit
        mov     [windowtypechanged], eax
 
        jmp     syscall_display_settings._.redraw_whole_screen
 
  .exit:
        ret
 
align 4
syscall_display_settings.01:
        and     ecx, 1
        cmp     ecx, [buttontype]
        je      .exit
        mov     [buttontype], ecx
        mov     [windowtypechanged], ebx
 
  .exit:
        ret
 
align 4
syscall_display_settings.02:
        dec     ebx
        mov     esi, ecx
        and     edx, 127
        mov     edi, common_colours
        mov     ecx, edx
        rep     movsb
        mov     [windowtypechanged], ebx
        ret
 
align 4
syscall_display_settings.03:
        mov     edi, ecx
        and     edx, 127
        mov     esi, common_colours
        mov     ecx, edx
        rep     movsb
        ret
 
align 4
syscall_display_settings.04:
        mov     eax, [_skinh]
        mov     [esp + 32], eax
        ret
 
align 4
syscall_display_settings.05:
        mov     eax, [screen_workarea.left - 2]
        mov     ax, word[screen_workarea.right]
        mov     [esp + 32], eax
        mov     eax, [screen_workarea.top - 2]
        mov     ax, word[screen_workarea.bottom]
        mov     [esp + 20], eax
        ret
 
align 4
syscall_display_settings.06:
        xor     esi, esi
 
        mov     edi, [Screen_Max_X]
        mov     eax, ecx
        movsx   ebx, ax
        sar     eax, 16
        cmp     eax, ebx
        jge     .check_horizontal
        inc     esi
        or      eax, eax
        jge     @f
        xor     eax, eax
    @@: mov     [screen_workarea.left], eax
        cmp     ebx, edi
        jle     @f
        mov     ebx, edi
    @@: mov     [screen_workarea.right], ebx
 
  .check_horizontal:
        mov     edi, [Screen_Max_Y]
        mov     eax, edx
        movsx   ebx, ax
        sar     eax, 16
        cmp     eax, ebx
        jge     .check_if_redraw_needed
        inc     esi
        or      eax, eax
        jge     @f
        xor     eax, eax
    @@: mov     [screen_workarea.top], eax
        cmp     ebx, edi
        jle     @f
        mov     ebx, edi
    @@: mov     [screen_workarea.bottom], ebx
 
  .check_if_redraw_needed:
        or      esi, esi
        jz      .exit
 
        call    repos_windows
        jmp     syscall_display_settings._.calculate_whole_screen
 
  .exit:
        ret
 
align 4
syscall_display_settings.07:
        mov     eax, [_skinmargins + 0]
        mov     [esp + 32], eax
        mov     eax, [_skinmargins + 4]
        mov     [esp + 20], eax
        ret
 
align 4
syscall_display_settings.08:
        mov     ebx, ecx
        call    read_skin_file
        mov     [esp + 32], eax
        test    eax, eax
        jnz     .exit
 
        call    syscall_display_settings._.calculate_whole_screen
        jmp     syscall_display_settings._.redraw_whole_screen
 
  .exit:
        ret
 
syscall_display_settings._.calculate_whole_screen:
        xor     eax, eax
        xor     ebx, ebx
        mov     ecx, [Screen_Max_X]
        mov     edx, [Screen_Max_Y]
        jmp     calculatescreen
 
syscall_display_settings._.redraw_whole_screen:
        xor     eax, eax
        mov     [draw_limits.left], eax
        mov     [draw_limits.top], eax
        mov     eax, [Screen_Max_X]
        mov     [draw_limits.right], eax
        mov     eax, [Screen_Max_Y]
        mov     [draw_limits.bottom], eax
        mov     eax, window_data
        jmp     redrawscreen
 
align 4
;------------------------------------------------------------------------------
syscall_set_window_shape: ;///// system function 50 ///////////////////////////
;------------------------------------------------------------------------------
;; Set window shape address:
;> ebx = 0
;> ecx = shape data address
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set window shape scale:
;> ebx = 1
;> ecx = scale power (resulting scale is 2^ebx)
;------------------------------------------------------------------------------
        mov     edi, [current_slot]
 
        test    ebx, ebx
        jne     .shape_scale
        mov     [edi + APPDATA.wnd_shape], ecx
 
  .shape_scale:
        dec     ebx
        jnz     .exit
        mov     [edi + APPDATA.wnd_shape_scale], ecx
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
syscall_move_window: ;///// system function 67 ////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        mov     edi, [CURRENT_TASK]
        shl     edi, 5
        add     edi, window_data
 
        test    [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
        jnz     .exit
 
        cmp     ebx, -1
        jne     @f
        mov     ebx, [edi + WDATA.box.left]
    @@: cmp     ecx, -1
        jne     @f
        mov     ecx, [edi + WDATA.box.top]
    @@: cmp     edx, -1
        jne     @f
        mov     edx, [edi + WDATA.box.width]
    @@: cmp     esi, -1
        jne     @f
        mov     esi, [edi + WDATA.box.height]
 
    @@: push    esi edx ecx ebx
        mov     eax, esp
        mov     bl, [edi + WDATA.fl_wstate]
        call    window._.set_window_box
        add     esp, BOX.sizeof
 
        ; NOTE: do we really need this? to be reworked
;       mov     byte[DONT_DRAW_MOUSE], 0 ; mouse pointer
;       mov     byte[MOUSE_BACKGROUND], 0 ; no mouse under
;       mov     byte[MOUSE_DOWN], 0 ; react to mouse up/down
 
        ; NOTE: do we really need this? to be reworked
;       call    [draw_pointer]
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
syscall_window_settings: ;///// system function 71 /////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        dec     ebx     ; subfunction #1 - set window caption
        jnz     .exit_fail
 
        ; NOTE: only window owner thread can set its caption,
        ;       so there's no parameter for PID/TID
 
        mov     edi, [CURRENT_TASK]
        shl     edi, 5
 
        mov     [edi * 8 + SLOT_BASE + APPDATA.wnd_caption], ecx
        or      [edi + window_data + WDATA.fl_wstyle], WSTYLE_HASCAPTION
 
        call    window._.draw_window_caption
 
        xor     eax, eax ; eax = 0 (success)
        ret
 
;  .get_window_caption:
;        dec     eax     ; subfunction #2 - get window caption
;        jnz     .exit_fail
 
        ; not implemented yet
 
  .exit_fail:
        xor     eax, eax
        inc     eax     ; eax = 1 (fail)
        ret
 
align 4
;------------------------------------------------------------------------------
set_window_defaults: ;/////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        push    eax ecx
        xor     eax, eax
        mov     ecx, WIN_STACK
    @@: inc     eax
        add     ecx, 2
        ; process no
        mov     [ecx + 0x000], ax
        ; positions in stack
        mov     [ecx + 0x400], ax
        cmp     ecx, WIN_POS - 2
        jne     @b
        pop     ecx eax
        ret
 
align 4
;------------------------------------------------------------------------------
calculatescreen: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Scan all windows from bottom to top, calling `setscreen` for each one
;? intersecting given screen area
;------------------------------------------------------------------------------
;> eax = left
;> ebx = top
;> ecx = right
;> edx = bottom
;------------------------------------------------------------------------------
        push    esi
        pushfd
        cli
 
        mov     esi, 1
        call    window._.set_screen
 
        push    ebp
 
        mov     ebp, [TASK_COUNT]
        cmp     ebp, 1
        jbe     .exit
 
        push    edx ecx ebx eax
 
  .next_window:
        movzx   edi, word[WIN_POS + esi * 2]
        shl     edi, 5
 
        cmp     [CURRENT_TASK + edi + TASKDATA.state], TSTATE_FREE
        je      .skip_window
 
        add     edi, window_data
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .skip_window
 
        mov     eax, [edi + WDATA.box.left]
        cmp     eax, [esp + RECT.right]
        jg      .skip_window
        mov     ebx, [edi + WDATA.box.top]
        cmp     ebx, [esp + RECT.bottom]
        jg      .skip_window
        mov     ecx, [edi + WDATA.box.width]
        add     ecx, eax
        cmp     ecx, [esp + RECT.left]
        jl      .skip_window
        mov     edx, [edi + WDATA.box.height]
        add     edx, ebx
        cmp     edx, [esp + RECT.top]
        jl      .skip_window
 
        cmp     eax, [esp + RECT.left]
        jae     @f
        mov     eax, [esp + RECT.left]
    @@: cmp     ebx, [esp + RECT.top]
        jae     @f
        mov     ebx, [esp + RECT.top]
    @@: cmp     ecx, [esp + RECT.right]
        jbe     @f
        mov     ecx, [esp + RECT.right]
    @@: cmp     edx, [esp + RECT.bottom]
        jbe     @f
        mov     edx, [esp + RECT.bottom]
 
    @@: push    esi
        movzx   esi, word[WIN_POS + esi * 2]
        call    window._.set_screen
        pop     esi
 
  .skip_window:
        inc     esi
        dec     ebp
        jnz     .next_window
 
        pop     eax ebx ecx edx
 
  .exit:
        pop     ebp
        popfd
        pop     esi
        ret
 
align 4
;------------------------------------------------------------------------------
repos_windows: ;///////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        mov     ecx, [TASK_COUNT]
        mov     edi, window_data + WDATA.sizeof * 2
        call    force_redraw_background
        dec     ecx
        jle     .exit
 
  .next_window:
        mov     [edi + WDATA.fl_redraw], 1
        test    [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
        jnz     .fix_maximized
 
        mov     eax, [edi + WDATA.box.left]
        add     eax, [edi + WDATA.box.width]
        mov     ebx, [Screen_Max_X]
        cmp     eax, ebx
        jle     .fix_vertical
        mov     eax, [edi + WDATA.box.width]
        sub     eax, ebx
        jle     @f
        mov     [edi + WDATA.box.width], ebx
    @@: sub     ebx, [edi + WDATA.box.width]
        mov     [edi + WDATA.box.left], ebx
 
  .fix_vertical:
        mov     eax, [edi + WDATA.box.top]
        add     eax, [edi + WDATA.box.height]
        mov     ebx, [Screen_Max_Y]
        cmp     eax, ebx
        jle     .fix_client_box
        mov     eax, [edi + WDATA.box.height]
        sub     eax, ebx
        jle     @f
        mov     [edi + WDATA.box.height], ebx
    @@: sub     ebx, [edi + WDATA.box.height]
        mov     [edi + WDATA.box.top], ebx
        jmp     .fix_client_box
 
  .fix_maximized:
        mov     eax, [screen_workarea.left]
        mov     [edi + WDATA.box.left], eax
        sub     eax, [screen_workarea.right]
        neg     eax
        mov     [edi + WDATA.box.width], eax
        mov     eax, [screen_workarea.top]
        mov     [edi + WDATA.box.top], eax
        test    [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP
        jnz     .fix_client_box
        sub     eax, [screen_workarea.bottom]
        neg     eax
        mov     [edi + WDATA.box.height], eax
 
  .fix_client_box:
        call    window._.set_window_clientbox
 
        add     edi, WDATA.sizeof
        loop    .next_window
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_mouse: ;////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        ; NOTE: commented out since doesn't provide necessary functionality
        ;       anyway, to be reworked
;       push    eax
;
;       mov     eax, [timer_ticks]
;       cmp     [new_window_starting], eax
;       jb      .exit
;
;       mov     byte[MOUSE_BACKGROUND], 0
;       mov     byte[DONT_DRAW_MOUSE], 0
;
;       mov     [new_window_starting], eax
;
; .exit:
;       pop     eax
        ret
 
align 4
;------------------------------------------------------------------------------
draw_rectangle: ;//////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
;> esi = color
;------------------------------------------------------------------------------
        push    eax ebx ecx edi
 
        xor     edi, edi
 
  .flags_set:
        push    ebx
 
        ; set line color
        mov     ecx, esi
 
        ; draw top border
        rol     ebx, 16
        push    ebx
        rol     ebx, 16
        pop     bx
        call    [draw_line]
 
        ; draw bottom border
        mov     ebx, [esp - 2]
        pop     bx
        call    [draw_line]
 
        pop     ebx
        add     ebx, 1 * 65536 - 1
 
        ; draw left border
        rol     eax, 16
        push    eax
        rol     eax, 16
        pop     ax
        call    [draw_line]
 
        ; draw right border
        mov     eax, [esp - 2]
        pop     ax
        call    [draw_line]
 
        pop     edi ecx ebx eax
        ret
 
  .forced:
        push    eax ebx ecx edi
        xor     edi, edi
        inc     edi
        jmp     .flags_set
 
align 4
;------------------------------------------------------------------------------
drawwindow_I_caption: ;////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        push    [edx + WDATA.cl_titlebar]
        mov     esi, edx
 
        mov     edx, [esi + WDATA.box.top]
        mov     eax, edx
        lea     ebx, [edx + 21]
        inc     edx
        add     eax, [esi + WDATA.box.height]
 
        cmp     ebx, eax
        jbe     @f
        mov     ebx, eax
    @@: push    ebx
 
        xor     edi, edi
 
  .next_line:
        mov     ebx, edx
        shl     ebx, 16
        add     ebx, edx
        mov     eax, [esi + WDATA.box.left]
        inc     eax
        shl     eax, 16
        add     eax, [esi + WDATA.box.left]
        add     eax, [esi + WDATA.box.width]
        dec     eax
        mov     ecx, [esi + WDATA.cl_titlebar]
        test    ecx, 0x80000000
        jz      @f
        sub     ecx, 0x00040404
        mov     [esi + WDATA.cl_titlebar], ecx
    @@: and     ecx, 0x00ffffff
        call    [draw_line]
        inc     edx
        cmp     edx, [esp]
        jb      .next_line
 
        add     esp, 4
        pop     [esi + WDATA.cl_titlebar]
        ret
 
align 4
;------------------------------------------------------------------------------
drawwindow_I: ;////////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        pushad
 
        ; window border
 
        mov     eax, [edx + WDATA.box.left - 2]
        mov     ax, word[edx + WDATA.box.left]
        add     ax, word[edx + WDATA.box.width]
        mov     ebx, [edx + WDATA.box.top - 2]
        mov     bx, word[edx + WDATA.box.top]
        add     bx, word[edx + WDATA.box.height]
 
        mov     esi, [edx + WDATA.cl_frames]
        call    draw_rectangle
 
        ; window caption
 
        call    drawwindow_I_caption
 
        ; window client area
 
        ; do we need to draw it?
        mov     edi, [esi + WDATA.cl_workarea]
        test    edi, 0x40000000
        jnz     .exit
 
        ; does client area have a positive size on screen?
        mov     edx, [esi + WDATA.box.top]
        add     edx, 21 + 5
        mov     ebx, [esi + WDATA.box.top]
        add     ebx, [esi + WDATA.box.height]
        cmp     edx, ebx
        jg      .exit
 
        ; okay, let's draw it
        mov     eax, 1
        mov     ebx, 21
        mov     ecx, [esi + WDATA.box.width]
        mov     edx, [esi + WDATA.box.height]
        call    [drawbar]
 
  .exit:
        popad
        ret
 
align 4
;------------------------------------------------------------------------------
drawwindow_III_caption: ;/////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        mov     ecx, [edx + WDATA.cl_titlebar]
        push    ecx
        mov     esi, edx
        mov     edx, [esi + WDATA.box.top]
        add     edx, 4
        mov     ebx, [esi + WDATA.box.top]
        add     ebx, 20
        mov     eax, [esi + WDATA.box.top]
        add     eax, [esi + WDATA.box.height]
 
        cmp     ebx, eax
        jb      @f
        mov     ebx, eax
    @@: push    ebx
 
        xor     edi, edi
 
  .next_line:
        mov     ebx, edx
        shl     ebx, 16
        add     ebx, edx
        mov     eax, [esi + WDATA.box.left]
        shl     eax, 16
        add     eax, [esi + WDATA.box.left]
        add     eax, [esi + WDATA.box.width]
        add     eax, 4 * 65536 - 4
        mov     ecx, [esi + WDATA.cl_titlebar]
        test    ecx, 0x40000000
        jz      @f
        add     ecx, 0x00040404
    @@: test    ecx, 0x80000000
        jz      @f
        sub     ecx, 0x00040404
    @@: mov     [esi + WDATA.cl_titlebar], ecx
        and     ecx, 0x00ffffff
        call    [draw_line]
        inc     edx
        cmp     edx, [esp]
        jb      .next_line
 
        add     esp, 4
        pop     [esi + WDATA.cl_titlebar]
        ret
 
align 4
;------------------------------------------------------------------------------
drawwindow_III: ;//////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        pushad
 
        ; window border
 
        mov     eax, [edx + WDATA.box.left - 2]
        mov     ax, word[edx + WDATA.box.left]
        add     ax, word[edx + WDATA.box.width]
        mov     ebx, [edx + WDATA.box.top - 2]
        mov     bx, word[edx + WDATA.box.top]
        add     bx, word[edx + WDATA.box.height]
 
        mov     esi, [edx + WDATA.cl_frames]
        shr     esi, 1
        and     esi, 0x007f7f7f
        call    draw_rectangle
 
        push    esi
        mov     ecx, 3
        mov     esi, [edx + WDATA.cl_frames]
 
  .next_frame:
        add     eax, 1 * 65536 - 1
        add     ebx, 1 * 65536 - 1
        call    draw_rectangle
        dec     ecx
        jnz     .next_frame
 
        pop     esi
        add     eax, 1 * 65536 - 1
        add     ebx, 1 * 65536 - 1
        call    draw_rectangle
 
        ; window caption
 
        call    drawwindow_III_caption
 
        ; window client area
 
        ; do we need to draw it?
        mov     edi, [esi + WDATA.cl_workarea]
        test    edi, 0x40000000
        jnz     .exit
 
        ; does client area have a positive size on screen?
        mov     edx, [esi + WDATA.box.top]
        add     edx, 21 + 5
        mov     ebx, [esi + WDATA.box.top]
        add     ebx, [esi + WDATA.box.height]
        cmp     edx, ebx
        jg      .exit
 
        ; okay, let's draw it
        mov     eax, 5
        mov     ebx, 20
        mov     ecx, [esi + WDATA.box.width]
        mov     edx, [esi + WDATA.box.height]
        sub     ecx, 4
        sub     edx, 4
        call    [drawbar]
 
  .exit:
        popad
        ret
 
align 4
;------------------------------------------------------------------------------
waredraw: ;////////////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Activate window, redrawing if necessary
;------------------------------------------------------------------------------
        push    -1
        mov     eax, [TASK_COUNT]
        lea     eax, [WIN_POS + eax * 2]
        cmp     eax, esi
        pop     eax
        je      .exit
 
        ; is it overlapped by another window now?
        push    ecx
        call    window._.check_window_draw
        test    ecx, ecx
        pop     ecx
        jz      .do_not_draw
 
        ; yes it is, activate and update screen buffer
        mov     byte[MOUSE_DOWN], 1
        call    window._.window_activate
 
        pushad
        mov     edi, [TASK_COUNT]
        movzx   esi, word[WIN_POS + edi * 2]
        shl     esi, 5
        add     esi, window_data
 
        mov     eax, [esi + WDATA.box.left]
        mov     ebx, [esi + WDATA.box.top]
        mov     ecx, [esi + WDATA.box.width]
        mov     edx, [esi + WDATA.box.height]
 
        add     ecx, eax
        add     edx, ebx
 
        mov     edi, [TASK_COUNT]
        movzx   esi, word[WIN_POS + edi * 2]
        call    window._.set_screen
        popad
 
        ; tell application to redraw itself
        mov     [edi + WDATA.fl_redraw], 1
        xor     eax, eax
        jmp     .exit
 
  .do_not_draw:
        ; no it's not, just activate the window
        call    window._.window_activate
        xor     eax, eax
        mov     byte[MOUSE_BACKGROUND], al
        mov     byte[DONT_DRAW_MOUSE], al
 
 
  .exit:
        mov     byte[MOUSE_DOWN], 0
        inc     eax
        ret
 
align 4
;------------------------------------------------------------------------------
minimize_window: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = window number on screen
;------------------------------------------------------------------------------
;# corrupts [dl*]
;------------------------------------------------------------------------------
        push    edi
        pushfd
        cli
 
        ; is it already minimized?
        movzx   edi, word[WIN_POS + eax * 2]
        shl     edi, 5
        add     edi, window_data
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .exit
 
        push    eax ebx ecx edx esi
 
        ; no it's not, let's do that
        or      [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        mov     eax, [edi + WDATA.box.left]
        mov     [draw_limits.left], eax
        mov     ecx, eax
        add     ecx, [edi + WDATA.box.width]
        mov     [draw_limits.right], ecx
        mov     ebx, [edi + WDATA.box.top]
        mov     [draw_limits.top], ebx
        mov     edx, ebx
        add     edx, [edi + WDATA.box.height]
        mov     [draw_limits.bottom], edx
        call    calculatescreen
        xor     esi, esi
        xor     eax, eax
        call    redrawscreen
 
        pop     esi edx ecx ebx eax
 
  .exit:
        popfd
        pop     edi
        ret
 
align 4
;------------------------------------------------------------------------------
restore_minimized_window: ;////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = window number on screen
;------------------------------------------------------------------------------
;# corrupts [dl*]
;------------------------------------------------------------------------------
        pushad
        pushfd
        cli
 
        ; is it already restored?
        movzx   esi, word[WIN_POS + eax * 2]
        mov     edi, esi
        shl     edi, 5
        add     edi, window_data
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jz      .exit
 
        ; no it's not, let's do that
        mov     [edi + WDATA.fl_redraw], 1
        and     [edi + WDATA.fl_wstate], not WSTATE_MINIMIZED
        mov     ebp, window._.set_screen
        cmp     eax, [TASK_COUNT]
        jz      @f
        mov     ebp, calculatescreen
    @@: mov     eax, [edi + WDATA.box.left]
        mov     ebx, [edi + WDATA.box.top]
        mov     ecx, [edi + WDATA.box.width]
        mov     edx, [edi + WDATA.box.height]
        add     ecx, eax
        add     edx, ebx
        call    ebp
 
        mov     byte[MOUSE_BACKGROUND], 0
 
  .exit:
        popfd
        popad
        ret
 
align 4
; TODO: remove this proc
;------------------------------------------------------------------------------
window_check_events: ;/////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        ; do we have window minimize/restore request?
        cmp     [window_minimize], 0
        je      .exit
 
        ; okay, minimize or restore top-most window and exit
        mov     eax, [TASK_COUNT]
        mov     bl, 0
        xchg    [window_minimize], bl
        dec     bl
        jnz     @f
        call    minimize_window
        jmp     .exit
 
    @@: call    restore_minimized_window
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_maximize_handler: ;/////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> esi = process slot
;------------------------------------------------------------------------------
        mov     edi, esi
        shl     edi, 5
        add     edi, window_data
 
        ; can window change its height?
        ; only types 2 and 3 can be resized
        mov     dl, [edi + WDATA.fl_wstyle]
 
        test    dl, 2
        jz      .exit
 
        ; toggle normal/maximized window state
        mov     bl, [edi + WDATA.fl_wstate]
        xor     bl, WSTATE_MAXIMIZED
 
        ; calculate and set appropriate window bounds
        test    bl, WSTATE_MAXIMIZED
        jz      .restore_size
 
        mov     eax, [screen_workarea.left]
        mov     ecx, [screen_workarea.top]
        push    [screen_workarea.bottom] \
                [screen_workarea.right] \
                ecx \
                eax
        sub     [esp + BOX.width], eax
        sub     [esp + BOX.height], ecx
        mov     eax, esp
        jmp     .set_box
 
  .restore_size:
        mov     eax, esi
        shl     eax, 8
        add     eax, SLOT_BASE + APPDATA.saved_box
        push    [eax + BOX.height] \
                [eax + BOX.width] \
                [eax + BOX.top] \
                [eax + BOX.left]
        mov     eax, esp
 
  .set_box:
        test    bl, WSTATE_ROLLEDUP
        jz      @f
 
        xchg    eax, ecx
        call    window._.get_rolledup_height
        mov     [ecx + BOX.height], eax
        xchg    eax, ecx
 
    @@: call    window._.set_window_box
        add     esp, BOX.sizeof
 
  .exit:
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_rollup_handler: ;///////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> esi = process slot
;------------------------------------------------------------------------------
        mov     edx, esi
        shl     edx, 8
        add     edx, SLOT_BASE
 
        ; toggle normal/rolled up window state
        mov     bl, [edi + WDATA.fl_wstate]
        xor     bl, WSTATE_ROLLEDUP
 
        ; calculate and set appropriate window bounds
        test    bl, WSTATE_ROLLEDUP
        jz      .restore_size
 
        call    window._.get_rolledup_height
        push    eax \
                [edi + WDATA.box.width] \
                [edi + WDATA.box.top] \
                [edi + WDATA.box.left]
        mov     eax, esp
        jmp     .set_box
 
  .restore_size:
        test    bl, WSTATE_MAXIMIZED
        jnz     @f
        add     esp, -BOX.sizeof
        lea     eax, [edx + APPDATA.saved_box]
        jmp     .set_box
 
    @@: mov     eax, [screen_workarea.top]
        push    [screen_workarea.bottom] \
                [edi + WDATA.box.width] \
                eax \
                [edi + WDATA.box.left]
        sub     [esp + BOX.height], eax
        mov     eax, esp
 
  .set_box:
        call    window._.set_window_box
        add     esp, BOX.sizeof
 
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_start_moving_handler: ;/////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> eax = old (original) window box
;> esi = process slot
;------------------------------------------------------------------------------
        mov     edi, eax
        call    window._.draw_negative_box
 
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_end_moving_handler: ;///////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> eax = old (original) window box
;> ebx = new (final) window box
;> esi = process slot
;------------------------------------------------------------------------------
        mov     edi, ebx
        call    window._.draw_negative_box
 
        mov     edi, esi
        shl     edi, 5
        add     edi, window_data
 
        mov     eax, ebx
        mov     bl, [edi + WDATA.fl_wstate]
        call    window._.set_window_box
        ret
 
align 4
;------------------------------------------------------------------------------
sys_window_moving_handler: ;///////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> eax = old (from previous call) window box
;> ebx = new (current) window box
;> esi = process_slot
;------------------------------------------------------------------------------
        mov     edi, eax
        call    window._.draw_negative_box
        mov     edi, ebx
        call    window._.draw_negative_box
        ret
 
;==============================================================================
;///// private functions //////////////////////////////////////////////////////
;==============================================================================
 
iglobal
  FuncTable syscall_display_settings, ftable, \
    00, 01, 02, 03, 04, 05, 06, 07, 08
 
  align 4
  window_topleft dd \
    1, 21, \ ;type 0
    0,  0, \ ;type 1
    5, 20, \ ;type 2
    5,  ?, \ ;type 3 {set by skin}
    5,  ?    ;type 4 {set by skin}
endg
 
;uglobal
  ; NOTE: commented out since doesn't provide necessary functionality anyway,
  ;       to be reworked
; new_window_starting       dd ?
;endg
 
align 4
;------------------------------------------------------------------------------
window._.invalidate_screen: ;//////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> eax = old (original) window box
;> ebx = new (final) window box
;> edi = pointer to WDATA struct
;------------------------------------------------------------------------------
        push    eax ebx
 
        ; TODO: do we really need `draw_limits`?
        mov     ecx, [eax + BOX.left]
        mov     edx, [ebx + BOX.left]
        cmp     ecx, edx
        jle     @f
        xchg    ecx, edx
    @@: mov     [draw_limits.left], ecx
        mov     ecx, [eax + BOX.width]
        cmp     ecx, [ebx + BOX.width]
        jae     @f
        mov     ecx, [ebx + BOX.width]
    @@: add     ecx, edx
        mov     [draw_limits.right], ecx
        mov     ecx, [eax + BOX.top]
        mov     edx, [ebx + BOX.top]
        cmp     ecx, edx
        jle     @f
        xchg    ecx, edx
    @@: mov     [draw_limits.top], ecx
        mov     ecx, [eax + BOX.height]
        cmp     ecx, [ebx + BOX.height]
        jae     @f
        mov     ecx, [ebx + BOX.height]
    @@: add     ecx, edx
        mov     [draw_limits.bottom], ecx
 
        ; recalculate screen buffer at old position
        push    ebx
        mov     edx, [eax + BOX.height]
        mov     ecx, [eax + BOX.width]
        mov     ebx, [eax + BOX.top]
        mov     eax, [eax + BOX.left]
        add     ecx, eax
        add     edx, ebx
        call    calculatescreen
        pop     eax
 
        ; recalculate screen buffer at new position
        mov     edx, [eax + BOX.height]
        mov     ecx, [eax + BOX.width]
        mov     ebx, [eax + BOX.top]
        mov     eax, [eax + BOX.left]
        add     ecx, eax
        add     edx, ebx
        call    calculatescreen
 
        mov     eax, edi
        call    redrawscreen
 
        ; tell window to redraw itself
        mov     [edi + WDATA.fl_redraw], 1
 
        pop     ebx eax
        ret
 
align 4
;------------------------------------------------------------------------------
window._.set_window_box: ;/////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> eax = pointer to BOX struct
;> bl = new window state flags
;> edi = pointer to WDATA struct
;------------------------------------------------------------------------------
        push    eax ebx esi
 
; don't do anything if the new box is identical to the old
	cmp	bl, [edi + WDATA.fl_wstate]
	jnz	@f
	mov	esi, eax
	push	edi
if WDATA.box
	add	edi, WDATA.box
end if
	mov	ecx, 4
	repz	cmpsd
	pop	edi
	jz	.exit
@@:
 
        add     esp, -BOX.sizeof
 
        mov     ebx, esp
if WDATA.box
        lea     esi, [edi + WDATA.box]
else
	mov	esi, edi ; optimization for WDATA.box = 0
end if
        xchg    eax, esi
        mov     ecx, BOX.sizeof
        call    memmove
        xchg    eax, esi
        xchg    ebx, esi
        call    memmove
        mov     eax, ebx
        mov     ebx, esi
 
        call    window._.check_window_position
        call    window._.set_window_clientbox
        call    window._.invalidate_screen
 
        add     esp, BOX.sizeof
 
        mov     cl, [esp + 4]
        mov     ch, cl
        xchg    cl, [edi + WDATA.fl_wstate]
 
        or      cl, ch
        test    cl, WSTATE_MAXIMIZED
        jnz     .exit
 
        mov     eax, edi
        sub     eax, window_data
        shl     eax, 3
        add     eax, SLOT_BASE
 
        lea     ebx, [edi + WDATA.box]
        xchg    esp, ebx
 
        pop     [eax + APPDATA.saved_box.left] \
                [eax + APPDATA.saved_box.top] \
                [eax + APPDATA.saved_box.width] \
                edx
 
        xchg    esp, ebx
 
        test    ch, WSTATE_ROLLEDUP
        jnz     .exit
 
        mov     [eax + APPDATA.saved_box.height], edx
 
  .exit:
        pop     esi ebx eax
        ret
 
align 4
;------------------------------------------------------------------------------
window._.set_window_clientbox: ;///////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> edi = pointer to WDATA struct
;------------------------------------------------------------------------------
        push    eax ecx edi
 
        mov     eax, [_skinh]
        mov     [window_topleft + 8 * 3 + 4], eax
        mov     [window_topleft + 8 * 4 + 4], eax
 
        mov     ecx, edi
        sub     edi, window_data
        shl     edi, 3
        test    [ecx + WDATA.fl_wstyle], WSTYLE_CLIENTRELATIVE
        jz      .whole_window
 
        movzx   eax, [ecx + WDATA.fl_wstyle]
        and     eax, 0x0F
        mov     eax, [eax * 8 + window_topleft + 0]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.left], eax
        shl     eax, 1
        neg     eax
        add     eax, [ecx + WDATA.box.width]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.width], eax
 
        movzx   eax, [ecx + WDATA.fl_wstyle]
        and     eax, 0x0F
        push    [eax * 8 + window_topleft + 0]
        mov     eax, [eax * 8 + window_topleft + 4]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.top], eax
        neg     eax
        sub     eax, [esp]
        add     eax, [ecx + WDATA.box.height]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.height], eax
        add     esp, 4
        jmp     .exit
 
  .whole_window:
        xor     eax, eax
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.left], eax
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.top], eax
        mov     eax, [ecx + WDATA.box.width]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.width], eax
        mov     eax, [ecx + WDATA.box.height]
        mov     [edi + SLOT_BASE + APPDATA.wnd_clientbox.height], eax
 
  .exit:
        pop     edi ecx eax
        ret
 
align 4
;------------------------------------------------------------------------------
window._.sys_set_window: ;/////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;< edx = pointer to WDATA struct
;------------------------------------------------------------------------------
        mov     eax, [CURRENT_TASK]
        shl     eax, 5
        add     eax, window_data
 
        ; save window colors
        mov     [eax + WDATA.cl_workarea], edx
        mov     [eax + WDATA.cl_titlebar], esi
        mov     [eax + WDATA.cl_frames], edi
 
        mov     edi, eax
 
        ; was it already defined before?
        test    [edi + WDATA.fl_wdrawn], 1
        jnz     .set_client_box
 
        ; NOTE: commented out since doesn't provide necessary functionality
        ;       anyway, to be reworked
;       mov     eax, [timer_ticks] ; [0xfdf0]
;       add     eax, 100
;       mov     [new_window_starting], eax
 
        ; no it wasn't, performing initial window definition
        movzx   eax, bx
        mov     [edi + WDATA.box.width], eax
        movzx   eax, cx
        mov     [edi + WDATA.box.height], eax
        sar     ebx, 16
        sar     ecx, 16
        mov     [edi + WDATA.box.left], ebx
        mov     [edi + WDATA.box.top], ecx
 
        call    window._.check_window_position
 
        push    ecx edi
 
        mov     cl, [edi + WDATA.fl_wstyle]
        mov     eax, [edi + WDATA.cl_frames]
 
        sub     edi, window_data
        shl     edi, 3
        add     edi, SLOT_BASE
 
        and     cl, 0x0F
        cmp     cl, 3
        je      @f
        cmp     cl, 4
        je      @f
 
        xor     eax, eax
 
    @@: mov     [edi + APPDATA.wnd_caption], eax
 
        mov     esi, [esp]
        add     edi, APPDATA.saved_box
        movsd
        movsd
        movsd
        movsd
 
        pop     edi ecx
 
        mov     esi, [CURRENT_TASK]
        movzx   esi, word[WIN_STACK + esi * 2]
        lea     esi, [WIN_POS + esi * 2]
        call    waredraw
 
        mov     eax, [edi + WDATA.box.left]
        mov     ebx, [edi + WDATA.box.top]
        mov     ecx, [edi + WDATA.box.width]
        mov     edx, [edi + WDATA.box.height]
        add     ecx, eax
        add     edx, ebx
        call    calculatescreen
 
        mov     byte[KEY_COUNT], 0           ; empty keyboard buffer
        mov     byte[BTN_COUNT], 0           ; empty button buffer
 
  .set_client_box:
        ; update window client box coordinates
        call    window._.set_window_clientbox
 
        ; reset window redraw flag and exit
        mov     [edi + WDATA.fl_redraw], 0
        mov     edx, edi
        ret
 
align 4
;------------------------------------------------------------------------------
window._.check_window_position: ;//////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Check if window is inside screen area
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
        push    eax ebx ecx edx esi
 
        mov     eax, [edi + WDATA.box.left]
        mov     ebx, [edi + WDATA.box.top]
        mov     ecx, [edi + WDATA.box.width]
        mov     edx, [edi + WDATA.box.height]
 
        mov     esi, [Screen_Max_X]
        cmp     ecx, esi
        ja      .fix_width_high
 
  .check_left:
        or      eax, eax
        jl      .fix_left_low
        add     eax, ecx
        cmp     eax, esi
        jg      .fix_left_high
 
  .check_height:
        mov     esi, [Screen_Max_Y]
        cmp     edx, esi
        ja      .fix_height_high
 
  .check_top:
        or      ebx, ebx
        jl      .fix_top_low
        add     ebx, edx
        cmp     ebx, esi
        jg      .fix_top_high
 
  .exit:
        pop     esi edx ecx ebx eax
        ret
 
  .fix_width_high:
        mov     ecx, esi
        mov     [edi + WDATA.box.width], esi
        jmp     .check_left
 
  .fix_left_low:
        xor     eax, eax
        mov     [edi + WDATA.box.left], eax
        jmp     .check_height
 
  .fix_left_high:
        mov     eax, esi
        sub     eax, ecx
        mov     [edi + WDATA.box.left], eax
        jmp     .check_height
 
  .fix_height_high:
        mov     edx, esi
        mov     [edi + WDATA.box.height], esi
        jmp     .check_top
 
  .fix_top_low:
        xor     ebx, ebx
        mov     [edi + WDATA.box.top], ebx
        jmp     .exit
 
  .fix_top_high:
        mov     ebx, esi
        sub     ebx, edx
        mov     [edi + WDATA.box.top], ebx
        jmp     .exit
 
align 4
;------------------------------------------------------------------------------
window._.get_titlebar_height: ;////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
        mov     al, [edi + WDATA.fl_wstyle]
        and     al, 0x0f
        cmp     al, 0x03
        jne     @f
        mov     eax, [_skinh]
        ret
    @@: mov     eax, 21
        ret
 
align 4
;------------------------------------------------------------------------------
window._.get_rolledup_height: ;////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
        mov     al, [edi + WDATA.fl_wstyle]
        and     al, 0x0f
        cmp     al, 0x03
        jb      @f
        mov     eax, [_skinh]
        add     eax, 3
        ret
    @@: or      al, al
        jnz     @f
        mov     eax, 21
        ret
    @@: mov     eax, 21 + 2
        ret
 
align 4
;------------------------------------------------------------------------------
window._.set_screen: ;/////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Reserve window area in screen buffer
;------------------------------------------------------------------------------
;> eax = left
;> ebx = top
;> ecx = right
;> edx = bottom
;> esi = process number
;------------------------------------------------------------------------------
virtual at esp
  ff_x     dd ?
  ff_y     dd ?
  ff_width dd ?
  ff_xsz   dd ?
  ff_ysz   dd ?
  ff_scale dd ?
end virtual
 
        pushad
 
        cmp     esi, 1
        jz      .check_for_shaped_window
        mov     edi, esi
        shl     edi, 5
        cmp     [window_data + edi + WDATA.box.width], 0
        jnz     .check_for_shaped_window
        cmp     [window_data + edi + WDATA.box.height], 0
        jz      .exit
 
  .check_for_shaped_window:
        mov     edi, esi
        shl     edi, 8
        add     edi, SLOT_BASE
        cmp     [edi + APPDATA.wnd_shape], 0
        jne     .shaped_window
 
        ; get x&y size
        sub     ecx, eax
        sub     edx, ebx
        inc     ecx
        inc     edx
 
        ; get WinMap start
        push    esi
        mov     edi, [Screen_Max_X]
        inc     edi
        mov     esi, edi
        imul    edi, ebx
        add     edi, eax
        add     edi, [_WinMapAddress]
        pop     eax
        mov     ah, al
        push    ax
        shl     eax, 16
        pop     ax
 
  .next_line:
        push    ecx
        shr     ecx, 2
        rep     stosd
        mov     ecx, [esp]
        and     ecx, 3
        rep     stosb
        pop     ecx
        add     edi, esi
        sub     edi, ecx
        dec     edx
        jnz     .next_line
 
        jmp     .exit
 
  .shaped_window:
        ;  for (y=0; y <= x_size; y++)
        ;      for (x=0; x <= x_size; x++)
        ;          if (shape[coord(x,y,scale)]==1)
        ;             set_pixel(x, y, process_number);
 
        sub     ecx, eax
        sub     edx, ebx
        inc     ecx
        inc     edx
 
        push    [edi + APPDATA.wnd_shape_scale]  ; push scale first -> for loop
 
        ; get WinMap start  -> ebp
        push    eax
        mov     eax, [Screen_Max_X] ; screen_sx
        inc     eax
        imul    eax, ebx
        add     eax, [esp]
        add     eax, [_WinMapAddress]
        mov     ebp, eax
 
        mov     edi, [edi + APPDATA.wnd_shape]
        pop     eax
 
        ; eax = x_start
        ; ebx = y_start
        ; ecx = x_size
        ; edx = y_size
        ; esi = process_number
        ; edi = &shape
        ;       [scale]
        push    edx ecx ; for loop - x,y size
 
        mov     ecx, esi
        shl     ecx, 5
        mov     edx, [window_data + ecx + WDATA.box.top]
        push    [window_data + ecx + WDATA.box.width]           ; for loop - width
        mov     ecx, [window_data + ecx + WDATA.box.left]
        sub     ebx, edx
        sub     eax, ecx
        push    ebx eax ; for loop - x,y
 
        add     [ff_xsz], eax
        add     [ff_ysz], ebx
 
        mov     ebx, [ff_y]
 
  .ff_new_y:
        mov     edx, [ff_x]
 
  .ff_new_x:
        ; -- body --
        mov     ecx, [ff_scale]
        mov     eax, [ff_width]
        inc     eax
        shr     eax, cl
        push    ebx edx
        shr     ebx, cl
        shr     edx, cl
        imul    eax, ebx
        add     eax, edx
        pop     edx ebx
        add     eax, edi
        call    .read_byte
        test    al,al
        jz      @f
        mov     eax, esi
        mov     [ebp], al
        ; -- end body --
    @@: inc     ebp
        inc     edx
        cmp     edx, [ff_xsz]
        jb      .ff_new_x
 
        sub     ebp, [ff_xsz]
        add     ebp, [ff_x]
        add     ebp, [Screen_Max_X]  ; screen.x
        inc     ebp
        inc     ebx
        cmp     ebx, [ff_ysz]
        jb      .ff_new_y
 
        add     esp, 24
 
  .exit:
        popad
        ret
 
  .read_byte:
        ; eax - address
        ; esi - slot
        push    eax ecx edx esi
        xchg    eax, esi
        lea     ecx, [esp + 12]
        mov     edx, 1
        call    read_process_memory
        pop     esi edx ecx eax
        ret
 
align 4
;------------------------------------------------------------------------------
window._.window_activate: ;////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Activate window
;------------------------------------------------------------------------------
;> esi = pointer to WIN_POS+ window data
;------------------------------------------------------------------------------
        push    eax ebx
 
        ; if type of current active window is 3 or 4, it must be redrawn
        mov     ebx, [TASK_COUNT]
        movzx   ebx, word[WIN_POS + ebx * 2]
        shl     ebx, 5
        add     eax, window_data
        mov     al, [window_data + ebx + WDATA.fl_wstyle]
        and     al, 0x0f
        cmp     al, 0x03
        je      .set_window_redraw_flag
        cmp     al, 0x04
        jne     .move_others_down
 
  .set_window_redraw_flag:
        mov     [window_data + ebx + WDATA.fl_redraw], 1
 
  .move_others_down:
        ; ax <- process no
        movzx   ebx, word[esi]
        ; ax <- position in window stack
        movzx   ebx, word[WIN_STACK + ebx * 2]
 
        ; drop others
        xor     eax, eax
 
  .next_stack_window:
        cmp     eax, [TASK_COUNT]
        jae     .move_self_up
        inc     eax
        cmp     [WIN_STACK + eax * 2], bx
        jbe     .next_stack_window
        dec     word[WIN_STACK + eax * 2]
        jmp     .next_stack_window
 
  .move_self_up:
        movzx   ebx, word[esi]
        ; number of processes
        mov     ax, [TASK_COUNT]
        ; this is the last (and the upper)
        mov     [WIN_STACK + ebx * 2], ax
 
        ; update on screen - window stack
        xor     eax, eax
 
  .next_window_pos:
        cmp     eax, [TASK_COUNT]
        jae     .reset_vars
        inc     eax
        movzx   ebx, word[WIN_STACK + eax * 2]
        mov     [WIN_POS + ebx * 2], ax
        jmp     .next_window_pos
 
  .reset_vars:
        mov     byte[KEY_COUNT], 0
        mov     byte[BTN_COUNT], 0
        mov     word[MOUSE_SCROLL_H], 0
        mov     word[MOUSE_SCROLL_V], 0
 
        pop     ebx eax
        ret
 
align 4
;------------------------------------------------------------------------------
window._.check_window_draw: ;//////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Check if window is necessary to draw
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
        mov     cl, [edi + WDATA.fl_wstyle]
        and     cl, 0x0f
        cmp     cl, 3
        je      .exit.redraw      ; window type 3
        cmp     cl, 4
        je      .exit.redraw      ; window type 4
 
        push    eax ebx edx esi
 
        mov     eax, edi
        sub     eax, window_data
        shr     eax, 5
 
        movzx   eax, word[WIN_STACK + eax * 2]  ; get value of the curr process
        lea     esi, [WIN_POS + eax * 2]        ; get address of this process at 0xC400
 
  .next_window:
        add     esi, 2
 
        mov     eax, [TASK_COUNT]
        lea     eax, word[WIN_POS + eax * 2] ; number of the upper window
 
        cmp     esi, eax
        ja      .exit.no_redraw
 
        movzx   edx, word[esi]
        shl     edx, 5
        cmp     [CURRENT_TASK + edx + TASKDATA.state], TSTATE_FREE
        je      .next_window
 
        mov     eax, [edi + WDATA.box.top]
        mov     ebx, [edi + WDATA.box.height]
        add     ebx, eax
 
        mov     ecx, [window_data + edx + WDATA.box.top]
        cmp     ecx, ebx
        jge     .next_window
        add     ecx, [window_data + edx + WDATA.box.height]
        cmp     eax, ecx
        jge     .next_window
 
        mov     eax, [edi + WDATA.box.left]
        mov     ebx, [edi + WDATA.box.width]
        add     ebx, eax
 
        mov     ecx, [window_data + edx + WDATA.box.left]
        cmp     ecx, ebx
        jge     .next_window
        add     ecx, [window_data + edx + WDATA.box.width]
        cmp     eax, ecx
        jge     .next_window
 
        pop     esi edx ebx eax
 
  .exit.redraw:
        xor     ecx, ecx
        inc     ecx
        ret
 
  .exit.no_redraw:
        pop     esi edx ebx eax
        xor     ecx, ecx
        ret
 
align 4
;------------------------------------------------------------------------------
window._.draw_window_caption: ;////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? 
;------------------------------------------------------------------------------
        inc     [mouse_pause]
        call    [_display.disable_mouse]
 
        xor     eax, eax
        mov     edx, [TASK_COUNT]
        movzx   edx, word[WIN_POS + edx * 2]
        cmp     edx, [CURRENT_TASK]
        jne     @f
        inc     eax
    @@: mov     edx, [CURRENT_TASK]
        shl     edx, 5
        add     edx, window_data
        movzx   ebx, [edx + WDATA.fl_wstyle]
        and     bl, 0x0F
        cmp     bl, 3
        je      .draw_caption_style_3
        cmp     bl, 4
        je      .draw_caption_style_3
 
        jmp     .not_style_3
 
  .draw_caption_style_3:
        push    edx
        call    drawwindow_IV_caption
        add     esp, 4
        jmp     .2
 
  .not_style_3:
        cmp     bl, 2
        jne     .not_style_2
 
        call    drawwindow_III_caption
        jmp     .2
 
  .not_style_2:
        cmp     bl, 0
        jne     .2
 
        call    drawwindow_I_caption
 
  .2:   mov     edi, [CURRENT_TASK]
        shl     edi, 5
        test    [edi + window_data + WDATA.fl_wstyle], WSTYLE_HASCAPTION
        jz      .exit
        mov     edx, [edi * 8 + SLOT_BASE + APPDATA.wnd_caption]
        or      edx, edx
        jz      .exit
 
        movzx   eax, [edi + window_data + WDATA.fl_wstyle]
        and     al, 0x0F
        cmp     al, 3
        je      .skinned
        cmp     al, 4
        je      .skinned
 
        jmp     .not_skinned
 
  .skinned:
        mov     ebp, [edi + window_data + WDATA.box.left - 2]
        mov     bp, word[edi + window_data + WDATA.box.top]
        movzx   eax, word[edi + window_data + WDATA.box.width]
        sub     ax, [_skinmargins.left]
        sub     ax, [_skinmargins.right]
        push    edx
        cwde
        cdq
        mov     ebx, 6
        idiv    ebx
        pop     edx
        or      eax, eax
        js      .exit
 
        mov     esi, eax
        mov     ebx, dword[_skinmargins.left - 2]
        mov     bx, word[_skinh]
        sub     bx, [_skinmargins.bottom]
        sub     bx, [_skinmargins.top]
        sar     bx, 1
        adc     bx, 0
        add     bx, [_skinmargins.top]
        add     bx, -3
        add     ebx, ebp
        jmp     .dodraw
 
  .not_skinned:
        cmp     al, 1
        je      .exit
 
        mov     ebp, [edi + window_data + WDATA.box.left - 2]
        mov     bp, word[edi + window_data + WDATA.box.top]
        movzx   eax, word[edi + window_data + WDATA.box.width]
        sub     eax, 16
        push    edx
        cwde
        cdq
        mov     ebx, 6
        idiv    ebx
        pop     edx
        or      eax, eax
        js      .exit
 
        mov     esi, eax
        mov     ebx, 0x00080007
        add     ebx, ebp
 
  .dodraw:
        mov     ecx, [common_colours + 16]
        or      ecx, 0x80000000
        xor     edi, edi
        call    dtext_asciiz_esi
 
  .exit:
        dec     [mouse_pause]
        call    [draw_pointer]
        ret
 
align 4
;------------------------------------------------------------------------------
window._.draw_negative_box: ;//////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Draw negative box
;------------------------------------------------------------------------------
;> edi = pointer to BOX struct
;------------------------------------------------------------------------------
        push    eax ebx esi
        mov     eax, [edi + BOX.left - 2]
        mov     ax, word[edi + BOX.left]
        add     ax, word[edi + BOX.width]
        mov     ebx, [edi + BOX.top - 2]
        mov     bx, word[edi + BOX.top]
        add     bx, word[edi + BOX.height]
        mov     esi, 0x01000000
        call    draw_rectangle.forced
        pop     esi ebx eax
        ret

Rev 1474	Rev 1526
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8		8
9	$Revision: 1474 $	9	$Revision: 1526 $
10		10
11	;==============================================================================	11	;==============================================================================
12	;///// public functions ///////////////////////////////////////////////////////	12	;///// public functions ///////////////////////////////////////////////////////
13	;==============================================================================	13	;==============================================================================
14		14
15	window.BORDER_SIZE = 5	15	window.BORDER_SIZE = 5
16		16
17	macro FuncTable name, table_name, [label]	17	macro FuncTable name, table_name, [label]
18	{	18	{
19	common	19	common
20	align 4	20	align 4
21	\label name#.#table_name dword	21	\label name#.#table_name dword
22	forward	22	forward
23	dd name#.#label	23	dd name#.#label
24	common	24	common
25	name#.sizeof.#table_name = $ - name#.#table_name	25	name#.sizeof.#table_name = $ - name#.#table_name
26	}	26	}
27		27
28	uglobal	28	uglobal
29	common_colours rd 32	29	common_colours rd 32
30	draw_limits RECT	30	draw_limits RECT
31	endg	31	endg
32		32
33	align 4	33	align 4
34	;------------------------------------------------------------------------------	34	;------------------------------------------------------------------------------
35	syscall_draw_window: ;///// system function 0 /////////////////////////////////	35	syscall_draw_window: ;///// system function 0 /////////////////////////////////
36	;------------------------------------------------------------------------------	36	;------------------------------------------------------------------------------
37	;?	37	;?
38	;------------------------------------------------------------------------------	38	;------------------------------------------------------------------------------
39	mov eax, edx	39	mov eax, edx
40	shr eax, 24	40	shr eax, 24
41	and al, 0x0f	41	and al, 0x0f
42	cmp al, 5	42	cmp al, 5
43	jae .exit	43	jae .exit
44		44
45	push eax	45	push eax
46	inc [mouse_pause]	46	inc [mouse_pause]
47	call [_display.disable_mouse]	47	call [_display.disable_mouse]
48	call window._.sys_set_window	48	call window._.sys_set_window
49	call [_display.disable_mouse]	49	call [_display.disable_mouse]
50	pop eax	50	pop eax
51		51
52	or al, al	52	or al, al
53	jnz @f	53	jnz @f
54		54
55	; type I - original style	55	; type I - original style
56	call drawwindow_I	56	call drawwindow_I
57	jmp window._.draw_window_caption.2	57	jmp window._.draw_window_caption.2
58		58
59	@@: dec al	59	@@: dec al
60	jnz @f	60	jnz @f
61		61
62	; type II - only reserve area, no draw	62	; type II - only reserve area, no draw
63	call sys_window_mouse	63	call sys_window_mouse
64	dec [mouse_pause]	64	dec [mouse_pause]
65	call [draw_pointer]	65	call [draw_pointer]
66	jmp .exit	66	jmp .exit
67		67
68	@@: dec al	68	@@: dec al
69	jnz @f	69	jnz @f
70		70
71	; type III - new style	71	; type III - new style
72	call drawwindow_III	72	call drawwindow_III
73	jmp window._.draw_window_caption.2	73	jmp window._.draw_window_caption.2
74		74
75	; type IV & V - skinned window (resizable & not)	75	; type IV & V - skinned window (resizable & not)
76	@@: mov eax, [TASK_COUNT]	76	@@: mov eax, [TASK_COUNT]
77	movzx eax, word[WIN_POS + eax * 2]	77	movzx eax, word[WIN_POS + eax * 2]
78	cmp eax, [CURRENT_TASK]	78	cmp eax, [CURRENT_TASK]
79	setz al	79	setz al
80	movzx eax, al	80	movzx eax, al
81	push eax	81	push eax
82	call drawwindow_IV	82	call drawwindow_IV
83	jmp window._.draw_window_caption.2	83	jmp window._.draw_window_caption.2
84		84
85	.exit:	85	.exit:
86	ret	86	ret
87		87
88	align 4	88	align 4
89	;------------------------------------------------------------------------------	89	;------------------------------------------------------------------------------
90	syscall_display_settings: ;///// system function 48 ///////////////////////////	90	syscall_display_settings: ;///// system function 48 ///////////////////////////
91	;------------------------------------------------------------------------------	91	;------------------------------------------------------------------------------
92	;; Redraw screen:	92	;; Redraw screen:
93	;< ebx = 0	93	;< ebx = 0
94	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	94	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
95	;; Set button style:	95	;; Set button style:
96	;< ebx = 1	96	;< ebx = 1
97	;< ecx = 0 (flat) or 1 (with gradient)	97	;< ecx = 0 (flat) or 1 (with gradient)
98	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	98	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
99	;; Set system color palette:	99	;; Set system color palette:
100	;< ebx = 2	100	;< ebx = 2
101	;< ecx = pointer to color table	101	;< ecx = pointer to color table
102	;< edx = size of color table	102	;< edx = size of color table
103	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	103	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
104	;; Get system color palette:	104	;; Get system color palette:
105	;< ebx = 3	105	;< ebx = 3
106	;< ecx = pointer to color table buffer	106	;< ecx = pointer to color table buffer
107	;< edx = size of color table buffer	107	;< edx = size of color table buffer
108	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	108	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
109	;; Get skinned caption height:	109	;; Get skinned caption height:
110	;< ebx = 4	110	;< ebx = 4
111	;> eax = height in pixels	111	;> eax = height in pixels
112	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	112	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
113	;; Get screen working area:	113	;; Get screen working area:
114	;< ebx = 5	114	;< ebx = 5
115	;> eax = pack[16(left), 16(right)]	115	;> eax = pack[16(left), 16(right)]
116	;> ebx = pack[16(top), 16(bottom)]	116	;> ebx = pack[16(top), 16(bottom)]
117	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	117	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
118	;; Set screen working area:	118	;; Set screen working area:
119	;< ebx = 6	119	;< ebx = 6
120	;< ecx = pack[16(left), 16(right)]	120	;< ecx = pack[16(left), 16(right)]
121	;< edx = pack[16(top), 16(bottom)]	121	;< edx = pack[16(top), 16(bottom)]
122	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	122	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
123	;; Get skin margins:	123	;; Get skin margins:
124	;< ebx = 7	124	;< ebx = 7
125	;> eax = pack[16(left), 16(right)]	125	;> eax = pack[16(left), 16(right)]
126	;> ebx = pack[16(top), 16(bottom)]	126	;> ebx = pack[16(top), 16(bottom)]
127	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	127	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
128	;; Set skin:	128	;; Set skin:
129	;< ebx = 8	129	;< ebx = 8
130	;< ecx = pointer to FileInfoBlock struct	130	;< ecx = pointer to FileInfoBlock struct
131	;> eax = FS error code	131	;> eax = FS error code
132	;------------------------------------------------------------------------------	132	;------------------------------------------------------------------------------
133	cmp ebx, .sizeof.ftable / 4	133	cmp ebx, .sizeof.ftable / 4
134	ja @f	134	ja @f
135	jmp [.ftable + ebx * 4]	135	jmp [.ftable + ebx * 4]
136	@@: ret	136	@@: ret
137		137
138		138
139	align 4	139	align 4
140	syscall_display_settings.00:	140	syscall_display_settings.00:
141	xor eax, eax	141	xor eax, eax
142	inc ebx	142	inc ebx
143	cmp [windowtypechanged], ebx	143	cmp [windowtypechanged], ebx
144	jne .exit	144	jne .exit
145	mov [windowtypechanged], eax	145	mov [windowtypechanged], eax
146		146
147	jmp syscall_display_settings._.redraw_whole_screen	147	jmp syscall_display_settings._.redraw_whole_screen
148		148
149	.exit:	149	.exit:
150	ret	150	ret
151		151
152	align 4	152	align 4
153	syscall_display_settings.01:	153	syscall_display_settings.01:
154	and ecx, 1	154	and ecx, 1
155	cmp ecx, [buttontype]	155	cmp ecx, [buttontype]
156	je .exit	156	je .exit
157	mov [buttontype], ecx	157	mov [buttontype], ecx
158	mov [windowtypechanged], ebx	158	mov [windowtypechanged], ebx
159		159
160	.exit:	160	.exit:
161	ret	161	ret
162		162
163	align 4	163	align 4
164	syscall_display_settings.02:	164	syscall_display_settings.02:
165	dec ebx	165	dec ebx
166	mov esi, ecx	166	mov esi, ecx
167	and edx, 127	167	and edx, 127
168	mov edi, common_colours	168	mov edi, common_colours
169	mov ecx, edx	169	mov ecx, edx
170	rep movsb	170	rep movsb
171	mov [windowtypechanged], ebx	171	mov [windowtypechanged], ebx
172	ret	172	ret
173		173
174	align 4	174	align 4
175	syscall_display_settings.03:	175	syscall_display_settings.03:
176	mov edi, ecx	176	mov edi, ecx
177	and edx, 127	177	and edx, 127
178	mov esi, common_colours	178	mov esi, common_colours
179	mov ecx, edx	179	mov ecx, edx
180	rep movsb	180	rep movsb
181	ret	181	ret
182		182
183	align 4	183	align 4
184	syscall_display_settings.04:	184	syscall_display_settings.04:
185	mov eax, [_skinh]	185	mov eax, [_skinh]
186	mov [esp + 32], eax	186	mov [esp + 32], eax
187	ret	187	ret
188		188
189	align 4	189	align 4
190	syscall_display_settings.05:	190	syscall_display_settings.05:
191	mov eax, [screen_workarea.left - 2]	191	mov eax, [screen_workarea.left - 2]
192	mov ax, word[screen_workarea.right]	192	mov ax, word[screen_workarea.right]
193	mov [esp + 32], eax	193	mov [esp + 32], eax
194	mov eax, [screen_workarea.top - 2]	194	mov eax, [screen_workarea.top - 2]
195	mov ax, word[screen_workarea.bottom]	195	mov ax, word[screen_workarea.bottom]
196	mov [esp + 20], eax	196	mov [esp + 20], eax
197	ret	197	ret
198		198
199	align 4	199	align 4
200	syscall_display_settings.06:	200	syscall_display_settings.06:
201	xor esi, esi	201	xor esi, esi
202		202
203	mov edi, [Screen_Max_X]	203	mov edi, [Screen_Max_X]
204	mov eax, ecx	204	mov eax, ecx
205	movsx ebx, ax	205	movsx ebx, ax
206	sar eax, 16	206	sar eax, 16
207	cmp eax, ebx	207	cmp eax, ebx
208	jge .check_horizontal	208	jge .check_horizontal
209	inc esi	209	inc esi
210	or eax, eax	210	or eax, eax
211	jge @f	211	jge @f
212	xor eax, eax	212	xor eax, eax
213	@@: mov [screen_workarea.left], eax	213	@@: mov [screen_workarea.left], eax
214	cmp ebx, edi	214	cmp ebx, edi
215	jle @f	215	jle @f
216	mov ebx, edi	216	mov ebx, edi
217	@@: mov [screen_workarea.right], ebx	217	@@: mov [screen_workarea.right], ebx
218		218
219	.check_horizontal:	219	.check_horizontal:
220	mov edi, [Screen_Max_Y]	220	mov edi, [Screen_Max_Y]
221	mov eax, edx	221	mov eax, edx
222	movsx ebx, ax	222	movsx ebx, ax
223	sar eax, 16	223	sar eax, 16
224	cmp eax, ebx	224	cmp eax, ebx
225	jge .check_if_redraw_needed	225	jge .check_if_redraw_needed
226	inc esi	226	inc esi
227	or eax, eax	227	or eax, eax
228	jge @f	228	jge @f
229	xor eax, eax	229	xor eax, eax
230	@@: mov [screen_workarea.top], eax	230	@@: mov [screen_workarea.top], eax
231	cmp ebx, edi	231	cmp ebx, edi
232	jle @f	232	jle @f
233	mov ebx, edi	233	mov ebx, edi
234	@@: mov [screen_workarea.bottom], ebx	234	@@: mov [screen_workarea.bottom], ebx
235		235
236	.check_if_redraw_needed:	236	.check_if_redraw_needed:
237	or esi, esi	237	or esi, esi
238	jz .exit	238	jz .exit
239		239
240	call repos_windows	240	call repos_windows
241	jmp syscall_display_settings._.calculate_whole_screen	241	jmp syscall_display_settings._.calculate_whole_screen
242		242
243	.exit:	243	.exit:
244	ret	244	ret
245		245
246	align 4	246	align 4
247	syscall_display_settings.07:	247	syscall_display_settings.07:
248	mov eax, [_skinmargins + 0]	248	mov eax, [_skinmargins + 0]
249	mov [esp + 32], eax	249	mov [esp + 32], eax
250	mov eax, [_skinmargins + 4]	250	mov eax, [_skinmargins + 4]
251	mov [esp + 20], eax	251	mov [esp + 20], eax
252	ret	252	ret
253		253
254	align 4	254	align 4
255	syscall_display_settings.08:	255	syscall_display_settings.08:
256	mov ebx, ecx	256	mov ebx, ecx
257	call read_skin_file	257	call read_skin_file
258	mov [esp + 32], eax	258	mov [esp + 32], eax
259	test eax, eax	259	test eax, eax
260	jnz .exit	260	jnz .exit
261		261
262	call syscall_display_settings._.calculate_whole_screen	262	call syscall_display_settings._.calculate_whole_screen
263	jmp syscall_display_settings._.redraw_whole_screen	263	jmp syscall_display_settings._.redraw_whole_screen
264		264
265	.exit:	265	.exit:
266	ret	266	ret
267		267
268	syscall_display_settings._.calculate_whole_screen:	268	syscall_display_settings._.calculate_whole_screen:
269	xor eax, eax	269	xor eax, eax
270	xor ebx, ebx	270	xor ebx, ebx
271	mov ecx, [Screen_Max_X]	271	mov ecx, [Screen_Max_X]
272	mov edx, [Screen_Max_Y]	272	mov edx, [Screen_Max_Y]
273	jmp calculatescreen	273	jmp calculatescreen
274		274
275	syscall_display_settings._.redraw_whole_screen:	275	syscall_display_settings._.redraw_whole_screen:
276	xor eax, eax	276	xor eax, eax
277	mov [draw_limits.left], eax	277	mov [draw_limits.left], eax
278	mov [draw_limits.top], eax	278	mov [draw_limits.top], eax
279	mov eax, [Screen_Max_X]	279	mov eax, [Screen_Max_X]
280	mov [draw_limits.right], eax	280	mov [draw_limits.right], eax
281	mov eax, [Screen_Max_Y]	281	mov eax, [Screen_Max_Y]
282	mov [draw_limits.bottom], eax	282	mov [draw_limits.bottom], eax
283	mov eax, window_data	283	mov eax, window_data
284	jmp redrawscreen	284	jmp redrawscreen
285		285
286	align 4	286	align 4
287	;------------------------------------------------------------------------------	287	;------------------------------------------------------------------------------
288	syscall_set_window_shape: ;///// system function 50 ///////////////////////////	288	syscall_set_window_shape: ;///// system function 50 ///////////////////////////
289	;------------------------------------------------------------------------------	289	;------------------------------------------------------------------------------
290	;; Set window shape address:	290	;; Set window shape address:
291	;> ebx = 0	291	;> ebx = 0
292	;> ecx = shape data address	292	;> ecx = shape data address
293	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	293	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
294	;; Set window shape scale:	294	;; Set window shape scale:
295	;> ebx = 1	295	;> ebx = 1
296	;> ecx = scale power (resulting scale is 2^ebx)	296	;> ecx = scale power (resulting scale is 2^ebx)
297	;------------------------------------------------------------------------------	297	;------------------------------------------------------------------------------
298	mov edi, [current_slot]	298	mov edi, [current_slot]
299		299
300	test ebx, ebx	300	test ebx, ebx
301	jne .shape_scale	301	jne .shape_scale
302	mov [edi + APPDATA.wnd_shape], ecx	302	mov [edi + APPDATA.wnd_shape], ecx
303		303
304	.shape_scale:	304	.shape_scale:
305	dec ebx	305	dec ebx
306	jnz .exit	306	jnz .exit
307	mov [edi + APPDATA.wnd_shape_scale], ecx	307	mov [edi + APPDATA.wnd_shape_scale], ecx
308		308
309	.exit:	309	.exit:
310	ret	310	ret
311		311
312	align 4	312	align 4
313	;------------------------------------------------------------------------------	313	;------------------------------------------------------------------------------
314	syscall_move_window: ;///// system function 67 ////////////////////////////////	314	syscall_move_window: ;///// system function 67 ////////////////////////////////
315	;------------------------------------------------------------------------------	315	;------------------------------------------------------------------------------
316	;?	316	;?
317	;------------------------------------------------------------------------------	317	;------------------------------------------------------------------------------
318	mov edi, [CURRENT_TASK]	318	mov edi, [CURRENT_TASK]
319	shl edi, 5	319	shl edi, 5
320	add edi, window_data	320	add edi, window_data
321		321
322	test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED	322	test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
323	jnz .exit	323	jnz .exit
324		324
325	cmp ebx, -1	325	cmp ebx, -1
326	jne @f	326	jne @f
327	mov ebx, [edi + WDATA.box.left]	327	mov ebx, [edi + WDATA.box.left]
328	@@: cmp ecx, -1	328	@@: cmp ecx, -1
329	jne @f	329	jne @f
330	mov ecx, [edi + WDATA.box.top]	330	mov ecx, [edi + WDATA.box.top]
331	@@: cmp edx, -1	331	@@: cmp edx, -1
332	jne @f	332	jne @f
333	mov edx, [edi + WDATA.box.width]	333	mov edx, [edi + WDATA.box.width]
334	@@: cmp esi, -1	334	@@: cmp esi, -1
335	jne @f	335	jne @f
336	mov esi, [edi + WDATA.box.height]	336	mov esi, [edi + WDATA.box.height]
337		337
338	@@: push esi edx ecx ebx	338	@@: push esi edx ecx ebx
339	mov eax, esp	339	mov eax, esp
340	mov bl, [edi + WDATA.fl_wstate]	340	mov bl, [edi + WDATA.fl_wstate]
341	call window._.set_window_box	341	call window._.set_window_box
342	add esp, BOX.sizeof	342	add esp, BOX.sizeof
343		343
344	; NOTE: do we really need this? to be reworked	344	; NOTE: do we really need this? to be reworked
345	; mov byte[DONT_DRAW_MOUSE], 0 ; mouse pointer	345	; mov byte[DONT_DRAW_MOUSE], 0 ; mouse pointer
346	; mov byte[MOUSE_BACKGROUND], 0 ; no mouse under	346	; mov byte[MOUSE_BACKGROUND], 0 ; no mouse under
347	; mov byte[MOUSE_DOWN], 0 ; react to mouse up/down	347	; mov byte[MOUSE_DOWN], 0 ; react to mouse up/down
348		348
349	; NOTE: do we really need this? to be reworked	349	; NOTE: do we really need this? to be reworked
350	; call [draw_pointer]	350	; call [draw_pointer]
351		351
352	.exit:	352	.exit:
353	ret	353	ret
354		354
355	align 4	355	align 4
356	;------------------------------------------------------------------------------	356	;------------------------------------------------------------------------------
357	syscall_window_settings: ;///// system function 71 /////////////////////////////	357	syscall_window_settings: ;///// system function 71 /////////////////////////////
358	;------------------------------------------------------------------------------	358	;------------------------------------------------------------------------------
359	;?	359	;?
360	;------------------------------------------------------------------------------	360	;------------------------------------------------------------------------------
361	dec ebx ; subfunction #1 - set window caption	361	dec ebx ; subfunction #1 - set window caption
362	jnz .exit_fail	362	jnz .exit_fail
363		363
364	; NOTE: only window owner thread can set its caption,	364	; NOTE: only window owner thread can set its caption,
365	; so there's no parameter for PID/TID	365	; so there's no parameter for PID/TID
366		366
367	mov edi, [CURRENT_TASK]	367	mov edi, [CURRENT_TASK]
368	shl edi, 5	368	shl edi, 5
369		369
370	mov [edi * 8 + SLOT_BASE + APPDATA.wnd_caption], ecx	370	mov [edi * 8 + SLOT_BASE + APPDATA.wnd_caption], ecx
371	or [edi + window_data + WDATA.fl_wstyle], WSTYLE_HASCAPTION	371	or [edi + window_data + WDATA.fl_wstyle], WSTYLE_HASCAPTION
372		372
373	call window._.draw_window_caption	373	call window._.draw_window_caption
374		374
375	xor eax, eax ; eax = 0 (success)	375	xor eax, eax ; eax = 0 (success)
376	ret	376	ret
377		377
378	; .get_window_caption:	378	; .get_window_caption:
379	; dec eax ; subfunction #2 - get window caption	379	; dec eax ; subfunction #2 - get window caption
380	; jnz .exit_fail	380	; jnz .exit_fail
381		381
382	; not implemented yet	382	; not implemented yet
383		383
384	.exit_fail:	384	.exit_fail:
385	xor eax, eax	385	xor eax, eax
386	inc eax ; eax = 1 (fail)	386	inc eax ; eax = 1 (fail)
387	ret	387	ret
388		388
389	align 4	389	align 4
390	;------------------------------------------------------------------------------	390	;------------------------------------------------------------------------------
391	set_window_defaults: ;/////////////////////////////////////////////////////////	391	set_window_defaults: ;/////////////////////////////////////////////////////////
392	;------------------------------------------------------------------------------	392	;------------------------------------------------------------------------------
393	;?	393	;?
394	;------------------------------------------------------------------------------	394	;------------------------------------------------------------------------------
395	push eax ecx	395	push eax ecx
396	xor eax, eax	396	xor eax, eax
397	mov ecx, WIN_STACK	397	mov ecx, WIN_STACK
398	@@: inc eax	398	@@: inc eax
399	add ecx, 2	399	add ecx, 2
400	; process no	400	; process no
401	mov [ecx + 0x000], ax	401	mov [ecx + 0x000], ax
402	; positions in stack	402	; positions in stack
403	mov [ecx + 0x400], ax	403	mov [ecx + 0x400], ax
404	cmp ecx, WIN_POS - 2	404	cmp ecx, WIN_POS - 2
405	jne @b	405	jne @b
406	pop ecx eax	406	pop ecx eax
407	ret	407	ret
408		408
409	align 4	409	align 4
410	;------------------------------------------------------------------------------	410	;------------------------------------------------------------------------------
411	calculatescreen: ;/////////////////////////////////////////////////////////////	411	calculatescreen: ;/////////////////////////////////////////////////////////////
412	;------------------------------------------------------------------------------	412	;------------------------------------------------------------------------------
413	;? Scan all windows from bottom to top, calling `setscreen` for each one	413	;? Scan all windows from bottom to top, calling `setscreen` for each one
414	;? intersecting given screen area	414	;? intersecting given screen area
415	;------------------------------------------------------------------------------	415	;------------------------------------------------------------------------------
416	;> eax = left	416	;> eax = left
417	;> ebx = top	417	;> ebx = top
418	;> ecx = right	418	;> ecx = right
419	;> edx = bottom	419	;> edx = bottom
420	;------------------------------------------------------------------------------	420	;------------------------------------------------------------------------------
421	push esi	421	push esi
422	pushfd	422	pushfd
423	cli	423	cli
424		424
425	mov esi, 1	425	mov esi, 1
426	call window._.set_screen	426	call window._.set_screen
427		427
428	push ebp	428	push ebp
429		429
430	mov ebp, [TASK_COUNT]	430	mov ebp, [TASK_COUNT]
431	cmp ebp, 1	431	cmp ebp, 1
432	jbe .exit	432	jbe .exit
433		433
434	push edx ecx ebx eax	434	push edx ecx ebx eax
435		435
436	.next_window:	436	.next_window:
437	movzx edi, word[WIN_POS + esi * 2]	437	movzx edi, word[WIN_POS + esi * 2]
438	shl edi, 5	438	shl edi, 5
439		439
440	cmp [CURRENT_TASK + edi + TASKDATA.state], TSTATE_FREE	440	cmp [CURRENT_TASK + edi + TASKDATA.state], TSTATE_FREE
441	je .skip_window	441	je .skip_window
442		442
443	add edi, window_data	443	add edi, window_data
444	test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED	444	test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
445	jnz .skip_window	445	jnz .skip_window
446		446
447	mov eax, [edi + WDATA.box.left]	447	mov eax, [edi + WDATA.box.left]
448	cmp eax, [esp + RECT.right]	448	cmp eax, [esp + RECT.right]
449	jg .skip_window	449	jg .skip_window
450	mov ebx, [edi + WDATA.box.top]	450	mov ebx, [edi + WDATA.box.top]
451	cmp ebx, [esp + RECT.bottom]	451	cmp ebx, [esp + RECT.bottom]
452	jg .skip_window	452	jg .skip_window
453	mov ecx, [edi + WDATA.box.width]	453	mov ecx, [edi + WDATA.box.width]
454	add ecx, eax	454	add ecx, eax
455	cmp ecx, [esp + RECT.left]	455	cmp ecx, [esp + RECT.left]
456	jl .skip_window	456	jl .skip_window
457	mov edx, [edi + WDATA.box.height]	457	mov edx, [edi + WDATA.box.height]
458	add edx, ebx	458	add edx, ebx
459	cmp edx, [esp + RECT.top]	459	cmp edx, [esp + RECT.top]
460	jl .skip_window	460	jl .skip_window
461		461
462	cmp eax, [esp + RECT.left]	462	cmp eax, [esp + RECT.left]
463	jae @f	463	jae @f
464	mov eax, [esp + RECT.left]	464	mov eax, [esp + RECT.left]
465	@@: cmp ebx, [esp + RECT.top]	465	@@: cmp ebx, [esp + RECT.top]
466	jae @f	466	jae @f
467	mov ebx, [esp + RECT.top]	467	mov ebx, [esp + RECT.top]
468	@@: cmp ecx, [esp + RECT.right]	468	@@: cmp ecx, [esp + RECT.right]
469	jbe @f	469	jbe @f
470	mov ecx, [esp + RECT.right]	470	mov ecx, [esp + RECT.right]
471	@@: cmp edx, [esp + RECT.bottom]	471	@@: cmp edx, [esp + RECT.bottom]
472	jbe @f	472	jbe @f
473	mov edx, [esp + RECT.bottom]	473	mov edx, [esp + RECT.bottom]
474		474
475	@@: push esi	475	@@: push esi
476	movzx esi, word[WIN_POS + esi * 2]	476	movzx esi, word[WIN_POS + esi * 2]
477	call window._.set_screen	477	call window._.set_screen
478	pop esi	478	pop esi
479		479
480	.skip_window:	480	.skip_window:
481	inc esi	481	inc esi
482	dec ebp	482	dec ebp
483	jnz .next_window	483	jnz .next_window
484		484
485	pop eax ebx ecx edx	485	pop eax ebx ecx edx
486		486
487	.exit:	487	.exit:
488	pop ebp	488	pop ebp
489	popfd	489	popfd
490	pop esi	490	pop esi
491	ret	491	ret
492		492
493	align 4	493	align 4
494	;------------------------------------------------------------------------------	494	;------------------------------------------------------------------------------
495	repos_windows: ;///////////////////////////////////////////////////////////////	495	repos_windows: ;///////////////////////////////////////////////////////////////
496	;------------------------------------------------------------------------------	496	;------------------------------------------------------------------------------
497	;?	497	;?
498	;------------------------------------------------------------------------------	498	;------------------------------------------------------------------------------
499	mov ecx, [TASK_COUNT]	499	mov ecx, [TASK_COUNT]
500	mov edi, window_data + WDATA.sizeof * 2	500	mov edi, window_data + WDATA.sizeof * 2

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 1474 → 1526