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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/gui/window.inc – Rev 427 → 444