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


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,0xc000
       @@:
        inc   eax
        add   ecx,2
        mov   [ecx+0x000],ax          ; process no
        mov   [ecx+0x400],ax          ; positions in stack
        cmp   ecx,0xc400-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
 
        mov   esi, 1
        xor   eax, eax
        xor   ebx, ebx
        mov   ecx, [0xFE00]
        mov   edx, [0xFE04]
        call  setscreen
 
        mov   ebp, [0x3004]        ; number of processes
        cmp   ebp, 1
        jbe   .finish
        align 4
      .new_wnd:
        movzx   edi, word [0xC400 + esi * 2]
        shl     edi, 5
 
        cmp     [0x3000+edi+0xa], byte 9
        je      .not_wnd
 
        add     edi, window_data
        test    [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
        jnz     .not_wnd
        mov     eax,[edi+WDATA.left]
        mov     ebx,[edi+WDATA.top]
        mov     ecx,[edi+WDATA.width]
        add     ecx,eax
        mov     edx,[edi+WDATA.height]
        add     edx,ebx
        push  esi
        movzx esi, word [0xC400 + esi * 2]
        call  setscreen
        pop   esi
      .not_wnd:
        inc   esi
        dec   ebp
        jnz   .new_wnd
      .finish:
        popfd
        popad
ret
 
 
 
virtual at esp
  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
        mov edi, esi ;;;word [esi*2+0xc400]
        shl   edi, 8
        add   edi, 0x80000+0x80  ; address of random shaped window area
        cmp   [edi], dword 0
        jne   .free_form
 
        ; get x&y size
        sub   ecx, eax
        sub   edx, ebx
        inc   ecx
        inc   edx
 
        ; get WinMap start
        mov   edi, [0xFE00] ; 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, [0xFE00]
        inc   edi
        sub   edi, ecx
        dec   edx
        jnz   .new_y
 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+4]  ; push scale first -> for loop
 
        ; get WinMap start  -> ebp
        push  eax
        mov   eax, [0xFE00] ; screen_sx
        inc   eax
        imul  eax, ebx   ;ebx
        add   eax, [esp] ;eax
        add   eax, WinMapAddress
        mov   ebp, eax
 
        mov   edi, [edi]
;        mov   eax, esi
;        shl   eax, 5
;        add   edi, [eax+0x3000+0x10]
        pop   eax
 
        ; eax = x_start
        ; ebx = y_start
        ; ecx = x_size
        ; edx = y_size
        ; esi = process_number
        ; edi = &shape
        ;       [scale]
        push edx ecx ;ebx eax
        xor  ebx, ebx
        align 4
      .ff_new_y:
        xor  edx, edx
        align 4
      .ff_new_x:
        ; -- body --
        mov  ecx, [ff_scale]
        mov  eax, [ff_xsz]
        shr  eax, cl
        push ebx edx
        shr  ebx, cl
        shr  edx, cl
        imul eax, ebx
        add  eax, edx
        pop  edx ebx
        add  eax, edi ;[ff_shape]
        call .read_byte
;        cmp  byte [eax], 1
;        jne  @f
        test al,al
        jz   @f
        mov  eax, esi  ; [ff_proc]
        mov  [ebp], al
       @@:
        ; -- end body --
        inc  ebp
        inc  edx
        cmp  edx, [ff_xsz]
        jb   .ff_new_x
        sub  ebp, [ff_xsz]
        add  ebp, [0xFE00]  ; screen.x
        inc  ebp
        inc  ebx
        cmp  ebx, [ff_ysz]
        jb   .ff_new_y
 
        pop  ecx edx   ; eax ebx first
        add  esp, 4
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,[0xfe00]
     mov  [dlxe],eax
     mov  eax,[0xfe04]
     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,[0x3010]
     add  esi,0x10
     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,[0x3010]
     add  esi,0x10
     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;[0xFE00]
        jl      @f
        mov     [screen_workarea.left],eax
    @@: cmp     ebx,[0xFE00]
        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,[0xFE04]
        jg      .lp2
        mov     [screen_workarea.bottom],ebx
  .lp2: call	repos_windows
	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,[0x3010]
        add     ebx,[edi+0x10]        ; 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
        call    calculatescreen
        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,[0x3004]
        mov     esi,0x20*2
	mov	byte[0x0000fff0],1
        dec     ecx
        jge	@f
        ret
    @@: mov	[esi+WDATA.fl_redraw],1
	test    [esi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jz      .lp2
        mov     eax,[screen_workarea.left]
        mov     [esi+WDATA.left],eax
        sub     eax,[screen_workarea.right]
        neg     eax
        mov     [esi+WDATA.width],eax
        mov     eax,[screen_workarea.top]
        mov     [esi+WDATA.top],eax
        test    [esi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     .lp1
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [esi+WDATA.height],eax
  .lp1: add     esi,0x20
        loop    @b
        ret
  .lp2: mov	eax,[esi+WDATA.left]
	add	eax,[esi+WDATA.width]
	mov	ebx,[0x0000fe00]
;	inc	ebx
	cmp	eax,ebx
	jle	.lp4
	mov	eax,[esi+WDATA.width]
	sub	eax,ebx
	jle	.lp3
	mov	[esi+WDATA.width],ebx
  .lp3: sub	ebx,[esi+WDATA.width]
	mov	[esi+WDATA.left],ebx
  .lp4: mov	eax,[esi+WDATA.top]
	add	eax,[esi+WDATA.height]
	mov	ebx,[0x0000fe04]
;	inc	ebx
	cmp	eax,ebx
	jle	.lp6
	mov	eax,[esi+WDATA.height]
	sub	eax,ebx
	jle	.lp5
	mov	[esi+WDATA.height],ebx
  .lp5: sub	ebx,[esi+WDATA.height]
	mov	[esi+WDATA.top],ebx
  .lp6: add     esi,0x20
        loop    @b
	ret
 
uglobal
  common_colours:
     times 128 db 0x0
endg
 
 
 
 
check_window_position:
 
    pushad                           ; window inside screen ?
 
    movzx eax,word [edi+0]
    movzx ebx,word [edi+4]
    movzx ecx,word [edi+8]
    movzx edx,word [edi+12]
 
    mov   esi,ecx             ; check x pos
    add   esi,eax
    cmp   esi,[0xfe00]
    jbe   x_pos_ok
    mov   [edi+0],dword 0
    xor   eax, eax
  x_pos_ok:
 
    mov   esi,edx             ; check y pos
    add   esi,ebx
    cmp   esi,[0xfe04]
    jbe   y_pos_ok
    mov   [edi+4],dword 0
    mov   ebx,0
  y_pos_ok:
 
    mov   esi,ecx             ; check x size
    add   esi,eax
    cmp   esi,[0xfe00]
    jbe   x_size_ok
    mov   ecx,[0xfe00]
    mov   [edi+8],ecx
  x_size_ok:
 
    mov   esi,edx             ; check y size
    add   esi,ebx
    cmp   esi,[0xfe04]
    jbe   y_size_ok
    mov   edx,[0xfe04]
    mov   [edi+12],edx
  y_size_ok:
 
    popad
 
    ret
 
 
uglobal
  new_window_starting dd 0
endg
 
 
sys_window_mouse:
 
    push  eax
 
    mov   eax,[timer_ticks] ;[0xfdf0]
    cmp   [new_window_starting],eax
    jb    swml1
 
    mov   [0xfff4],byte 0  ; no mouse background
    mov   [0xfff5],byte 0  ; draw mouse
 
    mov   [new_window_starting],eax
 
  swml1:
 
    pop   eax
 
    ret
 
drawwindow_I:
 
        pushad
 
        mov   esi,[edx+24]   ; rectangle
        mov   eax,[edx+0]
        shl   eax,16
        add   eax,[edx+0]
        add   eax,[edx+8]
        mov   ebx,[edx+04]
        shl   ebx,16
        add   ebx,[edx+4]
        add   ebx,[edx+12]
        call  draw_rectangle
 
        mov   ecx,[edx+20]   ; grab bar
        push  ecx
        mov   esi,edx
        mov   edx,[esi+04]
        add   edx,1
        mov   ebx,[esi+04]
        add   ebx,25
        mov   eax,[esi+04]
        add   eax,[esi+12]
        cmp   ebx,eax
        jb    wdsizeok
        mov   ebx,eax
      wdsizeok:
        push  ebx
      drwi:
        mov   ebx,edx
        shl   ebx,16
        add   ebx,edx
        mov   eax,[esi+00]
        inc   eax
        shl   eax,16
        add   eax,[esi+00]
        add   eax,[esi+8]
        sub   eax,1
        push  edx
        mov   edx,0x80000000
        mov   ecx,[esi+20]
        and   ecx,edx
        cmp   ecx,edx
        jnz   nofa
        mov   ecx,[esi+20]
        sub   ecx,0x00040404
        mov   [esi+20],ecx
        and   ecx,0x00ffffff
        jmp   faj
      nofa:
        mov   ecx,[esi+20]
        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+20],ecx
 
        mov   edx,[esi+04]      ; inside work area
        add   edx,21+5
        mov   ebx,[esi+04]
        add   ebx,[esi+12]
        cmp   edx,ebx
        jg    noinside
        mov   eax,1
        mov   ebx,21
        mov   ecx,[esi+8]
        mov   edx,[esi+12]
        mov   edi,[esi+16]
        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:
 
        pushad
 
        mov   edi,edx                              ; RECTANGLE
        mov   eax,[edi+0]
        shl   eax,16
        mov   ax,[edi+0]
        add   ax,[edi+8]
        mov   ebx,[edi+4]
        shl   ebx,16
        mov   bx,[edi+4]
        add   bx,[edi+12]
        mov   esi,[edi+24]
        shr   esi,1
        and   esi,0x007f7f7f
        push  esi
        call  draw_rectangle
        mov   ecx,3
      dw3l:
        add   eax,1*65536-1
        add   ebx,1*65536-1
        mov   esi,[edi+24]
        call  draw_rectangle
        dec   ecx
        jnz   dw3l
        pop   esi
        add   eax,1*65536-1
        add   ebx,1*65536-1
        call  draw_rectangle
 
        mov   ecx,[edx+20]                       ; GRAB BAR
        push  ecx
        mov   esi,edx
        mov   edx,[esi+04]
        add   edx,4
        mov   ebx,[esi+04]
        add   ebx,20
        mov   eax,[esi+04]
        add   eax,[esi+12]
        cmp   ebx,eax
        jb    wdsizeok2
        mov   ebx,eax
      wdsizeok2:
        push  ebx
      drwi2:
        mov   ebx,edx
        shl   ebx,16
        add   ebx,edx
        mov   eax,[esi+00]
        shl   eax,16
        add   eax,[esi+00]
        add   eax,[esi+8]
        add   eax,4*65536-4
        mov   ecx,[esi+20]
        test  ecx,0x40000000
        jz    nofa3
        add   ecx,0x040404
      nofa3:
        test  ecx,0x80000000
        jz    nofa2
        sub   ecx,0x040404
      nofa2:
        mov   [esi+20],ecx
        and   ecx,0xffffff
        xor   edi, edi
        call  [draw_line]
        inc   edx
        cmp   edx,[esp]
        jb    drwi2
        add   esp,4
        pop   ecx
        mov   [esi+20],ecx
 
        mov   edx,[esi+04]                       ; WORK AREA
        add   edx,21+5
        mov   ebx,[esi+04]
        add   ebx,[esi+12]
        cmp   edx,ebx
        jg    noinside2
        mov   eax,5
        mov   ebx,20
        mov   ecx,[esi+8]
        mov   edx,[esi+12]
        sub   ecx,4
        sub   edx,4
        mov   edi,[esi+16]
        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, [0x3004]
        movzx eax, word [0xC400 + 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 [0xC000+eax*2] ; ax <- position in window stack
 
        xor   esi, esi        ; drop others
      waloop:
        cmp   esi, dword [0x3004]
        jae   wacont
        inc   esi
        lea   edi, [0xC000 + 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, [0x3004]  ; number of processes
        mov   [0xC000+eax*2], bx     ; this is the last (and the upper)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        ; update on screen -window stack
        xor   esi, esi
      waloop2:
        mov   edi, [0x3004]
        cmp   esi, edi
        jae   wacont2
        inc   esi
        movzx ebx, word [esi*2 + 0xC000]
        mov   [ebx*2 + 0xC400], si
        jmp   waloop2
      wacont2:
        mov   [0xf400], byte 0           ; empty keyboard buffer
        mov   [0xf500], 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 [0xC000 + esi * 2] ; get value of the curr process
 
        lea   esi, [0xC400 + eax * 2]      ; get address of this process at 0xC400
 
        push  esi
 
      .new_check:
 
        pop   esi
        add   esi, 2
        push  esi
 
        mov   eax, [0x3004]
        lea   eax, word [0xC400 + eax * 2] ; number of the upper window
 
        cmp   esi, eax
        ja    .all_wnds_to_top
 
        movzx eax, word [esi]
        shl   eax, 5
        cmp   [0x3000 + eax + 0xa], byte 9
        je    .new_check                    ; skip dead windows
 
        lea   esi, [eax+window_data]
 
        mov   ebx, [edi+4]  ; y0
        mov   edx, [edi+12]
        add   edx, ebx      ; y0e
 
        mov   ecx, [esi+4]  ; y  ; y check
        cmp   ecx, edx      
        jae   .new_check     ; y < y0e
        mov   eax, [esi+12]
        add   ecx, eax       ; ye
        cmp   ebx, ecx       ; y0 >= ye
        ja    .new_check
 
        mov   eax, [edi+0]   ; x0
        mov   ecx, [edi+8]
        add   ecx, eax       ; x0e
 
        mov   edx, [esi+0]   ; x ; x check
        cmp   edx, ecx
        jae   .new_check     ; x < x0e
        mov   ecx, [esi+8]
        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   [0xfb44], byte 1     ; do draw mouse
        call  windowactivate
 
        ; update screen info
        pushad
        mov   edi, [0x3004] ; the last process (number)
        movzx esi, word [0xC400 + edi * 2]
        shl   esi, 5
        add   esi, window_data
 
        ; coordinates of the upper window
        mov   eax, [esi+00] ; cx
        mov   ebx, [esi+04] ; cy
        mov   ecx, [esi+08] ; sx
        mov   edx, [esi+12] ; sy
 
        add   ecx, eax       ; ecx = x_end
        add   edx, ebx       ; edx = y_end
 
        mov   edi, [0x3004]
        movzx esi, word [0xC400 + edi * 2]
        call  setscreen
 
 
        popad
 
        cmp   [0xff01], dword 1 ; if > 1 then activate process
        jbe   .not_activate
 
;;;        mov   eax, 10            ; wait for putimages to finish
;;;        call  delay_hs
 
        mov   [edi+31],byte 1  ; redraw flag for app
        mov   [0xfb44],byte 0  ; mouse down checks
 
        ret
 
     .not_activate:
 
;        mov   eax,5            ; wait for putimages to finish
;        call  delay_hs
 
        mov   [edi+31],byte 1  ; redraw flag for app
 
        mov   ecx, 25 ;100
     .waitflagdown:
        dec   ecx
        jz    .nowait
;        mov   eax, 2
;        call  delay_hs
        cmp   [edi+31], byte 0 ; wait flag to drop
        jnz   .waitflagdown
      .nowait:
 
;        mov   ecx,10
;      .wait:
;        mov   eax,1           ; wait for draw to finish
;        call  delay_hs
;        loop  .wait
 
        mov   [0xfb44],byte 0
 
        ret
 
     .do_not_draw:
 
        popad
 
        call  windowactivate
        mov   [0xfb44],byte 0  ; mouse down checks
        mov   [0xfff4],byte 0  ; no mouse background
        mov   [0xfff5],byte 0  ; draw mouse
        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  [0xff01],dword 1  ; activate request from app ?
        jbe  .no_activate_request
        mov  edi,[0xff01]     ; process number
        shl  edi,5
        add  edi,window_data
        mov  ebx,[0xff01]
        movzx esi, word [0xC000 + ebx * 2]
        lea  esi, [0xC400 + esi * 2]
        call waredraw
 
 
 
 
 
 
        mov  [0xff01],dword 0  ; activated
 
        popad
        ret
 
    .no_activate_request:
    
        cmp   [0xfb40],byte 0    ; mouse buttons pressed ?
        jne   .mouse_buttons_pressed
 
 
        cmp   [window_minimize],0
        je   .no_activate_request_2
        cmp   [window_minimize],1
        je    .mouse_buttons_pressed
        mov   esi,[0x3004]
        movzx edi, word [0xC400 + esi * 2]
        shl   edi, 5
        add   edi, window_data
        test    [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
        jnz     .mouse_buttons_pressed
 
 
 
 
 
    .no_activate_request_2:
        mov   [window_minimize],0
        popad
        ret
 
    .mouse_buttons_pressed:
 
        mov   esi,[0x3004]
        inc   esi
 
      cwloop:
        cmp   esi,2
        jb   .exit
        .temp_window_minimize_1:
        dec   esi
        movzx edi, word [0xC400 + esi * 2] ; ebx
        shl   edi, 5
        add   edi, window_data
;        mov   edi, ebx
        mov   ecx, [edi+0]
        mov   edx, [edi+4]
 
        mov   eax,ecx
        mov   ebx,edx
       cmp   [window_minimize],1
       jge   .window_minimize_no_check_mouse
        test    [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
        jnz     cwloop
 
       movzx  eax, word [0xfb0a]
       movzx  ebx, word [0xfb0c]
       
        cmp   ecx, eax
        jae   cwloop
        cmp   edx, ebx
        jae   cwloop
        add   ecx, [edi+8]
        add   edx, [edi+12]
        cmp   eax, ecx
        jae   cwloop
        cmp   ebx, edx
        jae   cwloop
 
      .window_minimize_no_check_mouse:
 
        pushad
        mov   eax, esi
        mov   ebx, [0x3004]
        cmp   eax, ebx      ; is this window active?
        jz    .move_resize_window
 
        ; eax = position in windowing stack
        ; redraw must ?
        lea   esi, [0xC400 + 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+0x14]
        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+0x10]
        and   edx, 0x0f000000
        cmp   edx, 0x02000000
        jb    .no_resize_2 ; not type 2 wnd
 
        mov   edx, [edi+4]
        add   edx, [edi+12]
        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+4]
        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] ;[0xfdf0]    ; double-click ?
        mov   edx, ecx
        sub   edx, [latest_window_touch]
        mov   [latest_window_touch], ecx
        mov   [latest_window_touch_delta], edx
 
        mov   cl, [0xfb40]     ; save for shade check
        mov   [do_resize], cl
     no_emulation_righ_button:
        mov   ecx, [edi+0]
        mov   edx, [edi+4]
 
        push  eax ecx edx
        mov   [dlx], ecx      ; save for drawlimits
        mov   [dly], edx
        mov   eax, [edi+8]
        add   ecx, eax
        mov   eax, [edi+12]
        add   edx, eax
        mov   [dlxe], ecx
        mov   [dlye], edx
        pop   edx ecx eax
 
        sub   eax, ecx
        sub   ebx, edx
 
        mov   esi, [0xfb0a]
        mov   [0xf300], esi
 
        pushad           ; wait for putimages to finish
;        mov   eax,5
;        call  delay_hs
        mov   eax,[edi+0]
        mov   [npx],eax
        mov   eax,[edi+4]
        mov   [npy],eax
        popad
 
        push eax                  ; save old coordinates
        mov   ax,[edi+00]
        mov   word [oldc+00],ax
        mov   ax,[edi+04]
        mov   word [oldc+04],ax
        mov   ax,[edi+8]
        mov   word [oldc+8],ax
        mov   word [npxe],ax
        mov   ax,[edi+12]
        mov   word [oldc+12],ax
        mov   word [npye],ax
        pop eax
 
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        call  drawwindowframes
    @@:
 
        mov   [reposition],0
        mov   [0xfb44],byte 1   ; no reaction to mouse up/down
 
        ; move window
 
      newchm:
 
        mov   [0xfff5],byte 1
 
        call  checkidle
 
        call  checkEgaCga
 
        mov   [0xfff4],byte 0
 
        call  [draw_pointer]
 
        pushad
        call   stack_handler
        popad
 
        mov   esi,[0xf300]
        cmp   esi,[0xfb0a]
        je    cwb
 
        mov   cx,[0xfb0a]
        mov   dx,[0xfb0c]
        sub   cx,ax
        sub   dx,bx
 
        push  ax
        push  bx
 
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        call  drawwindowframes
    @@:
 
        mov   ax,[0xfe00]
        mov   bx,[0xfe04]
 
        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+
 
        movzx eax,word [0xfb0a]
        cmp   eax,[edi+0]
        jb    nnepx
        sub   eax,[edi+0]
        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 [0xfb0c]
        cmp   eax,[edi+4]
        jb    nnepy
        sub   eax,[edi+4]
        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
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        call  drawwindowframes
    @@:
 
        mov   esi,[0xfb0a]
        mov   [0xf300],esi
 
      cwb:
        cmp   [0xfb40],byte 0
        jne   newchm 
                                     ; new position done
        mov     [0xfff5],byte 1
        mov     cl,0
        test    [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
        jnz     @f
        mov     cl,[reposition]
        call    drawwindowframes
 
        mov   eax,[npx]
        mov   [edi+0],eax
        mov   eax,[npy]
        mov   [edi+4],eax
        mov   eax,[npxe]
        mov   [edi+8],eax
        mov   eax,[npye]
        mov   [edi+12],eax
 
    @@: 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,0x80000+0x90
        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,0x80000                 ; process base at 0x80000+
 
        cmp     [window_minimize],0
        je      no_wnd_minimize_restore
        mov     [reposition],1
  wnd_minimize:
        cmp     [window_minimize],1
        jne     wnd_restore
        or      [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
        jmp     no_wnd_minimize_restore
  wnd_restore:
        cmp     [window_minimize],2
        jne     no_wnd_minimize_restore
        and     [edi+WDATA.fl_wstate],not WSTATE_MINIMIZED
  no_wnd_minimize_restore:
 
 
        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+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.height],eax
 
      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.left],eax
        sub     eax,[screen_workarea.right]
        neg     eax
        mov     [edi+WDATA.width],eax
        mov     eax,[screen_workarea.top]
        mov     [edi+WDATA.top],eax
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jnz     @f
        sub     eax,[screen_workarea.bottom]
        neg     eax
        mov     [edi+WDATA.height],eax
    @@:
        jmp   no_fullscreen_restore
      restore_from_fullscreen:
        and     [edi+WDATA.fl_wstate],not WSTATE_MAXIMIZED
        push    [edi+WDATA.height]
        push  edi                         ; restore
        lea   esi, [edx + 0x90]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
        pop     eax
        test    [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
        jz      @f
        mov     [edi+WDATA.height],eax
    @@:
 
      no_fullscreen_restore:
 
        mov   eax,[edi+4]                 ; check Y inside screen
        add   eax,[edi+12]
        cmp   eax,[0xfe04]
        jbe   no_window_sizing
        mov   eax,[edi+0]                 ; check X inside screen
        add   eax,[edi+8]
        cmp   eax,[0xfe00]
        jbe   no_window_sizing
        mov   eax,[0xfe00]
        sub   eax,[edi+8]
        mov   [edi+0],eax
        mov   eax,[0xfe04]
        sub   eax,[edi+12]
        mov   [edi+4],eax
      no_window_sizing:
 
        popad
 
        cmp   [reposition],0
        je    retwm
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        mov     [edi+WDATA.fl_redraw],1
        mov   [0xfff5],byte 1 ; no mouse
 
        push  eax ebx ecx edx
        mov   eax,[oldc+00]
        mov   ebx,[oldc+04]
        mov   ecx,[oldc+8]
        mov   edx,[oldc+12]
        add   ecx,eax
        add   edx,ebx
        call  calculatescreen
        pop   edx ecx ebx eax
 
        mov   eax,edi
        call  redrawscreen
 
        mov   ecx,100         ; wait to avoid mouse residuals
      waitre2:
        mov   [0xfff5],byte 1
        call  checkidle
        cmp     [edi+WDATA.fl_redraw],0
        jz    retwm
        loop  waitre2
 
      retwm:
 
        mov   [0xfff5],byte 0 ; mouse pointer
        mov   [0xfff4],byte 0 ; no mouse under
        mov   [0xfb44],byte 0 ; react to mouse up/down
 
        mov    esi,window_moved
        call   sys_msg_board_str
 
        popad
 
       mov   [window_minimize],0
 
        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
 
drawwindowframes:
 
        pushad
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        mov   eax,[npx]
        shl   eax,16
        add   eax,[npx]
        mov   ebx,[npy]
        shl   ebx,16
        add   ebx,[npy]
        add   ebx,[npye]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        pop   edi
 
        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]
        mov   ecx,0x01000000
        push  edi
        mov   edi,1
        call  [draw_line]
        mov   edi,[0x3000]
        shl   edi,5
        add   edi,window_data
        mov   [edi+30],byte 1
        pop   edi
 
        popad
 
        ret
 
 
 
random_shaped_window:
 
;
;  eax = 0    giving address of data area
;      ebx    address
;  ebx = 1    shape area scale
;      ebx    2^ebx scale
 
     test eax, eax
     jne  rsw_no_address
     mov  eax,[0x3000]
     shl  eax,8
 
     mov  [eax+0x80000+0x80],ebx
   rsw_no_address:
 
     cmp  eax,1
     jne  rsw_no_scale
     mov  eax,[0x3000]
     shl  eax,8
     mov  [eax+0x80000+0x84],bl
   rsw_no_scale:
 
     ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 57 → 102