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


$Revision: 549 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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,WIN_STACK
       @@:
	inc   eax
	add   ecx,2
	mov   [ecx+0x000],ax	      ; process no
	mov   [ecx+0x400],ax	      ; positions in stack
	cmp   ecx,WIN_POS-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, [TASK_COUNT]	 ; number of processes
	cmp	ebp, 1
	jbe	.finish
	align 4
      .new_wnd:
	movzx	edi, word [WIN_POS + esi * 2]
	shl	edi, 5
 
	cmp	[CURRENT_TASK+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 [WIN_POS + 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+WIN_POS]
	shl   edi, 8
	add   edi, SLOT_BASE  ; 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, [ScreenWidth] ; 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, [ScreenWidth]
	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, [ScreenWidth] ; 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, [ScreenWidth]  ; 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,[ScreenWidth]
     mov  [dlxe],eax
     mov  eax,[ScreenHeight]
     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,[TASK_BASE]
     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,[TASK_BASE]
     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;[ScreenWidth]
	jl	@f
	mov	[screen_workarea.left],eax
    @@: cmp	ebx,[ScreenWidth]
	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,[ScreenHeight]
	jg	.lp2
	mov	[screen_workarea.bottom],ebx
  .lp2: call	repos_windows
	mov	eax, 0
	mov	ebx, 0
	mov	ecx, [ScreenWidth]
	mov	edx, [ScreenHeight]
    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
        call    read_skin_file
        mov     [esp+32+36], eax
        test    eax, eax
        jnz     .ret
        xor     eax, eax
        xor     ebx, ebx
        mov     ecx, [ScreenWidth]
        mov     edx, [ScreenHeight]
        call    calculatescreen
	jmp	redraw_screen_direct
.ret:
        popad
        ret
   no_set_skin:
 
     popad
     ret
 
 
repos_windows:
	mov	ecx,[TASK_COUNT]
	mov	edi, OS_BASE+0x20*2
    mov    byte[REDRAW_BACKGROUND],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,[ScreenWidth]
;    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	[edi+WDATA.box.left],ebx
  .lp4: mov	eax,[edi+WDATA.box.top]
	add	eax,[edi+WDATA.box.height]
    mov    ebx,[ScreenHeight]
;    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,[ScreenWidth]
    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,[ScreenHeight]
    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,[ScreenWidth]
    jbe   x_size_ok
    mov   ecx,[ScreenWidth]
    mov   [edi+WDATA.box.width],ecx
  x_size_ok:
 
    mov   esi,edx	      ; check y size
    add   esi,ebx
    cmp   esi,[ScreenHeight]
    jbe   y_size_ok
    mov   edx,[ScreenHeight]
    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   [MOUSE_BACKGROUND],byte 0  ; no mouse background
    mov   [DONT_DRAW_MOUSE],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, [TASK_COUNT]
	movzx eax, word [WIN_POS + eax*2]
	shl   eax, 5
	add   eax, window_data
	mov   ebx, [eax + WDATA.cl_workarea]
	and   ebx, 0x0f000000
	cmp   ebx, 0x03000000
	je   .set_WDATA_fl_redraw   ; for 3 and 4 style
	cmp   ebx, 0x04000000
	je   .set_WDATA_fl_redraw
	jmp @f
	.set_WDATA_fl_redraw:
	mov   [eax + WDATA.fl_redraw], byte 1
     @@:
 
	push   esi
      movzx   eax, word [esi] ; ax <- process no
      movzx   eax, word [WIN_STACK+eax*2] ; ax <- position in window stack
 
	xor   esi, esi	      ; drop others
      waloop:
	cmp   esi, dword [TASK_COUNT]
	jae   wacont
	inc   esi
	lea   edi, [WIN_STACK + 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, [TASK_COUNT]	; number of processes
	mov   [WIN_STACK+eax*2], bx	; this is the last (and the upper)
 
	; update on screen -window stack
	xor   esi, esi
      waloop2:
	mov   edi, [TASK_COUNT]
	cmp   esi, edi
	jae   wacont2
	inc   esi
	movzx ebx, word [esi*2 + WIN_STACK]
	mov   [ebx*2 + WIN_POS], si
	jmp   waloop2
      wacont2:
	mov   [KEY_COUNT], byte 0	      ; empty keyboard buffer
	mov   [BTN_COUNT], byte 0	      ; empty button buffer
	mov   [MOUSE_SCROLL_H], word 0  ; zero mouse z-index
	mov   [MOUSE_SCROLL_V], word 0  ; zero mouse z-index
	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
	cmp   eax, 0x04000000
	je    .return_yes      ; window type 4
 
	mov   esi, edi
	sub   esi, window_data
	shr   esi, 5
 
	; esi = process number
 
	movzx eax, word [WIN_STACK + esi * 2] ; get value of the curr process
	lea   esi, [WIN_POS + eax * 2]	    ; get address of this process at 0xC400
 
	push  esi
 
      .new_check:
 
	pop   esi
	add   esi, 2
	push  esi
 
	mov   eax, [TASK_COUNT]
	lea   eax, word [WIN_POS + eax * 2] ; number of the upper window
 
	cmp   esi, eax
	ja    .all_wnds_to_top
 
	movzx eax, word [esi]
	shl   eax, 5
	cmp   [CURRENT_TASK + 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   [MOUSE_DOWN], byte 1     ; do draw mouse
	call  windowactivate
 
	; update screen info
	pushad
	mov   edi, [TASK_COUNT] ; the last process (number)
	movzx esi, word [WIN_POS + 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, [TASK_COUNT]
	movzx esi, word [WIN_POS + edi * 2]
	call  setscreen
	popad
 
    mov   [edi + WDATA.fl_redraw], 1  ; redraw flag for app
    mov   [MOUSE_DOWN],byte 0		  ; mouse down checks
 
	ret
 
     .do_not_draw:
 
	popad
 
	call  windowactivate
	mov   [MOUSE_DOWN],byte 0  ; mouse down checks
	mov   [MOUSE_BACKGROUND],byte 0  ; no mouse background
	mov   [DONT_DRAW_MOUSE],byte 0	; draw mouse
	ret
 
 
; eax = window number on screen
; corrupts registers and [dl*]
minimize_window:
	movzx eax, word [WIN_POS+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 [WIN_POS+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, [TASK_COUNT] ; 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   [MOUSE_BACKGROUND],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, [TASK_COUNT]       ; 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   [BTN_DOWN],byte 0    ; mouse buttons pressed ?
	jne  .mouse_buttons_pressed
;..................................... start 1/4 : modified by vhanla .................
	mov [bPressedMouseXY_W],0
;..................................... end 1/4 : modified by vhanla ...................
	popad
	ret
    .mouse_buttons_pressed:
;..................................... start 2/4 : modified by vhanla .................
	jmp @f
	bPressedMouseXY_W db 0x0
	@@:
;..................................... end 2/4 : modified by vhanla ...................
	mov   esi,[TASK_COUNT]
	inc   esi
 
;..................................... start 3/4 : modified by vhanla .................
	push ax
	cmp [bPressedMouseXY_W],0
	jnz @f
	mov [bPressedMouseXY_W],1
	mov ax,[MOUSE_X]
	mov [mx],ax
	mov ax,[MOUSE_Y]
	mov [my],ax
	@@:
	pop ax
;..................................... end 3/4 : modified by vhanla ...................
 
      cwloop:
	cmp   esi,2
	jb   .exit
 
	dec   esi
	movzx edi, word [WIN_POS + 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
 
;..................................... start 4/4 : modified by vhanla .................
       movzx  eax, word [mx]; movzx eax,word[MOUSE_X]
       movzx  ebx, word [my]; movzx ebx,word[MOUSE_Y]
;..................................... endt 4/4 : modified by vhanla ..................
	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, [TASK_COUNT]
	cmp   eax, ebx	    ; is this window active?
	jz    .move_resize_window
 
	; eax = position in windowing stack
	; redraw must ?
	lea   esi, [WIN_POS + 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, 0x00000000						;{test for resized}
	je    .no_resize_2
	cmp   edx, 0x01000000						;{test for resized}
	je    .no_resize_2
	cmp   edx, 0x04000000						;{test for resized}					
	je    .no_resize_2
;	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, [BTN_DOWN]	 ; 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, [MOUSE_X]
	mov   [WIN_TEMP_XY], 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   [MOUSE_DOWN],byte 1   ; no reaction to mouse up/down
 
	; move window
 
      newchm:
 
	mov   [DONT_DRAW_MOUSE],byte 1
 
	call  checkidle
 
	call  checkVga_N13
 
	mov   [MOUSE_BACKGROUND],byte 0
 
	call  [draw_pointer]
 
	pushad
	call   stack_handler
	popad
 
	mov   esi,[WIN_TEMP_XY]
	cmp   esi,[MOUSE_X]
	je    cwb
 
	mov   cx,[MOUSE_X]
	mov   dx,[MOUSE_Y]
	sub   cx,ax
	sub   dx,bx
 
	push  ax
	push  bx
 
	call  drawwindowframes
 
	mov   ax,[ScreenWidth]
	mov   bx,[ScreenHeight]
 
	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, [SLOT_BASE + edx*8]
 
	movzx eax,word [MOUSE_X]
    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 [MOUSE_Y]
    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,[MOUSE_X]
	mov   [WIN_TEMP_XY],esi
 
      cwb:
	cmp   [BTN_DOWN],byte 0
	jne   newchm
				     ; new position done
	mov	[DONT_DRAW_MOUSE],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,SLOT_BASE+APPDATA.saved_box
	cld
	rep   movsd
	pop   ecx edi esi
      no_bounds_save:
 
	pushad				   ; WINDOW SHADE/FULLSCREEN
 
	;{doule click not worked for 4 type window}
    mov   edx, [edi + WDATA.cl_workarea]
	and   edx, 0x0f000000
	cmp   edx, 0x00000000
	je    no_fullscreen_restore
	cmp   edx, 0x01000000
	je    no_fullscreen_restore
	cmp   edx, 0x04000000
	je    no_fullscreen_restore
 
	cmp   [reposition],1
	je    no_window_sizing
	mov   edx,edi
	sub   edx,window_data
	shr   edx,5
	shl   edx,8
	add   edx,SLOT_BASE		    ; 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,[ScreenHeight]
	jbe   no_window_sizing
	mov   eax,[edi+WDATA.box.left]		       ; check X inside screen
	add   eax,[edi+WDATA.box.width]
	cmp   eax,[ScreenWidth]
	jbe   no_window_sizing
	mov   eax,[ScreenWidth]
	sub   eax,[edi+WDATA.box.width]
	mov   [edi+WDATA.box.left],eax
	mov   eax,[ScreenHeight]
	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   [DONT_DRAW_MOUSE],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   [DONT_DRAW_MOUSE],byte 1
	call  checkidle
	cmp	[edi+WDATA.fl_redraw],0
	jz    retwm
	loop  waitre2
 
      retwm:
 
	mov   [DONT_DRAW_MOUSE],byte 0 ; mouse pointer
	mov   [MOUSE_BACKGROUND],byte 0 ; no mouse under
	mov   [MOUSE_DOWN],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,[current_slot]
     mov  [eax+APPDATA.wnd_shape],ebx
rsw_no_address:
 
     cmp  eax,1
     jne  rsw_no_scale
     mov  eax,[current_slot]
     mov  byte [eax+APPDATA.wnd_shape_scale], bl
rsw_no_scale:
 
     ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 523 → 549