kolibrios/kernel/branches/kolibri_pe/gui/window.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision$


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
	jb	@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
; <EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,
;       <EFBFBD> <EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
;       <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 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
; <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
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, [Screen_Max_X] ; screen_sx
        inc   edi
        imul  edi, ebx
        add   edi, eax
        add   edi, [_display_data]

.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, [Screen_Max_X]
        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, [Screen_Max_X] ; screen_sx
	inc   eax
	imul  eax, ebx
	add   eax, [esp]
        add   eax, [_display_data]
	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, [Screen_Max_X]  ; 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,[Screen_Max_X]
     mov  [dlxe],eax
     mov  eax,[Screen_Max_Y]
     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;[Screen_Max_X]
	jl	@f
	mov	[screen_workarea.left],eax
    @@: cmp     ebx,[Screen_Max_X]
	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,[Screen_Max_Y]
	jg	.lp2
	mov	[screen_workarea.bottom],ebx
  .lp2: call	repos_windows
	mov	eax, 0
	mov	ebx, 0
        mov     ecx, [Screen_Max_X]
        mov     edx, [Screen_Max_Y]
    call    calculatescreen
;    jmp    redraw_screen_direct
    .exit:
	popad
	ret
   no_set_workarea:

	cmp	eax,7	    ; get skin margins
	jne	no_get_skinmargins
	popad
	mov	eax,dword[_skinmargins+0]
	mov	[esp+36],eax
	mov	eax,dword[_skinmargins+4]
	mov	[esp+24],eax
	ret
   no_get_skinmargins:

	cmp	eax,8	    ; set window skin
	jne	no_set_skin
        call    read_skin_file
        mov     [esp+32+36], eax
        test    eax, eax
        jnz     .ret
        xor     eax, eax
        xor     ebx, ebx
        mov     ecx, [Screen_Max_X]
        mov     edx, [Screen_Max_Y]
        call    calculatescreen
	jmp	redraw_screen_direct
.ret:
        popad
        ret
   no_set_skin:

     popad
     ret


repos_windows:
	mov	ecx,[TASK_COUNT]
    mov edi, window_data+0x20*2
	call    force_redraw_background
	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,[Screen_Max_X]
;    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,[Screen_Max_Y]
;    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 ?

    mov   eax, [edi+WDATA.box.left]
    mov   ebx, [edi+WDATA.box.top]
    mov   ecx, [edi+WDATA.box.width]
    mov   edx, [edi+WDATA.box.height]

    cmp   ecx,[Screen_Max_X]	      ; check x size
    jbe   x_size_ok
    mov   ecx,[Screen_Max_X]
    mov   [edi+WDATA.box.width],ecx

  x_size_ok:

    cmp   edx,[Screen_Max_Y]	      ; check y size
    jbe   y_size_ok
    mov   edx,[Screen_Max_Y]
    mov   [edi+WDATA.box.height],edx

  y_size_ok:

    cmp   eax,0	      ; check x pos
    jnle  @f
    xor   eax,eax
    mov   [edi+WDATA.box.left],eax
    jmp   x_pos_ok
  @@:
    add   eax,ecx
    cmp   eax,[Screen_Max_X]
    jbe   x_pos_ok
    mov   eax,[Screen_Max_X]
    sub   eax,ecx
    mov   [edi+WDATA.box.left],eax

  x_pos_ok:

    cmp   ebx,0	      ; check x pos
    jnle  @f
    xor   ebx,ebx
    mov   [edi+WDATA.box.top],ebx
    jmp   y_pos_ok
  @@:
    add   ebx,edx
    cmp   ebx,[Screen_Max_Y]
    jbe   y_pos_ok
    mov   ebx,[Screen_Max_Y]
    sub   ebx,edx
    mov   [edi+WDATA.box.top],ebx

  y_pos_ok:

    popad

    ret


drawwindow_I_caption:

	mov   ecx,[edx+WDATA.cl_titlebar]   ; grab bar
	push  ecx
	mov   esi,edx
	mov   edx,[esi+WDATA.box.top]
	add   edx,1
	mov   ebx,[esi+WDATA.box.top]
	add   ebx,21
	mov   eax,[esi+WDATA.box.top]
	add   eax,[esi+WDATA.box.height]
	cmp   ebx,eax
	jb    .wdsizeok
	mov   ebx,eax
.wdsizeok:
	push  ebx
.drwi:
	mov   ebx,edx
	shl   ebx,16
	add   ebx,edx
	mov   eax,[esi+WDATA.box.left]
	inc   eax
	shl   eax,16
	add   eax,[esi+WDATA.box.left]
	add   eax,[esi+WDATA.box.width]
	sub   eax,1
	push  edx
	mov   edx,0x80000000
	mov   ecx,[esi+WDATA.cl_titlebar]
	and   ecx,edx
	cmp   ecx,edx
	jnz   .nofa
	mov   ecx,[esi+WDATA.cl_titlebar]
	sub   ecx,0x00040404
	mov   [esi+WDATA.cl_titlebar],ecx
	and   ecx,0x00ffffff
	jmp   .faj
.nofa:
	mov   ecx,[esi+WDATA.cl_titlebar]
	and   ecx,0x00ffffff
.faj:
	pop   edx
	mov   edi,0
	call  [draw_line]
	inc   edx
	cmp   edx,[esp]
	jb    .drwi
	add   esp,4
	pop   ecx
	mov   [esi+WDATA.cl_titlebar],ecx

	ret


drawwindow_I:

	pushad
	or	[edx+WDATA.fl_wdrawn], 4

	mov   esi,[edx+WDATA.cl_frames]   ; rectangle
	mov   eax,[edx+WDATA.box.left]
	shl   eax,16
	add   eax,[edx+WDATA.box.left]
	add   eax,[edx+WDATA.box.width]
	mov   ebx,[edx+WDATA.box.top]
	shl   ebx,16
	add   ebx,[edx+WDATA.box.top]
	add   ebx,[edx+WDATA.box.height]
	call  draw_rectangle

	and	[edx+WDATA.fl_wdrawn], not 4
	test	[edx+WDATA.fl_wdrawn], 2
	jz	@f
	call	drawwindowframes2
@@:

	call	drawwindow_I_caption

	mov   edx,[esi+WDATA.box.top]	   ; inside work area
	add   edx,21+5
	mov   ebx,[esi+WDATA.box.top]
	add   ebx,[esi+WDATA.box.height]
	cmp   edx,ebx
	jg    noinside
	mov   eax,1
	mov   ebx,21
	mov   ecx,[esi+WDATA.box.width]
	mov   edx,[esi+WDATA.box.height]
	mov   edi,[esi+WDATA.cl_workarea]
	test  edi,0x40000000
	jnz   noinside
	call  [drawbar]
noinside:

	popad

	ret


draw_rectangle:

r_eax equ [esp+28]   ; x start
r_ax  equ [esp+30]   ; x end
r_ebx equ [esp+16]   ; y start
r_bx  equ [esp+18]   ; y end
;esi                 ; color

	pushad

	mov   ecx,esi	       ; yb,xb -> yb,xe
	mov   eax, r_eax
	rol   eax, 16
	mov   ebx,r_ebx
	shl   ebx,16
	mov   bx,r_ebx
	xor   edi, edi
	call  [draw_line]

	mov   ebx,r_bx	       ; ye,xb -> ye,xe
	shl   ebx,16
	mov   bx,r_bx
	call  [draw_line]

	mov   ecx,esi	       ; ya,xa -> ye,xa
	mov   eax,r_eax
	shl   eax,16
	mov   ax,r_eax
	mov   ebx,r_ebx
	shl   ebx,16
	mov   bx,r_bx
	mov   edi,0
	call  [draw_line]

	mov   eax,r_ax	     ; ya,xe -> ye,xe
	shl   eax,16
	mov   ax,r_ax
	call  [draw_line]

	popad
	ret


drawwindow_III_caption:

	mov   ecx,[edx+WDATA.cl_titlebar]			; GRAB BAR
	push  ecx
	mov   esi,edx
	mov   edx,[esi+WDATA.box.top]
	add   edx,4
	mov   ebx,[esi+WDATA.box.top]
	add   ebx,20
	mov   eax,[esi+WDATA.box.top]
	add   eax,[esi+WDATA.box.height]
	cmp   ebx,eax
	jb    .wdsizeok
	mov   ebx,eax
.wdsizeok:
	push  ebx
.drwi:
	mov   ebx,edx
	shl   ebx,16
	add   ebx,edx
	mov   eax,[esi+WDATA.box.left]
	shl   eax,16
	add   eax,[esi+WDATA.box.left]
	add   eax,[esi+WDATA.box.width]
	add   eax,4*65536-4
	mov   ecx,[esi+WDATA.cl_titlebar]
	test  ecx,0x40000000
	jz    .nofa
	add   ecx,0x040404
.nofa:
	test  ecx,0x80000000
	jz    .nofa2
	sub   ecx,0x040404
.nofa2:
	mov   [esi+WDATA.cl_titlebar],ecx
	and   ecx,0xffffff
	xor   edi, edi
	call  [draw_line]
	inc   edx
	cmp   edx,[esp]
	jb    .drwi
	add   esp,4
	pop   ecx
	mov   [esi+WDATA.cl_titlebar],ecx

	ret


drawwindow_III:

	pushad

	mov   edi,edx				   ; RECTANGLE
	mov   eax,[edi+WDATA.box.left]
	shl   eax,16
    mov   ax, word [edi+WDATA.box.left]
    add   ax, word [edi+WDATA.box.width]
	mov   ebx,[edi+WDATA.box.top]
	shl   ebx,16
    mov   bx, word [edi+WDATA.box.top]
    add   bx, word [edi+WDATA.box.height]
	mov   esi,[edi+WDATA.cl_frames]
	shr   esi,1
	and   esi,0x007f7f7f
	push  esi
	or	[edi+WDATA.fl_wdrawn], 4
	call  draw_rectangle
	and	[edi+WDATA.fl_wdrawn], not 4
	test	[edi+WDATA.fl_wdrawn], 2
	jz	@f
	call	drawwindowframes2
@@:
	mov   ecx,3
dw3l:
	add   eax,1*65536-1
	add   ebx,1*65536-1
	mov   esi,[edi+WDATA.cl_frames]
	call  draw_rectangle
	dec   ecx
	jnz   dw3l
	pop   esi
	add   eax,1*65536-1
	add   ebx,1*65536-1
	call  draw_rectangle

	call	drawwindow_III_caption

	mov   edx,[esi+WDATA.box.top]			    ; WORK AREA
	add   edx,21+5
	mov   ebx,[esi+WDATA.box.top]
	add   ebx,[esi+WDATA.box.height]
	cmp   edx,ebx
	jg    noinside2
	mov   eax,5
	mov   ebx,20
	mov   ecx,[esi+WDATA.box.width]
	mov   edx,[esi+WDATA.box.height]
	sub   ecx,4
	sub   edx,4
	mov   edi,[esi+WDATA.cl_workarea]
	test  edi,0x40000000
	jnz   noinside2
	call  [drawbar]
noinside2:
	popad

	ret



; activate window
align 4
windowactivate:

	; esi = abs mem position in stack 0xC400+

	pushad

     ; if type of current active window is 3,
     ; it must be redrawn
	mov   eax, [TASK_COUNT]
	movzx eax, word [WIN_POS + eax*2]
	shl   eax, 5
	add   eax, window_data
	mov   ebx, [eax + WDATA.cl_workarea]
	and   ebx, 0x0f000000
	cmp   ebx, 0x03000000
	je   .set_WDATA_fl_redraw   ; for 3 and 4 style
	cmp   ebx, 0x04000000
	je   .set_WDATA_fl_redraw
	jmp @f
	.set_WDATA_fl_redraw:
	mov   [eax + WDATA.fl_redraw], byte 1
     @@:

	push   esi
      movzx   eax, word [esi] ; ax <- process no
      movzx   eax, word [WIN_STACK+eax*2] ; ax <- position in window stack

	xor   esi, esi	      ; drop others
waloop:
	cmp   esi, dword [TASK_COUNT]
	jae   wacont
	inc   esi
	lea   edi, [WIN_STACK + esi*2]
	mov   bx, [edi] ; position of the current process
	cmp   bx, ax
	jbe   @f
	dec   bx       ; upper? => drop!
	mov   [edi], bx
      @@:
	jmp   waloop
wacont:
			    ; set to no 1
	pop   esi	    ;   esi = pointer at 0xC400

    movzx   eax, word [esi]
	mov   bx, [TASK_COUNT]	; number of processes
	mov   [WIN_STACK+eax*2], bx	; this is the last (and the upper)

	; update on screen -window stack
	xor   esi, esi
waloop2:
	mov   edi, [TASK_COUNT]
	cmp   esi, edi
	jae   wacont2
	inc   esi
	movzx ebx, word [esi*2 + WIN_STACK]
	mov   [ebx*2 + WIN_POS], si
	jmp   waloop2
wacont2:
    mov   [KEY_COUNT],  0         ; empty keyboard buffer
    mov   [BTN_COUNT],  0             ; empty button buffer
    mov   [mouse_scroll_h],  0        ; zero mouse z-index
    mov   [mouse_scroll_v],  0        ; zero mouse z-index
	popad
	ret


; check if window is necessary to draw

checkwindowdraw:

	; edi = position in window_data+

	mov   eax, [edi + WDATA.cl_workarea]
	and   eax, 0x0f000000
	cmp   eax, 0x03000000
	je    .return_yes      ; window type 3
	cmp   eax, 0x04000000
	je    .return_yes      ; window type 4

	mov   esi, edi
	sub   esi, window_data
	shr   esi, 5

	; esi = process number

	movzx eax, word [WIN_STACK + esi * 2] ; get value of the curr process
	lea   esi, [WIN_POS + eax * 2]	    ; get address of this process at 0xC400

	push  esi

.new_check:

	pop   esi
	add   esi, 2
	push  esi

	mov   eax, [TASK_COUNT]
	lea   eax, word [WIN_POS + eax * 2] ; number of the upper window

	cmp   esi, eax
	ja    .all_wnds_to_top

	movzx eax, word [esi]
	shl   eax, 5
	cmp   [CURRENT_TASK + eax + TASKDATA.state], byte 9
	je    .new_check		    ; skip dead windows

	lea   esi, [eax+window_data]

	mov   ebx, [edi+WDATA.box.top]	; y0
	mov   edx, [edi+WDATA.box.height]
	add   edx, ebx	    ; y0e

	mov   ecx, [esi+WDATA.box.top]	; y  ; y check
	cmp   ecx, edx
	jae   .new_check     ; y < y0e
	mov   eax, [esi+WDATA.box.height]
	add   ecx, eax	     ; ye
	cmp   ebx, ecx	     ; y0 >= ye
	ja    .new_check

	mov   eax, [edi+WDATA.box.left]   ; x0
	mov   ecx, [edi+WDATA.box.width]
	add   ecx, eax	     ; x0e

	mov   edx, [esi+WDATA.box.left]   ; x ; x check
	cmp   edx, ecx
	jae   .new_check     ; x < x0e
	mov   ecx, [esi+WDATA.box.width]
	add   edx, ecx
	cmp   eax, edx
	ja    .new_check

	pop   esi
  .return_yes:
	mov   ecx,1   ; overlap some window
	ret

  .all_wnds_to_top:

	pop   esi

	xor   ecx, ecx	     ; passed all windows to top
	ret


waredraw:     ; if redraw necessary at activate

	pushad

	call  checkwindowdraw	   ; draw window on activation ?
	test  ecx, ecx
	jz    .do_not_draw

	popad
	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

	ret

.do_not_draw:

	popad

	call  windowactivate
    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:
.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  byte [btn_down],   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 .................
uglobal
	bPressedMouseXY_W db 0x0
endg
;..................................... end 2/4 : modified by vhanla ...................
	mov   esi,[TASK_COUNT]
	inc   esi

;..................................... start 3/4 : modified by vhanla .................
	cmp [bPressedMouseXY_W],1
	ja  @f
	inc [bPressedMouseXY_W]
	jnc @f
	;mov ax,[MOUSE_X]
	;mov [mx],ax
	;mov ax,[MOUSE_Y]
	;mov [my],ax
	mov eax,dword[MOUSE_X]
	mov dword[mx],eax
      @@:
;..................................... 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

	cmp   [bPressedMouseXY_W], 1
	ja    .exit_popa

	; eax = position in windowing stack
	; redraw must ?
	lea   esi, [WIN_POS + esi * 2]
	call  waredraw
.exit_popa:
	add   esp, 32

.exit:
	popad
	ret

.move_resize_window:    ; MOVE OR RESIZE WINDOW
	popad

	; Check for user enabled fixed window
    mov   edx, [edi + WDATA.cl_titlebar]
	and   edx, 0x0f000000
	cmp   edx, 0x01000000
	jne   .window_move_enabled_for_user
	popad
	ret
.window_move_enabled_for_user:

    test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
	jnz	.no_resize_2

	mov   [do_resize_from_corner],byte 0   ; resize for skinned window
    mov   edx, [edi + WDATA.cl_workarea]
	and   edx, 0x0f000000
	cmp   edx, 0x00000000						;{test for resized}
	je    .no_resize_2
	cmp   edx, 0x01000000						;{test for resized}
	je    .no_resize_2
	cmp   edx, 0x04000000						;{test for resized}
	je    .no_resize_2
;	jb    .no_resize_2 ; not type 2 wnd

    mov   edx, [edi + WDATA.box.top]
    add   edx, [edi + WDATA.box.height]
	sub   edx, 6	   ; edx = y_end - 6
	cmp   ebx, edx	   ; ebx = mouse_y
	jb    .no_resize_2
	mov   [do_resize_from_corner],byte 1
	jmp   .continue
      .no_resize_2:

	push	eax
	call	get_titlebar_height
    add     eax,[edi + WDATA.box.top]
	cmp	ebx,eax
	pop	eax
	jae	.exit

     .continue:

;	push  esi
;	mov   esi, window_moving
;	call  sys_msg_board_str
;	pop   esi

	mov   ecx, [timer_ticks]     ; double-click ?
	mov   edx, ecx
	sub   edx, [latest_window_touch]
	mov   [latest_window_touch], ecx
	mov   [latest_window_touch_delta], edx

    mov   cl, byte  [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, dword [MOUSE_X]
	mov   [WIN_TEMP_XY], esi

	pushad		 ; wait for putimages to finish
;        mov   ebx,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:

	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, word [Screen_Max_X]
        mov   bx, word [Screen_Max_Y]

	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, dword [MOUSE_X]
	mov   [WIN_TEMP_XY],esi

      cwb:
    cmp  byte [btn_down], 0
	jne   newchm
				     ; new position done
    mov cl,0
	test	[edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
	jnz	@f
	mov	cl,[reposition]
	call	drawwindowframes

	mov   eax,[npx]
    mov   [edi + WDATA.box.left],eax
	mov   eax,[npy]
    mov   [edi + WDATA.box.top],eax
	mov   eax,[npxe]
    mov   [edi + WDATA.box.width],eax
	mov   eax,[npye]
    mov   [edi + WDATA.box.height],eax
	call	set_window_clientbox

    @@: mov	[reposition],cl

	cmp   [reposition],1	     ; save new position and size
	jne   no_bounds_save
	push  esi edi ecx
	mov   esi,edi
	mov   ecx,2
	test  [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP or WSTATE_MAXIMIZED
	jnz   @f
	add   ecx,2
@@:
    sub   edi,window_data
	shr   edi,5
	shl   edi,8
	add   edi,SLOT_BASE+APPDATA.saved_box
	cld
	rep   movsd
	pop   ecx edi esi
      no_bounds_save:

	pushad				   ; WINDOW SHADE/FULLSCREEN

	;{doule click not worked for 4 type window}
    mov   edx, [edi + WDATA.cl_workarea]
	and   edx, 0x0f000000
	cmp   edx, 0x00000000
	je    no_fullscreen_restore
	cmp   edx, 0x01000000
	je    no_fullscreen_restore

	cmp   [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
        add     eax, [edi+WDATA.box.top]
        cmp     eax, [Screen_Max_Y]
        jbe     @f
        mov     eax, [Screen_Max_Y]
        sub     eax, [edi+WDATA.box.height]
        mov     [edi+WDATA.box.top], eax
    @@: call    check_window_position
	call	set_window_clientbox

no_window_shade:

	push edx
	mov   edx, [edi + WDATA.cl_workarea]
	and   edx, 0x0f000000
	cmp   edx, 0x04000000
	pop edx
	je    no_fullscreen_restore

	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,[Screen_Max_Y]
	jbe   no_window_sizing
	mov   eax,[edi+WDATA.box.left]		       ; check X inside screen
	add   eax,[edi+WDATA.box.width]
        cmp   eax,[Screen_Max_X]
	jbe   no_window_sizing
        mov   eax,[Screen_Max_X]
	sub   eax,[edi+WDATA.box.width]
	mov   [edi+WDATA.box.left],eax
        mov   eax,[Screen_Max_Y]
	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

	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:
    call  checkidle
	cmp	[edi+WDATA.fl_redraw],0
	jz    retwm
	loop  waitre2

retwm:

;	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


;ebx x
;eax y
;ecx width
;edx height
;esi slot

align 4
_set_screen:
        push edx
        add   ebx, [_display_data]
        mul   [_screen_width]
        lea   ebx, [eax+ebx]

        mov eax, esi
        mov ah, al
        mov esi, eax
        shl eax, 16
        or eax, esi

        pop edx
        mov esi, ecx
.row:

        mov edi, ebx
        add ebx, [_screen_width]

        mov ecx, esi

        dec edx
        js .done
.16:
        cmp ecx, 16
        jb .8

        mov [edi],   eax
        mov [edi+4], eax
        mov [edi+8], eax
        mov [edi+12], eax
        add edi, 16
        sub ecx, 16
        jmp .16
.8:
        shr ecx, 2
        rep stosd
        mov ecx, esi
        and ecx, 3
        rep stosb
        jmp .row
.done:
        ret

;[esp+4]    ebp
;[esp+8]    x
;[esp+12]   y
;[esp+16]   w
;[esp+20]   h
;[esp+24]   color

;ebx      disp data
;edx      dest

public _int_draw_bar
align 4
_int_draw_bar:

        lea ecx, [esp+4]
        call lock_cursor

        sub esp, 4
        mov [esp], ebp

        mov ebx, [esp+8]
        mov eax, [esp+12]
        mul [_screen_width]
        add ebx, [_display_data]
        lea ebx, [eax+ebx]

        mov edi, [esp+8]
        mov eax, [esp+12]
        mul [BytesPerScanLine]

        cmp byte [ScreenBPP], 24
        je  .24

        lea ecx, [LFB_BASE+eax+edi*4]

        mov eax, [esp+24]
        mov edx, [CURRENT_TASK]
.row32:
        mov edi, ecx
        mov esi, ebx

        add ecx, [BytesPerScanLine]
        add ebx, [_screen_width]

        dec dword [esp+20]
        js .done

        mov ebp, [esp+16]

align 16
.draw32:
        cmp dl, byte [esi]
        jne @f

        stosd
@@:
        inc esi
        dec ebp
        jnz .draw32
        jmp .row32
.done:
        call unlock_cursor

        mov ebp, [esp]
        add esp, 4
        ret

.24:
        lea ecx, [LFB_BASE+edi*3]
        add ecx, eax

        mov eax, [esp+24]
        mov edx, eax
        shr edx, 8
        mov dl, [CURRENT_TASK]
.row24:
        mov edi, ecx
        mov esi, ebx

        add ecx, [BytesPerScanLine]
        add ebx, [_screen_width]

        dec dword [esp+20]
        js .done

        mov ebp, [esp+16]

align 16
.draw24:
        cmp dl, byte [esi]
        jne @f

        mov [edi], ax
        mov [edi+2], dh
@@:
        add edi, 3
        inc esi
        dec ebp
        jnz .draw24
        jmp .row24



;[esp+4]    x
;[esp+8]    y
;[esp+12]   w
;[esp+16]   color

;esi      disp data
;edi      dest


public _int_hline
align 4
_int_hline:

           mov esi, [esp+4]
           mov eax, [esp+8]
           mov ecx, [esp+12]

           mul [_screen_width]
           add esi, [_display_data]
           add esi, eax

           mov edi, [esp+4]
           mov eax, [esp+8]
           mul [BytesPerScanLine]

           cmp byte [ScreenBPP], 24
           je  .24

           lea edi, [LFB_BASE+eax+edi*4]

           mov eax, [esp+16]

.32_kernel:
           mov edx, [CURRENT_TASK]

align 16
.draw32:
           cmp dl, byte [esi]
           jne @f

           stosd
@@:
           inc esi
           dec ecx
           jnz .draw32

           ret
.24:
           lea edi, [LFB_BASE+edi*3]
           add edi, eax

           mov eax, [esp+16]

.24_kernel:
           mov edx, eax
           shr edx, 8
           mov dl, [CURRENT_TASK]

align 16
.draw24:
           cmp dl, byte [esi]
           jne @f

           mov [edi], ax
           mov [edi+2], dh
@@:
           add edi, 3
           inc esi
           dec ecx
           jnz .draw24

           ret


;[esp+4]    x
;[esp+8]    y
;[esp+12]   h
;[esp+16]   color

;esi      disp data
;edi      dest

public _int_vline
align 4
_int_vline:

           mov esi, [esp+4]
           mov eax, [esp+8]
           mov ecx, [esp+12]

           mul [_screen_width]
           add esi, [_display_data]
           add esi, eax

           mov edi, [esp+4]
           mov eax, [esp+8]
           mul [BytesPerScanLine]

           cmp byte [ScreenBPP], 24
           je  .24

           lea edi, [LFB_BASE+eax+edi*4]

           mov eax, [esp+16]

.32_kernel:
           mov edx, [CURRENT_TASK]

align 16
.draw32:
           cmp dl, byte [esi]
           jne @f

           mov [edi], eax
@@:
           add esi, [_screen_width]
           add edi, [BytesPerScanLine]
           dec ecx
           jnz .draw32

           ret
.24:
           lea edi, [LFB_BASE+edi*3]
           add edi, eax

           mov eax, [esp+16]

.24_kernel:
           mov edx, eax
           shr edx, 8
           mov dl, [CURRENT_TASK]

align 16
.draw24:
           cmp dl, byte [esi]
           jne @f

           mov [edi], ax
           mov [edi+2], dh
@@:
           add esi, [_screen_width]
           add edi, [BytesPerScanLine]
           dec ecx
           jnz .draw24

           ret

;[esp]      dst
;[esp+4]    mask

;[esp+12]   x
;[esp+16]   y
;[esp+20]   w
;[esp+24]   h
;[esp+32]   color

public _int_rectangle
align 4
_int_rectangle:

.dst       equ (esp)
.mask      equ (esp+4)

.x         equ (esp+12)
.y         equ (esp+16)
.w         equ (esp+20)
.h         equ (esp+24)
.color     equ (esp+28)

           sub esp, 8

           mov esi, [.x]
           mov eax, [.y]
           mul [_screen_width]
           add esi, [_display_data]
           add esi, eax
           mov [.mask], esi

           mov edi, [.x]
           mov eax, [.y]
           mul [BytesPerScanLine]

           cmp byte [ScreenBPP], 24
           je  .24

           lea edi, [LFB_BASE+eax+edi*4]

           mov [.dst],  edi

           mov ecx, [.w]
           mov eax, [.color]
           call _int_hline.32_kernel

           sub edi, 4
           dec esi

           mov ecx, [.h]
           call _int_vline.32_kernel

           mov edi, [.dst]
           mov esi, [.mask]
           mov ecx, [.h]
           call _int_vline.32_kernel

           mov ecx, [.w]
           sub esi, [_screen_width]
           sub edi, [BytesPerScanLine]
           call _int_hline.32_kernel

           add esp, 8
           ret
.24:
           lea edi, [LFB_BASE+edi*3]
           add edi, eax

           mov [.dst],  edi

           mov ecx, [.w]
           mov eax, [.color]
           call _int_hline.24_kernel

           sub edi, 3
           dec esi

           mov ecx, [.h]
           call _int_vline.24_kernel

           mov edi, [.dst]
           mov esi, [.mask]
           mov ecx, [.h]
           call _int_vline.24_kernel

           mov ecx, [.w]
           sub esi, [_screen_width]
           sub edi, [BytesPerScanLine]
           call _int_hline.24_kernel

restore   .dst
restore   .mask

restore   .x
restore   .y
restore   .w
restore   .h
restore   .color

           add esp, 8
           ret