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


$Revision: 431 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; 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
	mov	eax,ebx
	mov	edi,[TASK_BASE]
	add	ebx,[edi+TASKDATA.mem_start]	    ; abs start of info block
	pushd	[ebx+0] [ebx+4] [ebx+8] [ebx+12]
	mov	dword[ebx+0],0	      ; read
	mov	dword[ebx+4],0	      ; from the beginning
	mov	dword[ebx+8],64       ; 32 KBytes maximum
	mov	ecx,skin_data+64*512
	sub	ecx,[edi+0x10]
	mov	dword[ebx+12],ecx     ; destination
	push	eax
	pushad
	call	file_system
	popad
	pop    eax
	popd	[ebx+12] [ebx+8] [ebx+4] [ebx+0]
	cmp	eax,ERROR_SUCCESS
	je	@f
	cmp	eax,ERROR_END_OF_FILE
	jne	.exit
    @@: cmp	[skin_data+64*512+SKIN_HEADER.ident],'SKIN'
	mov	eax,ERROR_UNKNOWN_FS
	jne	.exit
	mov	esi,skin_data+64*512
	mov	edi,skin_data
	mov	ecx,(64*512)/4
	rep	movsd
	call	parse_skin_data
    pushad
	mov	eax, 0
	mov	ebx, 0
	mov	ecx, [ScreenWidth]
	mov	edx, [ScreenHeight]
	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,[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
	jne   @f
	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
	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 [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, 0x02000000
	jb    .no_resize_2 ; not type 2 wnd
 
    mov   edx, [edi + WDATA.box.top]
    add   edx, [edi + WDATA.box.height]
	sub   edx, 6	   ; edx = y_end - 6
	cmp   ebx, edx	   ; ebx = mouse_y
	jb    .no_resize_2
	mov   [do_resize_from_corner],byte 1
	jmp   .continue
      .no_resize_2:
 
	push	eax
	call	get_titlebar_height
    add     eax,[edi + WDATA.box.top]
	cmp	ebx,eax
	pop	eax
	jae	.exit
 
     .continue:
 
	push  esi
	mov   esi, window_moving
	call  sys_msg_board_str
	pop   esi
 
	mov   ecx, [timer_ticks]     ; double-click ?
	mov   edx, ecx
	sub   edx, [latest_window_touch]
	mov   [latest_window_touch], ecx
	mov   [latest_window_touch_delta], edx
 
	mov   cl, [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
 
	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_TASK]
     shl  eax,8
 
     mov  [eax+SLOT_BASE+APPDATA.wnd_shape],ebx
   rsw_no_address:
 
     cmp  eax,1
     jne  rsw_no_scale
     mov  eax,[CURRENT_TASK]
     shl  eax,8
     mov  byte [eax+SLOT_BASE+APPDATA.wnd_shape_scale], bl
   rsw_no_scale:
 
     ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 425 → 431