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


get_titlebar_height: ; edi = window draw_data pointer
        mov     al,[edi+WDATA.fl_wstyle]
        and     al,0x0F
        cmp     al,0x03
        jne     @f
        mov     eax,[_skinh]
        ret
    @@: mov     eax,21
        ret
 
get_rolledup_height: ; edi = window draw_data pointer
        mov     al,[edi+WDATA.fl_wstyle]
        and     al,0x0F
        cmp     al,0x03
        jne     @f
        mov     eax,[_skinh]
        add     eax,3
        ret
    @@: or      al,al
        jnz     @f
        mov     eax,21
        ret
    @@: mov     eax,21+2
        ret
 
 
setwindowdefaults:
        pushad
 
        xor   eax,eax
        mov   ecx,0xc000
       @@:
        inc   eax
        add   ecx,2
        mov   [ecx+0x000],ax          ; process no
        mov   [ecx+0x400],ax          ; positions in stack
        cmp   ecx,0xc400-2            ; the more high, the more surface
        jnz   @b
 
        popad
        ret
 
 
 
; eax = cx
; ebx = cy
; ecx = ex
; edx = ey
; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,
;       è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü
;       ÷àñòåé îêîí âûçâàòü setscreen
align 4
calculatescreen:
        pushad
        pushfd
        cli
 
        push    edx ecx ebx eax
 
        mov     esi, 1
        call    setscreen
 
        mov     ebp, [0x3004]        ; number of processes
        cmp     ebp, 1
        jbe     .finish
        align 4
      .new_wnd:
        movzx   edi, word [0xC400 + esi * 2]
        shl     edi, 5
 
        cmp     [0x3000+edi+TASKDATA.state], byte 9
        je      .not_wnd
 
        add     edi, window_data
        test    [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .not_wnd
 
        mov     eax,[edi+WDATA.box.left]
        cmp     eax, [esp+RECT.right]
        ja      .out_of_bounds
        mov     ebx,[edi+WDATA.box.top]
        cmp     ebx, [esp+RECT.bottom]
        ja      .out_of_bounds
        mov     ecx,[edi+WDATA.box.width]
        add     ecx, eax
        cmp     ecx, [esp+RECT.left]
        jb      .out_of_bounds
        mov     edx,[edi+WDATA.box.height]
        add     edx, ebx
        cmp     edx, [esp+RECT.top]
        jb      .out_of_bounds
 
    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 [0xC400 + esi * 2]
        call    setscreen
        pop     esi
 
      .not_wnd:
      .out_of_bounds:
        inc     esi
        dec     ebp
        jnz     .new_wnd
      .finish:
 
    pop     eax ebx ecx edx
 
        popfd
        popad
ret
 
 
 
virtual at esp
  ff_x     dd ?
  ff_y     dd ?
  ff_width dd ?
  ff_xsz   dd ?
  ff_ysz   dd ?
  ff_scale dd ?
end virtual
 
align 4
; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà
setscreen:
;  eax  x start
;  ebx  y start
;  ecx  x end
;  edx  y end
;  esi  process number
pushad
; \begin{diamond}[29.08.2006]
        cmp     esi, 1
        jz      @f
        mov     edi, esi
        shl     edi, 5
        cmp     [edi+window_data+WDATA.box.width], 0
        jnz     @f
        cmp     [edi+window_data+WDATA.box.height], 0
        jz      .ret
@@:
; \end{diamond}[29.08.2006]
        mov edi, esi ;;;word [esi*2+0xc400]
        shl   edi, 8
        add   edi, 0x80000  ; address of random shaped window area
        cmp   [edi+APPDATA.wnd_shape], dword 0
        jne   .free_form
 
        ; get x&y size
        sub   ecx, eax
        sub   edx, ebx
        inc   ecx
        inc   edx
 
        ; get WinMap start
        mov   edi, [0xFE00] ; screen_sx
        inc   edi
        imul  edi, ebx
        add   edi, eax
        add   edi, WinMapAddress
 
  .new_y:
        push  ecx ; sx
        push  edx
 
        mov   edx, esi
        align 4
  .new_x:
        mov   byte [edi], dl
        inc   edi
        dec   ecx
        jnz   .new_x
 
        pop   edx
        pop   ecx
        add   edi, [0xFE00]
        inc   edi
        sub   edi, ecx
        dec   edx
        jnz   .new_y
.ret:
 popad
 ret
  .read_byte:
   ;eax - address
   ;esi - slot
        push  eax
        push  ebx
        push  ecx
        push  edx
        mov   edx,eax
        mov   eax,esi
        lea   ebx,[esp+12]
        mov   ecx,1
        call  read_process_memory
        pop   edx
        pop   ecx
        pop   ebx
        pop   eax
        ret  
  .free_form:
 
        ;  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  dword [edi+APPDATA.wnd_shape_scale]  ; push scale first -> for loop
 
        ; get WinMap start  -> ebp
        push  eax
        mov   eax, [0xFE00] ; 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, [0xFE00]  ; screen.x
        inc  ebp
        inc  ebx
        cmp  ebx, [ff_ysz]
        jb   .ff_new_y
 
        add  esp, 24
popad
ret
 
 
display_settings:
 
;    eax = 0         ; DISPLAY redraw
;          ebx = 0   ; all
;
;    eax = 1         ; BUTTON type
;          ebx = 0   ; flat
;          ebx = 1   ; 3D
;    eax = 2         ; set WINDOW colours
;          ebx = pointer to table
;          ecx = number of bytes define
;    eax = 3         ; get WINDOW colours
;          ebx = pointer to table
;          ecx = number of bytes wanted
;    eax = 4         ; get skin height
;          input  : nothing
;          output : eax = skin height in pixel
;    eax = 5         ; get screen workarea
;          input  : nothing
;          output : eax = [left]*65536+[right]
;                   ebx = [top]*65536+[bottom]
;    eax = 6         ; set screen workarea
;          input  : ecx = [left]*65536+[right]
;                   edx = [top]*65536+[bottom]
;          output : nothing
;    eax = 7         ; get skin margins
;          input  : nothing
;          output : eax = [left]*65536+[right]
;                   ebx = [top]*65536+[bottom]
;    eax = 8         ; set window skin
;          input  : ecx = pointer to file info block
;          output : eax = FS error code
 
 
     pushad
 
     test eax, eax      ; redraw display
     jnz  dspl0
     test ebx, ebx
     jnz  dspl0
     cmp  [windowtypechanged],dword 1
     jne  dspl00
     mov  [windowtypechanged],dword 0
  redraw_screen_direct:
     mov  [dlx],dword 0
     mov  [dly],dword 0
     mov  eax,[0xfe00]
     mov  [dlxe],eax
     mov  eax,[0xfe04]
     mov  [dlye],eax
     mov  eax,window_data
     call redrawscreen
   dspl00:
     popad
     ret
   dspl0:
 
     cmp  eax,1       ; button type
     jne  dspl1
     and  ebx,1
     cmp  ebx,[buttontype]
     je   dspl9
     mov  [buttontype],ebx
     mov  [windowtypechanged],dword 1
    dspl9:
     popad
     ret
   dspl1:
 
     cmp  eax,2       ; set common window colours
     jne  no_com_colours
     mov  [windowtypechanged],dword 1
     mov  esi,[0x3010]
     add  esi,TASKDATA.mem_start
     add  ebx,[esi]
     mov  esi,ebx
     mov  edi,common_colours
     and  ecx,127
     cld
     rep  movsb
     popad
     ret
   no_com_colours:
 
     cmp  eax,3       ; get common window colours
     jne  no_get_com
     mov  esi,[0x3010]
     add  esi,TASKDATA.mem_start
     add  ebx,[esi]
     mov  edi,ebx
     mov  esi,common_colours
     and  ecx,127
     cld
     rep  movsb
     popad
     ret
   no_get_com:
 
     cmp  eax,4       ; get skin height
     jne  no_skin_height
     popad
     mov  eax,[_skinh]
     mov  [esp+36],eax
     ret
   no_skin_height:
 
        cmp     eax,5       ; get screen workarea
        jne     no_get_workarea
        popad
        mov     eax,[screen_workarea.left-2]
        mov     ax,word[screen_workarea.right]
        mov     [esp+36],eax
        mov     eax,[screen_workarea.top-2]
        mov     ax,word[screen_workarea.bottom]
        mov     [esp+24],eax
        ret
   no_get_workarea:
 
        cmp     eax,6       ; set screen workarea
        jne     no_set_workarea
        movsx   eax,word[esp+16+2]
        movsx   ebx,word[esp+16]
        cmp     eax,ebx
        jge     .lp1
        or      eax,eax;[0xFE00]
        jl      @f
        mov     [screen_workarea.left],eax
    @@: cmp     ebx,[0xFE00]
        jg      .lp1
        mov     [screen_workarea.right],ebx
  .lp1: movsx   eax,word[esp+24+2]
        movsx   ebx,word[esp+24]
        cmp     eax,ebx
        jge     .lp2
        or      eax,eax;[0xFE04]
        jl      @f
        mov     [screen_workarea.top],eax
    @@: cmp     ebx,[0xFE04]
        jg      .lp2
        mov     [screen_workarea.bottom],ebx
  .lp2: call    repos_windows
        mov     eax, 0
        mov     ebx, 0
        mov     ecx, [0xfe00]
        mov     edx, [0xfe04]
    call    calculatescreen
;    jmp    redraw_screen_direct
    .exit:
        popad
        ret
   no_set_workarea:
 
        cmp     eax,7       ; get skin margins
        jne     no_get_skinmargins
        popad
        mov     eax,dword[_skinmargins+0]
        mov     [esp+36],eax
        mov     eax,dword[_skinmargins+4]
        mov     [esp+24],eax
        ret
   no_get_skinmargins:
 
        cmp     eax,8       ; set window skin
        jne     no_set_skin
        mov     eax,ebx
        mov     edi,[0x3010]
        add     ebx,[edi+TASKDATA.mem_start]        ; abs start of info block
        pushd   [ebx+0] [ebx+4] [ebx+8] [ebx+12]
        mov     dword[ebx+0],0        ; read
        mov     dword[ebx+4],0        ; from the beginning
        mov     dword[ebx+8],64       ; 32 KBytes maximum
        mov     ecx,skin_data+64*512
        sub     ecx,[edi+0x10]
        mov     dword[ebx+12],ecx     ; destination
        push    eax
        pushad
        call    file_system
        popad
        pop    eax
        popd    [ebx+12] [ebx+8] [ebx+4] [ebx+0]
        cmp     eax,ERROR_SUCCESS
        je      @f
        cmp     eax,ERROR_END_OF_FILE
        jne     .exit
    @@: cmp     [skin_data+64*512+SKIN_HEADER.ident],'SKIN'
        mov     eax,ERROR_UNKNOWN_FS
        jne     .exit
        mov     esi,skin_data+64*512
        mov     edi,skin_data
        mov     ecx,(64*512)/4
        rep     movsd
        call    parse_skin_data
    pushad
        mov     eax, 0
        mov     ebx, 0
        mov     ecx, [0xfe00]
        mov     edx, [0xfe04]
        call    calculatescreen
    popad
        mov     dword[esp+32+36],0
        jmp     redraw_screen_direct
  .exit:
        mov     [esp+32+36],eax
        popad
        ret
   no_set_skin:
 
     popad
     ret
 
 
repos_windows:
        mov     ecx,[0x3004]
        mov     edi,0x20*2
    mov    byte[0x0000fff0],1
        dec     ecx
        jge    @f
        ret
    @@: mov     [edi+WDATA.fl_redraw],1
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jz      .lp2
        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     .lp1
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [edi+WDATA.box.height],eax
  .lp1:
        call    set_window_clientbox
        add     edi,0x20
        loop    @b
        ret
  .lp2: mov     eax,[edi+WDATA.box.left]
        add     eax,[edi+WDATA.box.width]
    mov    ebx,[0x0000fe00]
;    inc    ebx
    cmp    eax,ebx
    jle    .lp4
        mov     eax,[edi+WDATA.box.width]
    sub    eax,ebx
    jle    .lp3
        mov     [edi+WDATA.box.width],ebx
  .lp3: sub     ebx,[edi+WDATA.box.width]
        mov     [esi+WDATA.box.left],ebx
  .lp4: mov     eax,[edi+WDATA.box.top]
        add     eax,[edi+WDATA.box.height]
    mov    ebx,[0x0000fe04]
;    inc    ebx
    cmp    eax,ebx
    jle    .lp6
        mov     eax,[edi+WDATA.box.height]
    sub    eax,ebx
    jle    .lp5
        mov     [edi+WDATA.box.height],ebx
  .lp5: sub     ebx,[edi+WDATA.box.height]
        mov     [edi+WDATA.box.top],ebx
  .lp6: jmp     .lp1
 
uglobal
  common_colours:
     times 128 db 0x0
endg
 
 
 
 
check_window_position:
 
    pushad                           ; window inside screen ?
 
    movzx eax,word [edi+WDATA.box.left]
    movzx ebx,word [edi+WDATA.box.top]
    movzx ecx,word [edi+WDATA.box.width]
    movzx edx,word [edi+WDATA.box.height]
 
    mov   esi,ecx             ; check x pos
    add   esi,eax
    cmp   esi,[0xfe00]
    jbe   x_pos_ok
    mov   [edi+WDATA.box.left],dword 0
    xor   eax, eax
  x_pos_ok:
 
    mov   esi,edx             ; check y pos
    add   esi,ebx
    cmp   esi,[0xfe04]
    jbe   y_pos_ok
    mov   [edi+WDATA.box.top],dword 0
    mov   ebx,0
  y_pos_ok:
 
    mov   esi,ecx             ; check x size
    add   esi,eax
    cmp   esi,[0xfe00]
    jbe   x_size_ok
    mov   ecx,[0xfe00]
    mov   [edi+WDATA.box.width],ecx
  x_size_ok:
 
    mov   esi,edx             ; check y size
    add   esi,ebx
    cmp   esi,[0xfe04]
    jbe   y_size_ok
    mov   edx,[0xfe04]
    mov   [edi+WDATA.box.height],edx
  y_size_ok:
 
    popad
 
    ret
 
 
uglobal
  new_window_starting dd 0
endg
 
 
sys_window_mouse:
 
    push  eax
 
    mov   eax,[timer_ticks]
    cmp   [new_window_starting],eax
    jb    swml1
 
    mov   [0xfff4],byte 0  ; no mouse background
    mov   [0xfff5],byte 0  ; draw mouse
 
    mov   [new_window_starting],eax
 
  swml1:
 
    pop   eax
 
    ret
 
 
 
 
drawwindow_I_caption:
 
        mov   ecx,[edx+WDATA.cl_titlebar]   ; grab bar
        push  ecx
        mov   esi,edx
        mov   edx,[esi+WDATA.box.top]
        add   edx,1
        mov   ebx,[esi+WDATA.box.top]
        add   ebx,21
        mov   eax,[esi+WDATA.box.top]
        add   eax,[esi+WDATA.box.height]
        cmp   ebx,eax
        jb    .wdsizeok
        mov   ebx,eax
  .wdsizeok:
        push  ebx
  .drwi:
        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]
        sub   eax,1
        push  edx
        mov   edx,0x80000000
        mov   ecx,[esi+WDATA.cl_titlebar]
        and   ecx,edx
        cmp   ecx,edx
        jnz   .nofa
        mov   ecx,[esi+WDATA.cl_titlebar]
        sub   ecx,0x00040404
        mov   [esi+WDATA.cl_titlebar],ecx
        and   ecx,0x00ffffff
        jmp   .faj
  .nofa:
        mov   ecx,[esi+WDATA.cl_titlebar]
        and   ecx,0x00ffffff
  .faj:
        pop   edx
        mov   edi,0
        call  [draw_line]
        inc   edx
        cmp   edx,[esp]
        jb    .drwi
        add   esp,4
        pop   ecx
        mov   [esi+WDATA.cl_titlebar],ecx
 
        ret
 
 
drawwindow_I:
 
        pushad
        or      [edx+WDATA.fl_wdrawn], 4
 
        mov   esi,[edx+WDATA.cl_frames]   ; rectangle
        mov   eax,[edx+WDATA.box.left]
        shl   eax,16
        add   eax,[edx+WDATA.box.left]
        add   eax,[edx+WDATA.box.width]
        mov   ebx,[edx+WDATA.box.top]
        shl   ebx,16
        add   ebx,[edx+WDATA.box.top]
        add   ebx,[edx+WDATA.box.height]
        call  draw_rectangle
 
        and     [edx+WDATA.fl_wdrawn], not 4
        test    [edx+WDATA.fl_wdrawn], 2
        jz      @f
        call    drawwindowframes2
@@:
 
        call    drawwindow_I_caption
 
        mov   edx,[esi+WDATA.box.top]      ; inside work area
        add   edx,21+5
        mov   ebx,[esi+WDATA.box.top]
        add   ebx,[esi+WDATA.box.height]
        cmp   edx,ebx
        jg    noinside
        mov   eax,1
        mov   ebx,21
        mov   ecx,[esi+WDATA.box.width]
        mov   edx,[esi+WDATA.box.height]
        mov   edi,[esi+WDATA.cl_workarea]
	test  edi,0x40000000
	jnz   noinside
        call  [drawbar]
      noinside:
 
        popad
 
        ret
 
 
draw_rectangle:
 
r_eax equ [esp+28]   ; x start
r_ax  equ [esp+30]   ; x end
r_ebx equ [esp+16]   ; y start
r_bx  equ [esp+18]   ; y end
;esi                 ; color
 
        pushad
 
        mov   ecx,esi          ; yb,xb -> yb,xe
        mov   eax, r_eax
        rol   eax, 16
        mov   ebx,r_ebx
        shl   ebx,16
        mov   bx,r_ebx
        xor   edi, edi
        call  [draw_line]
 
        mov   ebx,r_bx         ; ye,xb -> ye,xe
        shl   ebx,16
        mov   bx,r_bx
        call  [draw_line]
 
        mov   ecx,esi          ; ya,xa -> ye,xa
        mov   eax,r_eax
        shl   eax,16
        mov   ax,r_eax
        mov   ebx,r_ebx
        shl   ebx,16
        mov   bx,r_bx
        mov   edi,0
        call  [draw_line]
 
        mov   eax,r_ax       ; ya,xe -> ye,xe
        shl   eax,16
        mov   ax,r_ax
        call  [draw_line]
 
        popad
        ret
 
 
drawwindow_III_caption:
 
        mov   ecx,[edx+WDATA.cl_titlebar]                       ; GRAB BAR
        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    .wdsizeok
        mov   ebx,eax
  .wdsizeok:
        push  ebx
  .drwi:
        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    .nofa
        add   ecx,0x040404
  .nofa:
        test  ecx,0x80000000
        jz    .nofa2
        sub   ecx,0x040404
  .nofa2:
        mov   [esi+WDATA.cl_titlebar],ecx
        and   ecx,0xffffff
        xor   edi, edi
        call  [draw_line]
        inc   edx
        cmp   edx,[esp]
        jb    .drwi
        add   esp,4
        pop   ecx
        mov   [esi+WDATA.cl_titlebar],ecx
 
        ret
 
 
drawwindow_III:
 
        pushad
 
        mov   edi,edx                              ; RECTANGLE
        mov   eax,[edi+WDATA.box.left]
        shl   eax,16
    mov   ax, word [edi+WDATA.box.left]
    add   ax, word [edi+WDATA.box.width]
        mov   ebx,[edi+WDATA.box.top]
        shl   ebx,16
    mov   bx, word [edi+WDATA.box.top]
    add   bx, word [edi+WDATA.box.height]
        mov   esi,[edi+WDATA.cl_frames]
        shr   esi,1
        and   esi,0x007f7f7f
        push  esi
        or      [edi+WDATA.fl_wdrawn], 4
        call  draw_rectangle
        and     [edi+WDATA.fl_wdrawn], not 4
        test    [edi+WDATA.fl_wdrawn], 2
        jz      @f
        call    drawwindowframes2
@@:
        mov   ecx,3
      dw3l:
        add   eax,1*65536-1
        add   ebx,1*65536-1
        mov   esi,[edi+WDATA.cl_frames]
        call  draw_rectangle
        dec   ecx
        jnz   dw3l
        pop   esi
        add   eax,1*65536-1
        add   ebx,1*65536-1
        call  draw_rectangle
 
        call    drawwindow_III_caption
 
        mov   edx,[esi+WDATA.box.top]                       ; WORK AREA
        add   edx,21+5
        mov   ebx,[esi+WDATA.box.top]
        add   ebx,[esi+WDATA.box.height]
        cmp   edx,ebx
        jg    noinside2
        mov   eax,5
        mov   ebx,20
        mov   ecx,[esi+WDATA.box.width]
        mov   edx,[esi+WDATA.box.height]
        sub   ecx,4
        sub   edx,4
        mov   edi,[esi+WDATA.cl_workarea]
	test  edi,0x40000000
	jnz   noinside2
        call  [drawbar]
      noinside2:
 
        popad
 
        ret
 
 
 
; activate window
align 4
windowactivate:
 
        ; esi = abs mem position in stack 0xC400+
 
        pushad
 
     ; if type of current active window is 3,
     ; it must be redrawn
        mov   eax, [0x3004]
        movzx eax, word [0xC400 + eax*2]
        shl   eax, 5
        add   eax, window_data
        mov   ebx, [eax + WDATA.cl_workarea]
        and   ebx, 0x0f000000
        cmp   ebx, 0x03000000
        jne   @f
        mov   [eax + WDATA.fl_redraw], byte 1
     @@:
 
        push   esi
      movzx   eax, word [esi] ; ax <- process no
      movzx   eax, word [0xC000+eax*2] ; ax <- position in window stack
 
        xor   esi, esi        ; drop others
      waloop:
        cmp   esi, dword [0x3004]
        jae   wacont
        inc   esi
        lea   edi, [0xC000 + esi*2]
        mov   bx, [edi] ; position of the current process
        cmp   bx, ax
        jbe   @f
        dec   bx       ; upper? => drop!
        mov   [edi], bx
      @@:
        jmp   waloop
      wacont:
                            ; set to no 1
        pop   esi           ;   esi = pointer at 0xC400
 
      movzx   eax, word [esi]
        mov   bx, [0x3004]  ; number of processes
        mov   [0xC000+eax*2], bx     ; this is the last (and the upper)
 
        ; update on screen -window stack
        xor   esi, esi
      waloop2:
        mov   edi, [0x3004]
        cmp   esi, edi
        jae   wacont2
        inc   esi
        movzx ebx, word [esi*2 + 0xC000]
        mov   [ebx*2 + 0xC400], si
        jmp   waloop2
      wacont2:
        mov   [0xf400], byte 0           ; empty keyboard buffer
        mov   [0xf500], byte 0           ; empty button buffer
        popad
        ret
 
 
; check if window is necessary to draw
 
checkwindowdraw:
 
        ; edi = position in window_data+
 
        mov   eax, [edi + WDATA.cl_workarea]
        and   eax, 0x0f000000
        cmp   eax, 0x03000000
        je    .return_yes      ; window type 3
 
        mov   esi, edi
        sub   esi, window_data
        shr   esi, 5
 
        ; esi = process number
 
        movzx eax, word [0xC000 + esi * 2] ; get value of the curr process
        lea   esi, [0xC400 + eax * 2]      ; get address of this process at 0xC400
 
        push  esi
 
      .new_check:
 
        pop   esi
        add   esi, 2
        push  esi
 
        mov   eax, [0x3004]
        lea   eax, word [0xC400 + eax * 2] ; number of the upper window
 
        cmp   esi, eax
        ja    .all_wnds_to_top
 
        movzx eax, word [esi]
        shl   eax, 5
        cmp   [0x3000 + eax + TASKDATA.state], byte 9
        je    .new_check                    ; skip dead windows
 
        lea   esi, [eax+window_data]
 
        mov   ebx, [edi+WDATA.box.top]  ; y0
        mov   edx, [edi+WDATA.box.height]
        add   edx, ebx      ; y0e
 
        mov   ecx, [esi+WDATA.box.top]  ; y  ; y check
        cmp   ecx, edx      
        jae   .new_check     ; y < y0e
        mov   eax, [esi+WDATA.box.height]
        add   ecx, eax       ; ye
        cmp   ebx, ecx       ; y0 >= ye
        ja    .new_check
 
        mov   eax, [edi+WDATA.box.left]   ; x0
        mov   ecx, [edi+WDATA.box.width]
        add   ecx, eax       ; x0e
 
        mov   edx, [esi+WDATA.box.left]   ; x ; x check
        cmp   edx, ecx
        jae   .new_check     ; x < x0e
        mov   ecx, [esi+WDATA.box.width]
        add   edx, ecx
        cmp   eax, edx
        ja    .new_check
 
        pop   esi
  .return_yes:
        mov   ecx,1   ; overlap some window
        ret
 
  .all_wnds_to_top:
 
        pop   esi
 
        xor   ecx, ecx       ; passed all windows to top
        ret
 
 
 
 
waredraw:     ; if redraw necessary at activate
 
        pushad
 
        call  checkwindowdraw      ; draw window on activation ?
        test  ecx, ecx
        jz    .do_not_draw
 
        popad
        mov   [0xfb44], byte 1     ; do draw mouse
        call  windowactivate
 
        ; update screen info
        pushad
        mov   edi, [0x3004] ; the last process (number)
        movzx esi, word [0xC400 + edi * 2]
        shl   esi, 5
        add   esi, window_data
 
        ; coordinates of the upper window
    mov   eax, [esi + WDATA.box.left]   ; cx
    mov   ebx, [esi + WDATA.box.top]    ; cy
    mov   ecx, [esi + WDATA.box.width]  ; sx
    mov   edx, [esi + WDATA.box.height] ; sy
 
        add   ecx, eax       ; ecx = x_end
        add   edx, ebx       ; edx = y_end
 
        mov   edi, [0x3004]
        movzx esi, word [0xC400 + edi * 2]
        call  setscreen
        popad
 
    mov   [edi + WDATA.fl_redraw], 1  ; redraw flag for app
    mov   [0xfb44],byte 0             ; mouse down checks
 
        ret
 
     .do_not_draw:
 
        popad
 
        call  windowactivate
        mov   [0xfb44],byte 0  ; mouse down checks
        mov   [0xfff4],byte 0  ; no mouse background
        mov   [0xfff5],byte 0  ; draw mouse
        ret
 
 
; eax = window number on screen
; corrupts registers and [dl*]
minimize_window:
        movzx eax, word [0xC400+eax*2]
        shl   eax, 5
        add   eax, window_data
        test  [eax+WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz   .skip_redrawings
        pushfd
        cli
        or    [eax+WDATA.fl_wstate], WSTATE_MINIMIZED
        mov   edi, eax
        ;call  calculatescreen
        mov   eax, [edi+WDATA.box.left]
        mov   [dlx], eax
        mov   ecx, eax
        add   ecx, [edi+WDATA.box.width]
        mov   [dlxe], ecx
        mov   ebx, [edi+WDATA.box.top]
        mov   [dly], ebx
        mov   edx, ebx
        add   edx, [edi+WDATA.box.height]
        mov   [dlye], edx
        call  calculatescreen
        xor   esi, esi
        xor   eax, eax
        call  redrawscreen
        popfd
.skip_redrawings:
        ret
 
; eax = window number on screen
; corrupts registers and [dl*]
restore_minimized_window:
        pushfd
        cli
        movzx esi, word [0xC400+eax*2]
        mov   edi, esi
        shl   edi, 5
        add   edi, window_data
        test  [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
        jz    .skip_redrawings
        mov   [edi+WDATA.fl_redraw], 1
        and   [edi+WDATA.fl_wstate], not WSTATE_MINIMIZED
        cmp   eax, [0x3004] ; the uppermost window
        jnz   .no_uppermost
        mov   eax, [edi+WDATA.box.left]
        mov   ebx, [edi+WDATA.box.top]
        mov   ecx, eax
        mov   edx, ebx
        add   ecx, [edi+WDATA.box.width]
        add   edx, [edi+WDATA.box.height]
        call  setscreen
        jmp   .done
.no_uppermost:
        mov   eax, [edi+WDATA.box.left]
        mov   ebx, [edi+WDATA.box.top]
        mov   ecx, eax
        mov   edx, ebx
        add   ecx, [edi+WDATA.box.width]
        add   edx, [edi+WDATA.box.height]
        call  calculatescreen
.done:
        mov   [0xfff4],byte 0 ; no mouse under
.skip_redrawings:
        popfd
        ret
 
 
iglobal
  window_moving   db 'K : Window - move/resize',13,10,0
  window_moved    db 'K : Window - done',13,10,0
endg
 
; check window touch
align 4
checkwindows:
        pushad
 
        cmp   [window_minimize], 0
        je    .no_minimizing
        mov   eax, [0x3004]       ; the uppermost window
        mov   bl, 0
        xchg  [window_minimize], bl
        cmp   bl, 1
        jne   .restore
        call  minimize_window
        jmp   .continue
  .restore:
        call  restore_minimized_window
  .continue:
  .no_minimizing:
 
        cmp   [0xfb40],byte 0    ; mouse buttons pressed ?
        jne   .mouse_buttons_pressed
        popad
        ret
    .mouse_buttons_pressed:
 
        mov   esi,[0x3004]
        inc   esi
 
      cwloop:
        cmp   esi,2
        jb   .exit
 
        dec   esi
        movzx edi, word [0xC400 + esi * 2] ; ebx
        shl   edi, 5
        add   edi, window_data
;        mov   edi, ebx
    mov   ecx, [edi + WDATA.box.left]
    mov   edx, [edi + WDATA.box.top]
 
        mov   eax,ecx
        mov   ebx,edx
        test    [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
        jnz     cwloop
 
       movzx  eax, word [0xfb0a]
       movzx  ebx, word [0xfb0c]
       
        cmp   ecx, eax
        jae   cwloop
        cmp   edx, ebx
        jae   cwloop
    add   ecx, [edi + WDATA.box.width]
    add   edx, [edi + WDATA.box.height]
        cmp   eax, ecx
        jae   cwloop
        cmp   ebx, edx
        jae   cwloop
 
        pushad
        mov   eax, esi
        mov   ebx, [0x3004]
        cmp   eax, ebx      ; is this window active?
        jz    .move_resize_window
 
        ; eax = position in windowing stack
        ; redraw must ?
        lea   esi, [0xC400 + esi * 2]
        call  waredraw
        add   esp, 32
 
      .exit:
        popad
        ret
 
   .move_resize_window:    ; MOVE OR RESIZE WINDOW
        popad
 
        ; Check for user enabled fixed window
    mov   edx, [edi + WDATA.cl_titlebar]
        and   edx, 0x0f000000
        cmp   edx, 0x01000000
        jne   .window_move_enabled_for_user
        popad
        ret
      .window_move_enabled_for_user:
 
    test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     .no_resize_2
 
        mov   [do_resize_from_corner],byte 0   ; resize for skinned window
    mov   edx, [edi + WDATA.cl_workarea]
        and   edx, 0x0f000000
        cmp   edx, 0x02000000
        jb    .no_resize_2 ; not type 2 wnd
 
    mov   edx, [edi + WDATA.box.top]
    add   edx, [edi + WDATA.box.height]
        sub   edx, 6       ; edx = y_end - 6
        cmp   ebx, edx     ; ebx = mouse_y
        jb    .no_resize_2
        mov   [do_resize_from_corner],byte 1
        jmp   .continue
      .no_resize_2:
 
        push    eax
        call    get_titlebar_height
    add     eax,[edi + WDATA.box.top]
        cmp     ebx,eax
        pop     eax
        jae     .exit
 
     .continue:
 
        push  esi
        mov   esi, window_moving
        call  sys_msg_board_str
        pop   esi
 
        mov   ecx, [timer_ticks]     ; double-click ?
        mov   edx, ecx
        sub   edx, [latest_window_touch]
        mov   [latest_window_touch], ecx
        mov   [latest_window_touch_delta], edx
 
        mov   cl, [0xfb40]     ; save for shade check
        mov   [do_resize], cl
     no_emulation_righ_button:
    mov   ecx, [edi + WDATA.box.left]
    mov   edx, [edi + WDATA.box.top]
 
        push  eax ecx edx
        mov   [dlx], ecx      ; save for drawlimits
        mov   [dly], edx
    mov   eax, [edi + WDATA.box.width]
        add   ecx, eax
    mov   eax, [edi + WDATA.box.height]
        add   edx, eax
        mov   [dlxe], ecx
        mov   [dlye], edx
        pop   edx ecx eax
 
        sub   eax, ecx
        sub   ebx, edx
 
        mov   esi, [0xfb0a]
        mov   [0xf300], esi
 
        pushad           ; wait for putimages to finish
;        mov   eax,5
;        call  delay_hs
    mov   eax,[edi + WDATA.box.left]
        mov   [npx],eax
    mov   eax,[edi + WDATA.box.top]
        mov   [npy],eax
        popad
 
        push eax                  ; save old coordinates
    mov   ax, word [edi + WDATA.box.left]
        mov   word [oldc+BOX.left],ax
    mov   ax, word [edi + WDATA.box.top]
        mov   word [oldc+BOX.top],ax
    mov   ax, word [edi + WDATA.box.width]
        mov   word [oldc+BOX.width],ax
        mov   word [npxe],ax
    mov   ax, word [edi + WDATA.box.height]
        mov   word [oldc+BOX.height],ax
        mov   word [npye],ax
        pop eax
 
        call  drawwindowframes
 
        mov   [reposition],0
        mov   [0xfb44],byte 1   ; no reaction to mouse up/down
 
        ; move window
 
      newchm:
 
        mov   [0xfff5],byte 1
 
        call  checkidle
 
        call  checkVga_N13
 
        mov   [0xfff4],byte 0
 
        call  [draw_pointer]
 
        pushad
        call   stack_handler
        popad
 
        mov   esi,[0xf300]
        cmp   esi,[0xfb0a]
        je    cwb
 
        mov   cx,[0xfb0a]
        mov   dx,[0xfb0c]
        sub   cx,ax
        sub   dx,bx
 
        push  ax
        push  bx
 
        call  drawwindowframes
 
        mov   ax,[0xfe00]
        mov   bx,[0xfe04]
 
        cmp   [do_resize_from_corner],1
        je    no_new_position
 
        mov   word [npx],word 0     ; x repos ?
        cmp   ax,cx
        jb    noreposx
        mov   [reposition],1
        sub   ax,word [npxe]
        mov   word [npx],ax
        cmp   ax,cx
        jb    noreposx
        mov   word [npx],cx
      noreposx:
 
        mov   word [npy],word 0     ; y repos ?
        cmp   bx,dx
        jb    noreposy
        mov   [reposition],1
        sub   bx,word [npye]
        mov   word [npy],bx
        cmp   bx,dx
        jb    noreposy
        mov   word [npy],dx
      noreposy:
 
      no_new_position:
 
        cmp   [do_resize_from_corner],0    ; resize from right corner
        je    norepos_size
        pushad
 
        mov   edx,edi
        sub   edx,window_data
        ;shr   edx,5
        ;shl   edx,8
        ;add   edx,0x80000                 ; process base at 0x80000+
    lea   edx, [0x80000 + edx*8]
 
        movzx eax,word [0xfb0a]
    cmp   eax,[edi + WDATA.box.left]
        jb    nnepx
    sub   eax,[edi + WDATA.box.left]
        cmp   eax,32 ; [edx+0x90+8]
        jge   nnepx2
        mov   eax,32 ; [edx+0x90+8]
      nnepx2:
        mov   [npxe],eax
      nnepx:
 
        call    get_rolledup_height
        mov     ebx,eax
        movzx eax,word [0xfb0c]
    cmp   eax,[edi + WDATA.box.top]
        jb    nnepy
    sub   eax,[edi + WDATA.box.top]
        cmp     eax,ebx ; [edx+0x90+12]
        jge     nnepy2
        mov     eax,ebx ; [edx+0x90+12]
      nnepy2:
        mov   [npye],eax
      nnepy:
 
        mov   [reposition],1
 
        popad
      norepos_size:
 
        pop   bx
        pop   ax
        call  drawwindowframes
 
        mov   esi,[0xfb0a]
        mov   [0xf300],esi
 
      cwb:
        cmp   [0xfb40],byte 0
        jne   newchm 
                                     ; new position done
        mov     [0xfff5],byte 1
        mov     cl,0
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        mov     cl,[reposition]
        call    drawwindowframes
 
        mov   eax,[npx]
    mov   [edi + WDATA.box.left],eax
        mov   eax,[npy]
    mov   [edi + WDATA.box.top],eax
        mov   eax,[npxe]
    mov   [edi + WDATA.box.width],eax
        mov   eax,[npye]
    mov   [edi + WDATA.box.height],eax
        call    set_window_clientbox
 
    @@: mov     [reposition],cl
 
        cmp   [reposition],1         ; save new position and size
        jne   no_bounds_save
        push  esi edi ecx
        mov   esi,edi
        mov   ecx,2
        test  [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP or WSTATE_MAXIMIZED
        jnz   @f
        add   ecx,2
    @@: sub   edi,window_data
        shr   edi,5
        shl   edi,8
        add   edi,0x80000+APPDATA.saved_box
        cld
        rep   movsd
        pop   ecx edi esi
      no_bounds_save:
 
        pushad                             ; WINDOW SHADE/FULLSCREEN
 
        cmp   [reposition],1
        je    no_window_sizing
        mov   edx,edi
        sub   edx,window_data
        shr   edx,5
        shl   edx,8
        add   edx,0x80000                 ; process base at 0x80000+
 
        cmp   [do_resize],2               ; window shade ?
        jne   no_window_shade
        mov   [reposition],1
 
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     wnd_rolldown
  wnd_rollup:
        or      [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        call    get_rolledup_height
        jmp     @f
  wnd_rolldown:
        and     [edi+WDATA.fl_wstate],not WSTATE_ROLLEDUP
    mov     eax,[edx + APPDATA.saved_box.height] ; 0x90+BOX.height
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jz      @f
        mov     eax,[screen_workarea.bottom]
        sub     eax,[screen_workarea.top]
    @@: mov     [edi+WDATA.box.height],eax
        call    set_window_clientbox
 
      no_window_shade:
 
        cmp   [do_resize],1               ; fullscreen/restore ?
        jne   no_fullscreen_restore
        cmp   [latest_window_touch_delta],dword 50
        jg    no_fullscreen_restore
        mov   [reposition],1
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     restore_from_fullscreen
        or      [edi+WDATA.fl_wstate],WSTATE_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     @f
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [edi+WDATA.box.height],eax
    @@:
        jmp     restore_from_fullscreen.clientbox
      restore_from_fullscreen:
        and     [edi+WDATA.fl_wstate],not WSTATE_MAXIMIZED
        push    [edi+WDATA.box.height]
        push  edi                         ; restore
        lea   esi, [edx + APPDATA.saved_box]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
        pop     eax
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jz      @f
        mov     [edi+WDATA.box.height],eax
    @@:
    .clientbox:
        call    set_window_clientbox
 
      no_fullscreen_restore:
 
        mov   eax,[edi+WDATA.box.top]                 ; check Y inside screen
        add   eax,[edi+WDATA.box.height]
        cmp   eax,[0xfe04]
        jbe   no_window_sizing
        mov   eax,[edi+WDATA.box.left]                 ; check X inside screen
        add   eax,[edi+WDATA.box.width]
        cmp   eax,[0xfe00]
        jbe   no_window_sizing
        mov   eax,[0xfe00]
        sub   eax,[edi+WDATA.box.width]
        mov   [edi+WDATA.box.left],eax
        mov   eax,[0xfe04]
        sub   eax,[edi+WDATA.box.height]
        mov   [edi+WDATA.box.top],eax
        call  set_window_clientbox
      no_window_sizing:
 
        popad
 
        cmp   [reposition],0
        je    retwm
 
        mov   [0xfff5],byte 1 ; no mouse
 
 
        push  eax ebx ecx edx
        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   eax,[oldc+BOX.left]
        mov   ebx,[oldc+BOX.top]
        mov   ecx,[oldc+BOX.width]
        mov   edx,[oldc+BOX.height]
        add   ecx,eax
        add   edx,ebx
        call  calculatescreen
        pop   edx ecx ebx eax
 
        mov   eax,edi
        call  redrawscreen
 
 
        mov     [edi+WDATA.fl_redraw],1
 
        mov   ecx,100         ; wait to avoid mouse residuals
      waitre2:
        mov   [0xfff5],byte 1
        call  checkidle
        cmp     [edi+WDATA.fl_redraw],0
        jz    retwm
        loop  waitre2
 
      retwm:
 
        mov   [0xfff5],byte 0 ; mouse pointer
        mov   [0xfff4],byte 0 ; no mouse under
        mov   [0xfb44],byte 0 ; react to mouse up/down
 
        mov    esi,window_moved
        call   sys_msg_board_str
 
        popad
 
        ret
 
 
uglobal
  add_window_data            dd  0
  do_resize_from_corner      db  0x0
  reposition                 db  0x0
  latest_window_touch        dd  0x0
  latest_window_touch_delta  dd  0x0
 
  do_resize db 0x0
 
  oldc    dd 0x0,0x0,0x0,0x0
 
  dlx     dd 0x0
  dly     dd 0x0
  dlxe    dd 0x0
  dlye    dd 0x0
 
  npx     dd 0x0
  npy     dd 0x0
  npxe    dd 0x0
  npye    dd 0x0
 
  mpx     dd 0x0
  mpy     dd 0x0
endg
 
 
; draw negative window frames
drawwindowframes2:
        pushad
        cli
        jmp     drawwindowframes.do
drawwindowframes:
        pushad
        cli
 
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     .ret
        mov     eax, [npx]
        cmp     eax, [edi+WDATA.box.left]
        jnz     .nowndframe
        mov     eax, [npxe]
        cmp     eax, [edi+WDATA.box.width]
        jnz     .nowndframe
        mov     eax, [npy]
        cmp     eax, [edi+WDATA.box.top]
        jnz     .nowndframe
        mov     eax, [npye]
        cmp     eax, [edi+WDATA.box.height]
        jnz     .nowndframe
        xor     [edi+WDATA.fl_wdrawn], 2
        test    [edi+WDATA.fl_wdrawn], 4
        jnz     .ret
 
.nowndframe:
.do:
        mov     edi, 1
        mov     ecx, 0x01000000
        mov   eax,[npx]
        shl   eax,16
        add   eax,[npx]
        add   eax,[npxe]
        add   eax,65536*1-1
        mov   ebx,[npy]
        shl   ebx,16
        add   ebx,[npy]
        call  [draw_line]
 
        mov   eax,[npx]
        shl   eax,16
        add   eax,[npx]
        add   eax,[npxe]
        add   eax,65536*1-1
        mov   ebx,[npy]
        add   ebx,[npye]
        shl   ebx,16
        add   ebx,[npy]
        add   ebx,[npye]
        call  [draw_line]
 
        mov   eax,[npx]
        shl   eax,16
        add   eax,[npx]
        mov   ebx,[npy]
        shl   ebx,16
        add   ebx,[npy]
        add   ebx,[npye]
        call  [draw_line]
 
        mov   eax,[npx]
        add   eax,[npxe]
        shl   eax,16
        add   eax,[npx]
        add   eax,[npxe]
        mov   ebx,[npy]
        shl   ebx,16
        add   ebx,[npy]
        add   ebx,[npye]
        call  [draw_line]
 
.ret:
        sti
        popad
        ret
 
 
 
random_shaped_window:
 
;
;  eax = 0    giving address of data area
;      ebx    address
;  eax = 1    shape area scale
;      ebx    2^ebx scale
 
     test eax, eax
     jne  rsw_no_address
     mov  eax,[0x3000]
     shl  eax,8
 
     mov  [eax+0x80000+APPDATA.wnd_shape],ebx
   rsw_no_address:
 
     cmp  eax,1
     jne  rsw_no_scale
     mov  eax,[0x3000]
     shl  eax,8
     mov  byte [eax+0x80000+APPDATA.wnd_shape_scale], bl
   rsw_no_scale:
 
     ret

Rev 186	Rev 303
1	get_titlebar_height: ; edi = window draw_data pointer	1	get_titlebar_height: ; edi = window draw_data pointer
2	mov al,[edi+WDATA.fl_wstyle]	2	mov al,[edi+WDATA.fl_wstyle]
3	and al,0x0F	3	and al,0x0F
4	cmp al,0x03	4	cmp al,0x03
5	jne @f	5	jne @f
6	mov eax,[_skinh]	6	mov eax,[_skinh]
7	ret	7	ret
8	@@: mov eax,21	8	@@: mov eax,21
9	ret	9	ret
10		10
11	get_rolledup_height: ; edi = window draw_data pointer	11	get_rolledup_height: ; edi = window draw_data pointer
12	mov al,[edi+WDATA.fl_wstyle]	12	mov al,[edi+WDATA.fl_wstyle]
13	and al,0x0F	13	and al,0x0F
14	cmp al,0x03	14	cmp al,0x03
15	jne @f	15	jne @f
16	mov eax,[_skinh]	16	mov eax,[_skinh]
17	add eax,3	17	add eax,3
18	ret	18	ret
19	@@: or al,al	19	@@: or al,al
20	jnz @f	20	jnz @f
21	mov eax,21	21	mov eax,21
22	ret	22	ret
23	@@: mov eax,21+2	23	@@: mov eax,21+2
24	ret	24	ret
25		25
26		26
27	setwindowdefaults:	27	setwindowdefaults:
28	pushad	28	pushad
29		29
30	xor eax,eax	30	xor eax,eax
31	mov ecx,0xc000	31	mov ecx,0xc000
32	@@:	32	@@:
33	inc eax	33	inc eax
34	add ecx,2	34	add ecx,2
35	mov [ecx+0x000],ax ; process no	35	mov [ecx+0x000],ax ; process no
36	mov [ecx+0x400],ax ; positions in stack	36	mov [ecx+0x400],ax ; positions in stack
37	cmp ecx,0xc400-2 ; the more high, the more surface	37	cmp ecx,0xc400-2 ; the more high, the more surface
38	jnz @b	38	jnz @b
39		39
40	popad	40	popad
41	ret	41	ret
42		42
43		43
44		44
45	; eax = cx	45	; eax = cx
46	; ebx = cy	46	; ebx = cy
47	; ecx = ex	47	; ecx = ex
48	; edx = ey	48	; edx = ey
49	; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,	49	; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,
50	; è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü	50	; è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü
51	; ÷àñòåé îêîí âûçâàòü setscreen	51	; ÷àñòåé îêîí âûçâàòü setscreen
52	align 4	52	align 4
53	calculatescreen:	53	calculatescreen:
54	pushad	54	pushad
55	pushfd	55	pushfd
56	cli	56	cli
57		57
58	push edx ecx ebx eax	58	push edx ecx ebx eax
59		59
60	mov esi, 1	60	mov esi, 1
61	call setscreen	61	call setscreen
62		62
63	mov ebp, [0x3004] ; number of processes	63	mov ebp, [0x3004] ; number of processes
64	cmp ebp, 1	64	cmp ebp, 1
65	jbe .finish	65	jbe .finish
66	align 4	66	align 4
67	.new_wnd:	67	.new_wnd:
68	movzx edi, word [0xC400 + esi * 2]	68	movzx edi, word [0xC400 + esi * 2]
69	shl edi, 5	69	shl edi, 5
70		70
71	cmp [0x3000+edi+TASKDATA.state], byte 9	71	cmp [0x3000+edi+TASKDATA.state], byte 9
72	je .not_wnd	72	je .not_wnd
73		73
74	add edi, window_data	74	add edi, window_data
75	test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED	75	test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
76	jnz .not_wnd	76	jnz .not_wnd
77		77
78	mov eax,[edi+WDATA.box.left]	78	mov eax,[edi+WDATA.box.left]
79	cmp eax, [esp+RECT.right]	79	cmp eax, [esp+RECT.right]
80	ja .out_of_bounds	80	ja .out_of_bounds
81	mov ebx,[edi+WDATA.box.top]	81	mov ebx,[edi+WDATA.box.top]
82	cmp ebx, [esp+RECT.bottom]	82	cmp ebx, [esp+RECT.bottom]
83	ja .out_of_bounds	83	ja .out_of_bounds
84	mov ecx,[edi+WDATA.box.width]	84	mov ecx,[edi+WDATA.box.width]
85	add ecx, eax	85	add ecx, eax
86	cmp ecx, [esp+RECT.left]	86	cmp ecx, [esp+RECT.left]
87	jb .out_of_bounds	87	jb .out_of_bounds
88	mov edx,[edi+WDATA.box.height]	88	mov edx,[edi+WDATA.box.height]
89	add edx, ebx	89	add edx, ebx
90	cmp edx, [esp+RECT.top]	90	cmp edx, [esp+RECT.top]
91	jb .out_of_bounds	91	jb .out_of_bounds
92		92
93	cmp eax, [esp+RECT.left]	93	cmp eax, [esp+RECT.left]
94	jae @f	94	jae @f
95	mov eax, [esp+RECT.left]	95	mov eax, [esp+RECT.left]
96	@@:	96	@@:
97	cmp ebx, [esp+RECT.top]	97	cmp ebx, [esp+RECT.top]
98	jae @f	98	jae @f
99	mov ebx, [esp+RECT.top]	99	mov ebx, [esp+RECT.top]
100	@@:	100	@@:
101	cmp ecx, [esp+RECT.right]	101	cmp ecx, [esp+RECT.right]
102	jbe @f	102	jbe @f
103	mov ecx, [esp+RECT.right]	103	mov ecx, [esp+RECT.right]
104	@@:	104	@@:
105	cmp edx, [esp+RECT.bottom]	105	cmp edx, [esp+RECT.bottom]
106	jbe @f	106	jbe @f
107	mov edx, [esp+RECT.bottom]	107	mov edx, [esp+RECT.bottom]
108	@@:	108	@@:
109		109
110	push esi	110	push esi
111	movzx esi, word [0xC400 + esi * 2]	111	movzx esi, word [0xC400 + esi * 2]
112	call setscreen	112	call setscreen
113	pop esi	113	pop esi
114		114
115	.not_wnd:	115	.not_wnd:
116	.out_of_bounds:	116	.out_of_bounds:
117	inc esi	117	inc esi
118	dec ebp	118	dec ebp
119	jnz .new_wnd	119	jnz .new_wnd
120	.finish:	120	.finish:
121		121
122	pop eax ebx ecx edx	122	pop eax ebx ecx edx
123		123
124	popfd	124	popfd
125	popad	125	popad
126	ret	126	ret
127		127
128		128
129		129
130	virtual at esp	130	virtual at esp
131	ff_x dd ?	131	ff_x dd ?
132	ff_y dd ?	132	ff_y dd ?
133	ff_width dd ?	133	ff_width dd ?
134	ff_xsz dd ?	134	ff_xsz dd ?
135	ff_ysz dd ?	135	ff_ysz dd ?
136	ff_scale dd ?	136	ff_scale dd ?
137	end virtual	137	end virtual
138		138
139	align 4	139	align 4
140	; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà	140	; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà
141	setscreen:	141	setscreen:
142	; eax x start	142	; eax x start
143	; ebx y start	143	; ebx y start
144	; ecx x end	144	; ecx x end
145	; edx y end	145	; edx y end
146	; esi process number	146	; esi process number
147	pushad	147	pushad
148	; \begin{diamond}[29.08.2006]	148	; \begin{diamond}[29.08.2006]
149	cmp esi, 1	149	cmp esi, 1
150	jz @f	150	jz @f
151	mov edi, esi	151	mov edi, esi
152	shl edi, 5	152	shl edi, 5
153	cmp [edi+window_data+WDATA.box.width], 0	153	cmp [edi+window_data+WDATA.box.width], 0
154	jnz @f	154	jnz @f
155	cmp [edi+window_data+WDATA.box.height], 0	155	cmp [edi+window_data+WDATA.box.height], 0
156	jz .ret	156	jz .ret
157	@@:	157	@@:
158	; \end{diamond}[29.08.2006]	158	; \end{diamond}[29.08.2006]
159	mov edi, esi ;;;word [esi*2+0xc400]	159	mov edi, esi ;;;word [esi*2+0xc400]
160	shl edi, 8	160	shl edi, 8
161	add edi, 0x80000 ; address of random shaped window area	161	add edi, 0x80000 ; address of random shaped window area
162	cmp [edi+APPDATA.wnd_shape], dword 0	162	cmp [edi+APPDATA.wnd_shape], dword 0
163	jne .free_form	163	jne .free_form
164		164
165	; get x&y size	165	; get x&y size
166	sub ecx, eax	166	sub ecx, eax
167	sub edx, ebx	167	sub edx, ebx
168	inc ecx	168	inc ecx
169	inc edx	169	inc edx
170		170
171	; get WinMap start	171	; get WinMap start
172	mov edi, [0xFE00] ; screen_sx	172	mov edi, [0xFE00] ; screen_sx
173	inc edi	173	inc edi
174	imul edi, ebx	174	imul edi, ebx
175	add edi, eax	175	add edi, eax
176	add edi, WinMapAddress	176	add edi, WinMapAddress
177		177
178	.new_y:	178	.new_y:
179	push ecx ; sx	179	push ecx ; sx
180	push edx	180	push edx
181		181
182	mov edx, esi	182	mov edx, esi
183	align 4	183	align 4
184	.new_x:	184	.new_x:
185	mov byte [edi], dl	185	mov byte [edi], dl
186	inc edi	186	inc edi
187	dec ecx	187	dec ecx
188	jnz .new_x	188	jnz .new_x
189		189
190	pop edx	190	pop edx
191	pop ecx	191	pop ecx
192	add edi, [0xFE00]	192	add edi, [0xFE00]
193	inc edi	193	inc edi
194	sub edi, ecx	194	sub edi, ecx
195	dec edx	195	dec edx
196	jnz .new_y	196	jnz .new_y
197	.ret:	197	.ret:
198	popad	198	popad
199	ret	199	ret
200	.read_byte:	200	.read_byte:
201	;eax - address	201	;eax - address
202	;esi - slot	202	;esi - slot
203	push eax	203	push eax
204	push ebx	204	push ebx
205	push ecx	205	push ecx
206	push edx	206	push edx
207	mov edx,eax	207	mov edx,eax
208	mov eax,esi	208	mov eax,esi
209	lea ebx,[esp+12]	209	lea ebx,[esp+12]
210	mov ecx,1	210	mov ecx,1
211	call read_process_memory	211	call read_process_memory
212	pop edx	212	pop edx
213	pop ecx	213	pop ecx
214	pop ebx	214	pop ebx
215	pop eax	215	pop eax
216	ret	216	ret
217	.free_form:	217	.free_form:
218		218
219	; for (y=0; y <= x_size; y++)	219	; for (y=0; y <= x_size; y++)
220	; for (x=0; x <= x_size; x++)	220	; for (x=0; x <= x_size; x++)
221	; if (shape[coord(x,y,scale)]==1)	221	; if (shape[coord(x,y,scale)]==1)
222	; set_pixel(x, y, process_number);	222	; set_pixel(x, y, process_number);
223		223
224	sub ecx, eax	224	sub ecx, eax
225	sub edx, ebx	225	sub edx, ebx
226	inc ecx	226	inc ecx
227	inc edx	227	inc edx
228		228
229	push dword [edi+APPDATA.wnd_shape_scale] ; push scale first -> for loop	229	push dword [edi+APPDATA.wnd_shape_scale] ; push scale first -> for loop
230		230
231	; get WinMap start -> ebp	231	; get WinMap start -> ebp
232	push eax	232	push eax
233	mov eax, [0xFE00] ; screen_sx	233	mov eax, [0xFE00] ; screen_sx
234	inc eax	234	inc eax
235	imul eax, ebx	235	imul eax, ebx
236	add eax, [esp]	236	add eax, [esp]
237	add eax, WinMapAddress	237	add eax, WinMapAddress
238	mov ebp, eax	238	mov ebp, eax
239		239
240	mov edi, [edi+APPDATA.wnd_shape]	240	mov edi, [edi+APPDATA.wnd_shape]
241	pop eax	241	pop eax
242		242
243	; eax = x_start	243	; eax = x_start
244	; ebx = y_start	244	; ebx = y_start
245	; ecx = x_size	245	; ecx = x_size
246	; edx = y_size	246	; edx = y_size
247	; esi = process_number	247	; esi = process_number
248	; edi = &shape	248	; edi = &shape
249	; [scale]	249	; [scale]
250	push edx ecx ; for loop - x,y size	250	push edx ecx ; for loop - x,y size
251		251
252	mov ecx, esi	252	mov ecx, esi
253	shl ecx, 5	253	shl ecx, 5
254	mov edx, [window_data+ecx+WDATA.box.top]	254	mov edx, [window_data+ecx+WDATA.box.top]
255	push [window_data+ecx+WDATA.box.width] ; for loop - width	255	push [window_data+ecx+WDATA.box.width] ; for loop - width
256	mov ecx, [window_data+ecx+WDATA.box.left]	256	mov ecx, [window_data+ecx+WDATA.box.left]
257	sub ebx, edx	257	sub ebx, edx
258	sub eax, ecx	258	sub eax, ecx
259	push ebx eax ; for loop - x,y	259	push ebx eax ; for loop - x,y
260		260
261	add [ff_xsz], eax	261	add [ff_xsz], eax
262	add [ff_ysz], ebx	262	add [ff_ysz], ebx
263		263
264	mov ebx, [ff_y]	264	mov ebx, [ff_y]
265		265
266	.ff_new_y:	266	.ff_new_y:
267	mov edx, [ff_x]	267	mov edx, [ff_x]
268		268
269	.ff_new_x:	269	.ff_new_x:
270	; -- body --	270	; -- body --
271	mov ecx, [ff_scale]	271	mov ecx, [ff_scale]
272	mov eax, [ff_width]	272	mov eax, [ff_width]
273	inc eax	273	inc eax
274	shr eax, cl	274	shr eax, cl
275	push ebx edx	275	push ebx edx
276	shr ebx, cl	276	shr ebx, cl
277	shr edx, cl	277	shr edx, cl
278	imul eax, ebx	278	imul eax, ebx
279	add eax, edx	279	add eax, edx
280	pop edx ebx	280	pop edx ebx
281	add eax, edi	281	add eax, edi
282	call .read_byte	282	call .read_byte
283	test al,al	283	test al,al
284	jz @f	284	jz @f
285	mov eax, esi	285	mov eax, esi
286	mov [ebp], al	286	mov [ebp], al
287	@@:	287	@@:
288	; -- end body --	288	; -- end body --
289	inc ebp	289	inc ebp
290	inc edx	290	inc edx
291	cmp edx, [ff_xsz]	291	cmp edx, [ff_xsz]
292	jb .ff_new_x	292	jb .ff_new_x
293	sub ebp, [ff_xsz]	293	sub ebp, [ff_xsz]
294	add ebp, [ff_x]	294	add ebp, [ff_x]
295	add ebp, [0xFE00] ; screen.x	295	add ebp, [0xFE00] ; screen.x
296	inc ebp	296	inc ebp
297	inc ebx	297	inc ebx
298	cmp ebx, [ff_ysz]	298	cmp ebx, [ff_ysz]
299	jb .ff_new_y	299	jb .ff_new_y
300		300
301	add esp, 24	301	add esp, 24
302	popad	302	popad
303	ret	303	ret
304		304
305		305
306	display_settings:	306	display_settings:
307		307
308	; eax = 0 ; DISPLAY redraw	308	; eax = 0 ; DISPLAY redraw
309	; ebx = 0 ; all	309	; ebx = 0 ; all
310	;	310	;
311	; eax = 1 ; BUTTON type	311	; eax = 1 ; BUTTON type
312	; ebx = 0 ; flat	312	; ebx = 0 ; flat
313	; ebx = 1 ; 3D	313	; ebx = 1 ; 3D
314	; eax = 2 ; set WINDOW colours	314	; eax = 2 ; set WINDOW colours
315	; ebx = pointer to table	315	; ebx = pointer to table
316	; ecx = number of bytes define	316	; ecx = number of bytes define
317	; eax = 3 ; get WINDOW colours	317	; eax = 3 ; get WINDOW colours
318	; ebx = pointer to table	318	; ebx = pointer to table
319	; ecx = number of bytes wanted	319	; ecx = number of bytes wanted
320	; eax = 4 ; get skin height	320	; eax = 4 ; get skin height
321	; input : nothing	321	; input : nothing
322	; output : eax = skin height in pixel	322	; output : eax = skin height in pixel
323	; eax = 5 ; get screen workarea	323	; eax = 5 ; get screen workarea
324	; input : nothing	324	; input : nothing
325	; output : eax = [left]*65536+[right]	325	; output : eax = [left]*65536+[right]
326	; ebx = [top]*65536+[bottom]	326	; ebx = [top]*65536+[bottom]
327	; eax = 6 ; set screen workarea	327	; eax = 6 ; set screen workarea
328	; input : ecx = [left]*65536+[right]	328	; input : ecx = [left]*65536+[right]
329	; edx = [top]*65536+[bottom]	329	; edx = [top]*65536+[bottom]
330	; output : nothing	330	; output : nothing
331	; eax = 7 ; get skin margins	331	; eax = 7 ; get skin margins
332	; input : nothing	332	; input : nothing
333	; output : eax = [left]*65536+[right]	333	; output : eax = [left]*65536+[right]
334	; ebx = [top]*65536+[bottom]	334	; ebx = [top]*65536+[bottom]
335	; eax = 8 ; set window skin	335	; eax = 8 ; set window skin
336	; input : ecx = pointer to file info block	336	; input : ecx = pointer to file info block
337	; output : eax = FS error code	337	; output : eax = FS error code
338		338
339		339
340	pushad	340	pushad
341		341
342	test eax, eax ; redraw display	342	test eax, eax ; redraw display
343	jnz dspl0	343	jnz dspl0
344	test ebx, ebx	344	test ebx, ebx
345	jnz dspl0	345	jnz dspl0
346	cmp [windowtypechanged],dword 1	346	cmp [windowtypechanged],dword 1
347	jne dspl00	347	jne dspl00
348	mov [windowtypechanged],dword 0	348	mov [windowtypechanged],dword 0
349	redraw_screen_direct:	349	redraw_screen_direct:
350	mov [dlx],dword 0	350	mov [dlx],dword 0
351	mov [dly],dword 0	351	mov [dly],dword 0
352	mov eax,[0xfe00]	352	mov eax,[0xfe00]
353	mov [dlxe],eax	353	mov [dlxe],eax
354	mov eax,[0xfe04]	354	mov eax,[0xfe04]
355	mov [dlye],eax	355	mov [dlye],eax
356	mov eax,window_data	356	mov eax,window_data
357	call redrawscreen	357	call redrawscreen
358	dspl00:	358	dspl00:
359	popad	359	popad
360	ret	360	ret
361	dspl0:	361	dspl0:
362		362
363	cmp eax,1 ; button type	363	cmp eax,1 ; button type
364	jne dspl1	364	jne dspl1
365	and ebx,1	365	and ebx,1
366	cmp ebx,[buttontype]	366	cmp ebx,[buttontype]
367	je dspl9	367	je dspl9
368	mov [buttontype],ebx	368	mov [buttontype],ebx
369	mov [windowtypechanged],dword 1	369	mov [windowtypechanged],dword 1
370	dspl9:	370	dspl9:
371	popad	371	popad
372	ret	372	ret
373	dspl1:	373	dspl1:
374		374
375	cmp eax,2 ; set common window colours	375	cmp eax,2 ; set common window colours
376	jne no_com_colours	376	jne no_com_colours
377	mov [windowtypechanged],dword 1	377	mov [windowtypechanged],dword 1
378	mov esi,[0x3010]	378	mov esi,[0x3010]
379	add esi,TASKDATA.mem_start	379	add esi,TASKDATA.mem_start
380	add ebx,[esi]	380	add ebx,[esi]
381	mov esi,ebx	381	mov esi,ebx
382	mov edi,common_colours	382	mov edi,common_colours
383	and ecx,127	383	and ecx,127
384	cld	384	cld
385	rep movsb	385	rep movsb
386	popad	386	popad
387	ret	387	ret
388	no_com_colours:	388	no_com_colours:
389		389
390	cmp eax,3 ; get common window colours	390	cmp eax,3 ; get common window colours
391	jne no_get_com	391	jne no_get_com
392	mov esi,[0x3010]	392	mov esi,[0x3010]
393	add esi,TASKDATA.mem_start	393	add esi,TASKDATA.mem_start
394	add ebx,[esi]	394	add ebx,[esi]
395	mov edi,ebx	395	mov edi,ebx
396	mov esi,common_colours	396	mov esi,common_colours
397	and ecx,127	397	and ecx,127
398	cld	398	cld
399	rep movsb	399	rep movsb
400	popad	400	popad
401	ret	401	ret
402	no_get_com:	402	no_get_com:
403		403
404	cmp eax,4 ; get skin height	404	cmp eax,4 ; get skin height
405	jne no_skin_height	405	jne no_skin_height
406	popad	406	popad
407	mov eax,[_skinh]	407	mov eax,[_skinh]
408	mov [esp+36],eax	408	mov [esp+36],eax
409	ret	409	ret
410	no_skin_height:	410	no_skin_height:
411		411
412	cmp eax,5 ; get screen workarea	412	cmp eax,5 ; get screen workarea
413	jne no_get_workarea	413	jne no_get_workarea
414	popad	414	popad
415	mov eax,[screen_workarea.left-2]	415	mov eax,[screen_workarea.left-2]
416	mov ax,word[screen_workarea.right]	416	mov ax,word[screen_workarea.right]
417	mov [esp+36],eax	417	mov [esp+36],eax
418	mov eax,[screen_workarea.top-2]	418	mov eax,[screen_workarea.top-2]
419	mov ax,word[screen_workarea.bottom]	419	mov ax,word[screen_workarea.bottom]
420	mov [esp+24],eax	420	mov [esp+24],eax
421	ret	421	ret
422	no_get_workarea:	422	no_get_workarea:
423		423
424	cmp eax,6 ; set screen workarea	424	cmp eax,6 ; set screen workarea
425	jne no_set_workarea	425	jne no_set_workarea
426	movsx eax,word[esp+16+2]	426	movsx eax,word[esp+16+2]
427	movsx ebx,word[esp+16]	427	movsx ebx,word[esp+16]
428	cmp eax,ebx	428	cmp eax,ebx
429	jge .lp1	429	jge .lp1
430	or eax,eax;[0xFE00]	430	or eax,eax;[0xFE00]
431	jl @f	431	jl @f
432	mov [screen_workarea.left],eax	432	mov [screen_workarea.left],eax
433	@@: cmp ebx,[0xFE00]	433	@@: cmp ebx,[0xFE00]
434	jg .lp1	434	jg .lp1
435	mov [screen_workarea.right],ebx	435	mov [screen_workarea.right],ebx
436	.lp1: movsx eax,word[esp+24+2]	436	.lp1: movsx eax,word[esp+24+2]
437	movsx ebx,word[esp+24]	437	movsx ebx,word[esp+24]
438	cmp eax,ebx	438	cmp eax,ebx
439	jge .lp2	439	jge .lp2
440	or eax,eax;[0xFE04]	440	or eax,eax;[0xFE04]
441	jl @f	441	jl @f
442	mov [screen_workarea.top],eax	442	mov [screen_workarea.top],eax
443	@@: cmp ebx,[0xFE04]	443	@@: cmp ebx,[0xFE04]
444	jg .lp2	444	jg .lp2
445	mov [screen_workarea.bottom],ebx	445	mov [screen_workarea.bottom],ebx
446	.lp2: call repos_windows	446	.lp2: call repos_windows
447	mov eax, 0	447	mov eax, 0
448	mov ebx, 0	448	mov ebx, 0
449	mov ecx, [0xfe00]	449	mov ecx, [0xfe00]
450	mov edx, [0xfe04]	450	mov edx, [0xfe04]
451	call calculatescreen	451	call calculatescreen
452	; jmp redraw_screen_direct	452	; jmp redraw_screen_direct
453	.exit:	453	.exit:
454	popad	454	popad
455	ret	455	ret
456	no_set_workarea:	456	no_set_workarea:
457		457
458	cmp eax,7 ; get skin margins	458	cmp eax,7 ; get skin margins
459	jne no_get_skinmargins	459	jne no_get_skinmargins
460	popad	460	popad
461	mov eax,dword[_skinmargins+0]	461	mov eax,dword[_skinmargins+0]
462	mov [esp+36],eax	462	mov [esp+36],eax
463	mov eax,dword[_skinmargins+4]	463	mov eax,dword[_skinmargins+4]
464	mov [esp+24],eax	464	mov [esp+24],eax
465	ret	465	ret
466	no_get_skinmargins:	466	no_get_skinmargins:
467		467
468	cmp eax,8 ; set window skin	468	cmp eax,8 ; set window skin
469	jne no_set_skin	469	jne no_set_skin
470	mov eax,ebx	470	mov eax,ebx
471	mov edi,[0x3010]	471	mov edi,[0x3010]
472	add ebx,[edi+TASKDATA.mem_start] ; abs start of info block	472	add ebx,[edi+TASKDATA.mem_start] ; abs start of info block
473	pushd [ebx+0] [ebx+4] [ebx+8] [ebx+12]	473	pushd [ebx+0] [ebx+4] [ebx+8] [ebx+12]
474	mov dword[ebx+0],0 ; read	474	mov dword[ebx+0],0 ; read
475	mov dword[ebx+4],0 ; from the beginning	475	mov dword[ebx+4],0 ; from the beginning
476	mov dword[ebx+8],64 ; 32 KBytes maximum	476	mov dword[ebx+8],64 ; 32 KBytes maximum
477	mov ecx,skin_data+64*512	477	mov ecx,skin_data+64*512
478	sub ecx,[edi+0x10]	478	sub ecx,[edi+0x10]
479	mov dword[ebx+12],ecx ; destination	479	mov dword[ebx+12],ecx ; destination
480	push eax	480	push eax
481	pushad	481	pushad
482	call file_system	482	call file_system
483	popad	483	popad
484	pop eax	484	pop eax
485	popd [ebx+12] [ebx+8] [ebx+4] [ebx+0]	485	popd [ebx+12] [ebx+8] [ebx+4] [ebx+0]
486	cmp eax,ERROR_SUCCESS	486	cmp eax,ERROR_SUCCESS
487	je @f	487	je @f
488	cmp eax,ERROR_END_OF_FILE	488	cmp eax,ERROR_END_OF_FILE
489	jne .exit	489	jne .exit
490	@@: cmp [skin_data+64*512+SKIN_HEADER.ident],'SKIN'	490	@@: cmp [skin_data+64*512+SKIN_HEADER.ident],'SKIN'
491	mov eax,ERROR_UNKNOWN_FS	491	mov eax,ERROR_UNKNOWN_FS
492	jne .exit	492	jne .exit
493	mov esi,skin_data+64*512	493	mov esi,skin_data+64*512
494	mov edi,skin_data	494	mov edi,skin_data
495	mov ecx,(64*512)/4	495	mov ecx,(64*512)/4
496	rep movsd	496	rep movsd
497	call parse_skin_data	497	call parse_skin_data
498	pushad	498	pushad
499	mov eax, 0	499	mov eax, 0
500	mov ebx, 0	500	mov ebx, 0

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 186 → 303