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+0xa], byte 9
        je      .not_wnd
 
        add     edi, window_data
        test    [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .not_wnd
 
        mov     eax, [edi+WDATA.left]
        cmp     eax, [esp+RECT.right]
        ja      .out_of_bounds
        mov     ebx, [edi+WDATA.top]
        cmp     ebx, [esp+RECT.bottom]
        ja      .out_of_bounds
        mov     ecx, [edi+WDATA.width]
        add     ecx, eax
        cmp     ecx, [esp+RECT.left]
        jb      .out_of_bounds
        mov     edx, [edi+WDATA.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
        mov edi, esi ;;;word [esi*2+0xc400]
        shl   edi, 8
        add   edi, 0x80000+0x80  ; address of random shaped window area
        cmp   [edi], 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
 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+4]  ; 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]
 
 
 
        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.top]
        push [window_data+ecx+WDATA.width]      ; for loop - width
        mov  ecx, [window_data+ecx+WDATA.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,0x10
     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,0x10
     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+0x10]        ; 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     esi,0x20*2
	mov	byte[0x0000fff0],1
        dec     ecx
        jge	@f
        ret
    @@: mov	[esi+WDATA.fl_redraw],1
	test    [esi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jz      .lp2
        mov     eax,[screen_workarea.left]
        mov     [esi+WDATA.left],eax
        sub     eax,[screen_workarea.right]
        neg     eax
        mov     [esi+WDATA.width],eax
        mov     eax,[screen_workarea.top]
        mov     [esi+WDATA.top],eax
        test    [esi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     .lp1
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [esi+WDATA.height],eax
  .lp1: add     esi,0x20
        loop    @b
        ret
  .lp2: mov	eax,[esi+WDATA.left]
	add	eax,[esi+WDATA.width]
	mov	ebx,[0x0000fe00]
;	inc	ebx
	cmp	eax,ebx
	jle	.lp4
	mov	eax,[esi+WDATA.width]
	sub	eax,ebx
	jle	.lp3
	mov	[esi+WDATA.width],ebx
  .lp3: sub	ebx,[esi+WDATA.width]
	mov	[esi+WDATA.left],ebx
  .lp4: mov	eax,[esi+WDATA.top]
	add	eax,[esi+WDATA.height]
	mov	ebx,[0x0000fe04]
;	inc	ebx
	cmp	eax,ebx
	jle	.lp6
	mov	eax,[esi+WDATA.height]
	sub	eax,ebx
	jle	.lp5
	mov	[esi+WDATA.height],ebx
  .lp5: sub	ebx,[esi+WDATA.height]
	mov	[esi+WDATA.top],ebx
  .lp6: add     esi,0x20
        loop    @b
	ret
 
uglobal
  common_colours:
     times 128 db 0x0
endg
 
 
 
 
check_window_position:
 
    pushad                           ; window inside screen ?
 
    movzx eax,word [edi+0]
    movzx ebx,word [edi+4]
    movzx ecx,word [edi+8]
    movzx edx,word [edi+12]
 
    mov   esi,ecx             ; check x pos
    add   esi,eax
    cmp   esi,[0xfe00]
    jbe   x_pos_ok
    mov   [edi+0],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+4],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+8],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+12],edx
  y_size_ok:
 
    popad
 
    ret
 
 
uglobal
  new_window_starting dd 0
endg
 
 
sys_window_mouse:
 
    push  eax
 
    mov   eax,[timer_ticks] ;[0xfdf0]
    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:
 
        pushad
 
        mov   esi,[edx+24]   ; rectangle
        mov   eax,[edx+0]
        shl   eax,16
        add   eax,[edx+0]
        add   eax,[edx+8]
        mov   ebx,[edx+04]
        shl   ebx,16
        add   ebx,[edx+4]
        add   ebx,[edx+12]
        call  draw_rectangle
 
        mov   ecx,[edx+20]   ; grab bar
        push  ecx
        mov   esi,edx
        mov   edx,[esi+04]
        add   edx,1
        mov   ebx,[esi+04]
        add   ebx,25
        mov   eax,[esi+04]
        add   eax,[esi+12]
        cmp   ebx,eax
        jb    wdsizeok
        mov   ebx,eax
      wdsizeok:
        push  ebx
      drwi:
        mov   ebx,edx
        shl   ebx,16
        add   ebx,edx
        mov   eax,[esi+00]
        inc   eax
        shl   eax,16
        add   eax,[esi+00]
        add   eax,[esi+8]
        sub   eax,1
        push  edx
        mov   edx,0x80000000
        mov   ecx,[esi+20]
        and   ecx,edx
        cmp   ecx,edx
        jnz   nofa
        mov   ecx,[esi+20]
        sub   ecx,0x00040404
        mov   [esi+20],ecx
        and   ecx,0x00ffffff
        jmp   faj
      nofa:
        mov   ecx,[esi+20]
        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+20],ecx
 
        mov   edx,[esi+04]      ; inside work area
        add   edx,21+5
        mov   ebx,[esi+04]
        add   ebx,[esi+12]
        cmp   edx,ebx
        jg    noinside
        mov   eax,1
        mov   ebx,21
        mov   ecx,[esi+8]
        mov   edx,[esi+12]
        mov   edi,[esi+16]
        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:
 
        pushad
 
        mov   edi,edx                              ; RECTANGLE
        mov   eax,[edi+0]
        shl   eax,16
        mov   ax,[edi+0]
        add   ax,[edi+8]
        mov   ebx,[edi+4]
        shl   ebx,16
        mov   bx,[edi+4]
        add   bx,[edi+12]
        mov   esi,[edi+24]
        shr   esi,1
        and   esi,0x007f7f7f
        push  esi
        call  draw_rectangle
        mov   ecx,3
      dw3l:
        add   eax,1*65536-1
        add   ebx,1*65536-1
        mov   esi,[edi+24]
        call  draw_rectangle
        dec   ecx
        jnz   dw3l
        pop   esi
        add   eax,1*65536-1
        add   ebx,1*65536-1
        call  draw_rectangle
 
        mov   ecx,[edx+20]                       ; GRAB BAR
        push  ecx
        mov   esi,edx
        mov   edx,[esi+04]
        add   edx,4
        mov   ebx,[esi+04]
        add   ebx,20
        mov   eax,[esi+04]
        add   eax,[esi+12]
        cmp   ebx,eax
        jb    wdsizeok2
        mov   ebx,eax
      wdsizeok2:
        push  ebx
      drwi2:
        mov   ebx,edx
        shl   ebx,16
        add   ebx,edx
        mov   eax,[esi+00]
        shl   eax,16
        add   eax,[esi+00]
        add   eax,[esi+8]
        add   eax,4*65536-4
        mov   ecx,[esi+20]
        test  ecx,0x40000000
        jz    nofa3
        add   ecx,0x040404
      nofa3:
        test  ecx,0x80000000
        jz    nofa2
        sub   ecx,0x040404
      nofa2:
        mov   [esi+20],ecx
        and   ecx,0xffffff
        xor   edi, edi
        call  [draw_line]
        inc   edx
        cmp   edx,[esp]
        jb    drwi2
        add   esp,4
        pop   ecx
        mov   [esi+20],ecx
 
        mov   edx,[esi+04]                       ; WORK AREA
        add   edx,21+5
        mov   ebx,[esi+04]
        add   ebx,[esi+12]
        cmp   edx,ebx
        jg    noinside2
        mov   eax,5
        mov   ebx,20
        mov   ecx,[esi+8]
        mov   edx,[esi+12]
        sub   ecx,4
        sub   edx,4
        mov   edi,[esi+16]
        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 + 0xa], byte 9
        je    .new_check                    ; skip dead windows
 
        lea   esi, [eax+window_data]
 
        mov   ebx, [edi+4]  ; y0
        mov   edx, [edi+12]
        add   edx, ebx      ; y0e
 
        mov   ecx, [esi+4]  ; y  ; y check
        cmp   ecx, edx      
        jae   .new_check     ; y < y0e
        mov   eax, [esi+12]
        add   ecx, eax       ; ye
        cmp   ebx, ecx       ; y0 >= ye
        ja    .new_check
 
        mov   eax, [edi+0]   ; x0
        mov   ecx, [edi+8]
        add   ecx, eax       ; x0e
 
        mov   edx, [esi+0]   ; x ; x check
        cmp   edx, ecx
        jae   .new_check     ; x < x0e
        mov   ecx, [esi+8]
        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+00] ; cx
        mov   ebx, [esi+04] ; cy
        mov   ecx, [esi+08] ; sx
        mov   edx, [esi+12] ; 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+31],byte 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.left]
        mov   [dlx], eax
        mov   ecx, eax
        add   ecx, [edi+WDATA.width]
        mov   [dlxe], ecx
        mov   ebx, [edi+WDATA.top]
        mov   [dly], ebx
        mov   edx, ebx
        add   edx, [edi+WDATA.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.left]
        mov   ebx, [edi+WDATA.top]
        mov   ecx, eax
        mov   edx, ebx
        add   ecx, [edi+WDATA.width]
        add   edx, [edi+WDATA.height]
        call  setscreen
        jmp   .done
.no_uppermost:
        mov   eax, [edi+WDATA.left]
        mov   ebx, [edi+WDATA.top]
        mov   ecx, eax
        mov   edx, ebx
        add   ecx, [edi+WDATA.width]
        add   edx, [edi+WDATA.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+0]
        mov   edx, [edi+4]
 
        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+8]
        add   edx, [edi+12]
        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+0x14]
        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+0x10]
        and   edx, 0x0f000000
        cmp   edx, 0x02000000
        jb    .no_resize_2 ; not type 2 wnd
 
        mov   edx, [edi+4]
        add   edx, [edi+12]
        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+4]
        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+0]
        mov   edx, [edi+4]
 
        push  eax ecx edx
        mov   [dlx], ecx      ; save for drawlimits
        mov   [dly], edx
        mov   eax, [edi+8]
        add   ecx, eax
        mov   eax, [edi+12]
        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+0]
        mov   [npx],eax
        mov   eax,[edi+4]
        mov   [npy],eax
        popad
 
        push eax                  ; save old coordinates
        mov   ax,[edi+00]
        mov   word [oldc+00],ax
        mov   ax,[edi+04]
        mov   word [oldc+04],ax
        mov   ax,[edi+8]
        mov   word [oldc+8],ax
        mov   word [npxe],ax
        mov   ax,[edi+12]
        mov   word [oldc+12],ax
        mov   word [npye],ax
        pop eax
 
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        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  checkEgaCga
 
        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
 
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        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+
 
        movzx eax,word [0xfb0a]
        cmp   eax,[edi+0]
        jb    nnepx
        sub   eax,[edi+0]
        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+4]
        jb    nnepy
        sub   eax,[edi+4]
        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
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        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+0],eax
        mov   eax,[npy]
        mov   [edi+4],eax
        mov   eax,[npxe]
        mov   [edi+8],eax
        mov   eax,[npye]
        mov   [edi+12],eax
 
    @@: 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+0x90
        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+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.height],eax
 
      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.left],eax
        sub     eax,[screen_workarea.right]
        neg     eax
        mov     [edi+WDATA.width],eax
        mov     eax,[screen_workarea.top]
        mov     [edi+WDATA.top],eax
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     @f
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [edi+WDATA.height],eax
    @@:
        jmp   no_fullscreen_restore
      restore_from_fullscreen:
        and     [edi+WDATA.fl_wstate],not WSTATE_MAXIMIZED
        push    [edi+WDATA.height]
        push  edi                         ; restore
        lea   esi, [edx + 0x90]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
        pop     eax
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jz      @f
        mov     [edi+WDATA.height],eax
    @@:
 
      no_fullscreen_restore:
 
        mov   eax,[edi+4]                 ; check Y inside screen
        add   eax,[edi+12]
        cmp   eax,[0xfe04]
        jbe   no_window_sizing
        mov   eax,[edi+0]                 ; check X inside screen
        add   eax,[edi+8]
        cmp   eax,[0xfe00]
        jbe   no_window_sizing
        mov   eax,[0xfe00]
        sub   eax,[edi+8]
        mov   [edi+0],eax
        mov   eax,[0xfe04]
        sub   eax,[edi+12]
        mov   [edi+4],eax
      no_window_sizing:
 
        popad
 
        cmp   [reposition],0
        je    retwm
 
 
        mov   [0xfff5],byte 1 ; no mouse
 
 
        push  eax ebx ecx edx
        mov   eax,[edi+00]
        mov   ebx,[edi+04]
        mov   ecx,[edi+8]
        mov   edx,[edi+12]
        add   ecx,eax
        add   edx,ebx
        call  calculatescreen
 
        mov   eax,[oldc+00]
        mov   ebx,[oldc+04]
        mov   ecx,[oldc+8]
        mov   edx,[oldc+12]
        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
 
drawwindowframes:
 
        pushad
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        mov   eax,[npx]
        shl   eax,16
        add   eax,[npx]
        mov   ebx,[npy]
        shl   ebx,16
        add   ebx,[npy]
        add   ebx,[npye]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        mov   edi,[0x3000]
        shl   edi,5
        add   edi,window_data
        mov   [edi+30],byte 1
        pop   edi
 
        popad
 
        ret
 
 
 
random_shaped_window:
 
;
;  eax = 0    giving address of data area
;      ebx    address
;  ebx = 1    shape area scale
;      ebx    2^ebx scale
 
     test eax, eax
     jne  rsw_no_address
     mov  eax,[0x3000]
     shl  eax,8
 
     mov  [eax+0x80000+0x80],ebx
   rsw_no_address:
 
     cmp  eax,1
     jne  rsw_no_scale
     mov  eax,[0x3000]
     shl  eax,8
     mov  [eax+0x80000+0x84],bl
   rsw_no_scale:
 
     ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 105 → 112