WebSVN – Kolibri OS – Diff – /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: 996 $
+$Revision: 2971 $
 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
+	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
 ; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,
 ;       è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü
 ;       ÷àñòåé îêîí âûçâàòü setscreen
 align 4
 calculatescreen:
-	pushad
+        pushad
-	pushfd
+        pushfd
-	cli
+        cli
-	push	edx ecx ebx eax
+        push    edx ecx ebx eax
-	mov	esi, 1
+        mov esi, 1
-	call	setscreen
+        call    setscreen
-	mov	ebp, [TASK_COUNT]	 ; number of processes
+        mov ebp, [TASK_COUNT]    ; number of processes
-	cmp	ebp, 1
+        cmp ebp, 1
-	jbe	.finish
+        jbe .finish
 align 4
 .new_wnd:
-	movzx	edi, word [WIN_POS + esi * 2]
+        movzx   edi, word [WIN_POS + esi * 2]
-	shl	edi, 5
+        shl edi, 5
-	cmp	[CURRENT_TASK+edi+TASKDATA.state], byte 9
+        cmp [CURRENT_TASK+edi+TASKDATA.state], byte 9
-	je	.not_wnd
+        je  .not_wnd
-	add	edi, window_data
+        add edi, window_data
-	test	[edi+WDATA.fl_wstate], WSTATE_MINIMIZED
+        test    [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
-	jnz	.not_wnd
+        jnz .not_wnd
-	mov	eax,[edi+WDATA.box.left]
+        mov eax,[edi+WDATA.box.left]
-	cmp	eax, [esp+RECT.right]
+        cmp eax, [esp+RECT.right]
-	ja	.out_of_bounds
+        ja  .out_of_bounds
-	mov	ebx,[edi+WDATA.box.top]
+        mov ebx,[edi+WDATA.box.top]
-	cmp	ebx, [esp+RECT.bottom]
+        cmp ebx, [esp+RECT.bottom]
-	ja	.out_of_bounds
+        ja  .out_of_bounds
-	mov	ecx,[edi+WDATA.box.width]
+        mov ecx,[edi+WDATA.box.width]
-	add	ecx, eax
+        add ecx, eax
-	cmp	ecx, [esp+RECT.left]
+        cmp ecx, [esp+RECT.left]
-	jb	.out_of_bounds
+        jb  .out_of_bounds
-	mov	edx,[edi+WDATA.box.height]
+        mov edx,[edi+WDATA.box.height]
-	add	edx, ebx
+        add edx, ebx
-	cmp	edx, [esp+RECT.top]
+        cmp edx, [esp+RECT.top]
-	jb	.out_of_bounds
+        jb  .out_of_bounds
-    cmp     eax, [esp+RECT.left]
+        cmp     eax, [esp+RECT.left]
-	jae	@f
+        jae @f
-	mov	eax, [esp+RECT.left]
+        mov eax, [esp+RECT.left]
 @@:
-    cmp     ebx, [esp+RECT.top]
+        cmp     ebx, [esp+RECT.top]
-	jae	@f
+        jae @f
-	mov	ebx, [esp+RECT.top]
+        mov ebx, [esp+RECT.top]
 @@:
-    cmp     ecx, [esp+RECT.right]
+        cmp     ecx, [esp+RECT.right]
-	jbe	@f
+        jbe @f
-	mov	ecx, [esp+RECT.right]
+        mov ecx, [esp+RECT.right]
 @@:
-    cmp     edx, [esp+RECT.bottom]
+        cmp     edx, [esp+RECT.bottom]
-	jbe	@f
+        jbe @f
-	mov	edx, [esp+RECT.bottom]
+        mov edx, [esp+RECT.bottom]
 @@:
-	push	esi
+        push    esi
-	movzx	esi, word [WIN_POS + esi * 2]
+        movzx   esi, word [WIN_POS + esi * 2]
-	call	setscreen
+        call    setscreen
-	pop	esi
+        pop esi
 .not_wnd:
 .out_of_bounds:
-	inc	esi
+        inc esi
-	dec	ebp
+        dec ebp
-	jnz	.new_wnd
+        jnz .new_wnd
 .finish:
-    pop     eax ebx ecx edx
+        pop     eax ebx ecx edx
-	popfd
+        popfd
-	popad
+        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   ecx, eax
-	sub   edx, ebx
+        sub   edx, ebx
-	inc   ecx
+        inc   ecx
-	inc   edx
+        inc   edx
 	; get WinMap start
         mov   edi, [Screen_Max_X] ; screen_sx
-	inc   edi
+        inc   edi
-	imul  edi, ebx
+        imul  edi, ebx
-	add   edi, eax
+        add   edi, eax
         add   edi, [_display_data]
 .new_y:
-	push  ecx ; sx
+        push  ecx ; sx
-	push  edx
+        push  edx
-	mov   edx, esi
+        mov   edx, esi
 	align 4
 .new_x:
-	mov   byte [edi], dl
+        mov   byte [edi], dl
-	inc   edi
+        inc   edi
-	dec   ecx
+        dec   ecx
-	jnz   .new_x
+        jnz   .new_x
-	pop   edx
+        pop   edx
-	pop   ecx
+        pop   ecx
         add   edi, [Screen_Max_X]
-	inc   edi
+        inc   edi
-	sub   edi, ecx
+        sub   edi, ecx
-	dec   edx
+        dec   edx
-	jnz   .new_y
+        jnz   .new_y
 .ret:
- popad
+        popad
- ret
+        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
+;iglobal
-  window_moving   db 'K : Window - move/resize',13,10,0
+;  window_moving   db 'K : Window - move/resize',13,10,0
-  window_moved	  db 'K : Window - done',13,10,0
+;  window_moved	  db 'K : Window - done',13,10,0
-endg
-bPressedMouseXY_W db 0x0
+;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],0
+	cmp [bPressedMouseXY_W],1
-	jnz @f
+	ja  @f
-	mov [bPressedMouseXY_W],1
+	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 ...................
-    movzx  eax,word [MOUSE_Y]
-    movzx  ebx,word [MOUSE_X]
-    mov ecx, [Screen_Max_X]
-    add ebx, [_display_data]
-    inc ecx
-    mul ecx
-    movzx edi, byte [ebx+eax]
+      cwloop:
+	cmp   esi,2
+	jb   .exit
-cwloop:
-    movzx esi, word [WIN_STACK + edi * 2]
+	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
-	shl   edi, 5
+	jnz	cwloop
-	add   edi, window_data
+;..................................... 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
-    movzx  eax,word [MOUSE_X]
+	cmp   ebx, edx
-    movzx  ebx,word [MOUSE_Y]
+	jae   cwloop
 	pushad
-	mov   eax, esi
+    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
+;	push  esi
-	mov   esi, window_moving
+;	mov   esi, window_moving
-	call  sys_msg_board_str
+;	call  sys_msg_board_str
-	pop   esi
+;	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, dword [MOUSE_X]
+	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:
+      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
+;	mov    esi,window_moved
-	call   sys_msg_board_str
+;	call   sys_msg_board_str
 	popad
 	ret
 uglobal
-  add_window_data	     dd  0
+  add_window_data            dd  0
   do_resize_from_corner      db  0x0
-  reposition		     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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/gui/window.inc – Rev 996 → 2971