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


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
        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
        add   edi, window_data
        mov   eax, [edi+0]
        mov   ebx, [edi+4]
        mov   ecx, [edi+8]
        test  ecx, ecx
        jz    .not_wnd
        add   ecx, eax
        mov   edx, [edi+12]
        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:
        sti
        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
 
 
     pushad
 
     test eax, eax      ; redraw display
     jnz  dspl0
     test ebx, ebx
     jnz  dspl0
     cmp  [windowtypechanged],dword 1
     jne  dspl00
     mov  [windowtypechanged],dword 0
     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:
 
     popad
     ret
 
uglobal
  common_colours:
     times 128 db 0x0
endg
 
check_window_move_request:
 
        pushad
 
        mov   edi,[window_move_pr]    ; requestor process base
 
        cmp   edi,0
        je    window_move_return
 
        shl   edi,5
        add   edi,window_data
 
        push  dword [edi+0]           ; save old coordinates
        push  dword [edi+4]
        push  dword [edi+8]
        push  dword [edi+12]
 
        mov   eax,[window_move_eax]
        mov   ebx,[window_move_ebx]
        mov   ecx,[window_move_ecx]
        mov   edx,[window_move_edx]
 
        cmp   eax,-1                  ; set new position and size
        je    no_x_reposition
        mov   [edi+0],eax
      no_x_reposition:
        cmp   ebx,-1
        je    no_y_reposition
        mov   [edi+4],ebx
      no_y_reposition:
        cmp   ecx,-1
        je    no_x_resizing
        mov   [edi+8],ecx
      no_x_resizing:
        cmp   edx,-1
        je    no_y_resizing
        mov   [edi+12],edx
      no_y_resizing:
 
        call  check_window_position
 
        pushad                       ; save for window fullscreen/resize
        mov   esi,edi
        sub   edi,window_data
        shr   edi,5
        shl   edi,8
        add   edi,0x80000+0x90
        mov   ecx,4
        cld
        rep   movsd
        popad
 
        pushad                       ; calculcate screen at new position
        mov   eax,[edi+00]
        mov   ebx,[edi+04]
        mov   ecx,[edi+8]
        mov   edx,[edi+12]
        add   ecx,eax
        add   edx,ebx
        call  calculatescreen
        popad
 
        pop   edx                   ; calculcate screen at old position
        pop   ecx
        pop   ebx
        pop   eax
        add   ecx,eax
        add   edx,ebx
        mov   [dlx],eax             ; save for drawlimits
        mov   [dly],ebx
        mov   [dlxe],ecx
        mov   [dlye],edx
        call  calculatescreen
 
        mov   [edi+31],byte 1       ; flag the process as redraw
 
        mov   eax,edi               ; redraw screen at old position
        xor   esi,esi
        call  redrawscreen
 
        mov   [0xfff5],byte 0 ; mouse pointer
        mov   [0xfff4],byte 0 ; no mouse under
        mov   [0xfb44],byte 0 ; react to mouse up/down
 
        mov   ecx,10          ; wait 1/10 second
      wmrl3:
 
        call  [draw_pointer]
        mov   eax,1
        call  delay_hs
        loop  wmrl3
 
        mov   [window_move_pr],0
 
      window_move_return:
 
        popad
 
        ret
 
 
 
 
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
     ;<<< 14.11.2004 Ivan Poddubny  
;        mov   eax,r_eax
;        shl   eax,16
;        mov   ax,r_ax
        mov   eax, r_eax
        rol   eax, 16
     ;>>> 14.11.2004 Ivan Poddubny  
        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
 
        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)
 
;* start code - get active process (4) - Mario79
        cli
        cmp  [active_process_flag],1
        jne  @f
        mov   [active_process_flag],0
        jmp   end_save_active_process
    @@:
        call save_active_process_stack
    end_save_active_process:
        mov  [active_process],eax
        push  eax
        mov   eax,[active_process]
        shl   eax,5
        add   eax,0x3000
        mov   [eax-twdw+31],byte 1
        pop   eax
        sti
;* end code - get active process (4) - Mario79
 
        ; 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   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
        add   eax, window_data
        mov   esi, eax
 
        mov   ebx, [edi+4]
        mov   edx, [edi+12]
        add   edx, ebx
 
        mov   ecx, [esi+4]    ; y check
        cmp   ecx, edx
        jae   .new_check
        mov   eax, [esi+12]
        add   ecx, eax
        cmp   ebx, ecx
        ja    .new_check
 
        mov   eax, [edi+0]
        mov   ecx, [edi+8]
        add   ecx, eax
 
        mov   edx, [esi+0]    ; x check
        cmp   edx, ecx
        jae   .new_check
        mov   ecx, [esi+8]
        add   edx, ecx
        cmp   eax, edx
        ja    .new_check
 
        pop   esi
        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]
        shl   esi, 5
        movzx esi, byte [esi + 0x3000 + 0xE]
        call  setscreen ;;;calculatescreen ; 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
 
;* start code - get active process (2) - Mario79
;        mov  eax,[0xff01]
;        mov  [active_process],eax
;* end code - get active process  (2) - Mario79
 
        mov  [0xff01],dword 0  ; activated
 
        popad
        ret
 
    .no_activate_request:
    
        cmp   [0xfb40],byte 0    ; mouse buttons pressed ?
        jne   .mouse_buttons_pressed
;        cmp   [window_minimize],2
;        jne   .no_activate_request_1
        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
        cmp   [edi+12],dword 0
        je    .mouse_buttons_pressed
;        jne   .no_activate_request_2
;    .no_activate_request_1:
;        cmp   [window_minimize],1
;        jge   .mouse_buttons_pressed
;        jmp   .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
 
       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:
 
        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:
 
;// mike.dld [
        mov   dl,[edi+0x10+3]
        and   dl,0x0F
        cmp   dl,0x03
        jne   @f
        mov   edx, [edi+4] ; check if touch on bar
        add   edx, [_skinh]
        cmp   ebx, edx
        jae   .exit
        jmp   .continue
    @@:
;// mike.dld ]
 
        mov   edx, [edi+4] ; check if touch on bar
        add   edx, 21
        cmp   ebx, edx
        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
        cmp  [window_minimize],0
        je    no_emulation_righ_button
        mov   [do_resize], byte 2
     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
 
        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
 
        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,[edx+0x90+8]
        jge   nnepx2
        mov   eax,[edx+0x90+8]
      nnepx2:
        mov   [npxe],eax
      nnepx:
 
        movzx eax,word [0xfb0c]
        cmp   eax,[edi+4]
        jb    nnepy
        sub   eax,[edi+4]
        cmp   eax,23 ; [edx+0x90+12]
        jge   nnepy2
        mov   eax,23 ; [edx+0x90+12]
      nnepy2:
        mov   [npye],eax
      nnepy:
 
        mov   [reposition],1
 
        popad
      norepos_size:
 
        pop   bx
        pop   ax
        call  drawwindowframes
 
        mov   esi,[0xfb0a]
        mov   [0xf300],esi
 
      cwb:
        cmp   [0xfb40],byte 0
        jne   newchm 
                                     ; new position done
        call  drawwindowframes
        mov   [0xfff5],byte 1
 
        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
 
        cmp   [reposition],1         ; save new X and Y start
        jne   no_xy_save
        ; 
        push  esi edi ecx
        mov   esi,edi
        sub   edi,window_data
        shr   edi,5
        shl   edi,8
        add   edi,0x80000+0x90
        mov   ecx,2
        cld
        rep   movsd
        pop   ecx edi esi
        ; 
      no_xy_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   [do_resize],2               ; window shade ?
        jb    no_window_shade
        mov   [reposition],1
 
        cmp   [window_minimize],1
        jge    for_window_minimize
        cmp   [edi+12],dword 23 
        jle    window_shade_up
        jmp   for_window_shade
    for_window_minimize:
        cmp   [edi+12],dword 0 
        je    window_shade_up
    for_window_shade:
        cmp   [window_minimize],0
        je   no_window_minimize
        cmp   [window_minimize],2
        je   window_minimize_no_shade_full ;window_shade_up
        mov   [edi+8],dword 0 ;66
        mov   [edi+12],dword 0 ;279           ; on
        jmp   no_window_shade
  no_window_minimize:  
        mov   [edi+12],dword 23           ; on
        jmp   no_window_shade
      window_shade_up:
        cmp   [window_minimize],1
        jge   window_minimize_no_shade_full
        mov   eax,[edi+0]
        add   eax,[edi+4]
        test  eax, eax
        je    shade_full
        push  edi 
        lea   esi, [edx + 0x90]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
 
    window_minimize_no_shade_full:
;        mov   eax,[edx+0x90]              ; off
;        mov   [edi+0],eax
;        mov   eax,[edx+0x94]              ; off
;        mov   [edi+4],eax
;        mov   eax,[edx+0x98]              ; off
;        mov   [edi+8],eax
;        mov   eax,[edx+0x9C]              ; off
;        mov   [edi+12],eax
 
        push  edi 
        lea   esi, [edx + 0x90]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
        jmp   no_window_shade
 
      shade_full:
;        mov   eax,[0xfe00]
;        mov   [edi+8],eax
        mov   eax,[0xfe04]
        sub   eax,19
        mov   [edi+12],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
        mov   eax,[edi+12]
        add   eax,19
        cmp   eax,[0xfe04]
        je    restore_from_fullscreen
        mov   [edi+0],dword 0             ; set fullscreen
        mov   [edi+4],dword 0
        mov   eax,[0xfe00]
        mov   [edi+8],eax
        mov   eax,[0xfe04]
        sub   eax,19
        mov   [edi+12],eax
        jmp   no_fullscreen_restore
      restore_from_fullscreen:
        push  edi                         ; restore
;        mov   esi,edx
;        add   esi,0x90
        lea   esi, [edx + 0x90]
        mov   ecx,4
        cld
        rep   movsd
        pop   edi
 
      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
 
        pushad
        mov   eax,[edi+00]
        mov   ebx,[edi+04]
        mov   ecx,[edi+8]
        mov   edx,[edi+12]
        add   ecx,eax
        add   edx,ebx
        mov   edi,[0x3004]
        shl   edi,1
        add   edi,0xc400
        movzx esi,byte [edi]
        shl   esi,5
        add   esi,0x3000+0xe
        movzx esi,byte [esi]
 
        sub   edi,draw_data
        shr   edi,5
        shl   edi,8
        add   edi,0x80000+0x80
        ;cmp   [edi],dword 0
        ;jne   no_rect_shaped_move
        call  setscreen
        jmp   move_calculated
      no_rect_shaped_move:
        call  calculatescreen
      move_calculated:
 
        popad
 
        mov   [edi+31],byte 1 ; mark first as redraw
        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+31],byte 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
;        sti
        ret
 
;temp_mouse_1 dw 0
;temp_mouse_2 dw 0
 
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 2	Rev 33
1	setwindowdefaults:	1	setwindowdefaults:
2	pushad	2	pushad
3		3
4	xor eax,eax	4	xor eax,eax
5	mov ecx,0xc000	5	mov ecx,0xc000
6	@@:	6	@@:
7	inc eax	7	inc eax
8	add ecx,2	8	add ecx,2
9	mov [ecx+0x000],ax ; process no	9	mov [ecx+0x000],ax ; process no
10	mov [ecx+0x400],ax ; positions in stack	10	mov [ecx+0x400],ax ; positions in stack
11	cmp ecx,0xc400-2 ; the more high, the more surface	11	cmp ecx,0xc400-2 ; the more high, the more surface
12	jnz @b	12	jnz @b
13		13
14	popad	14	popad
15	ret	15	ret
16		16
17		17
18		18
19	; eax = cx	19	; eax = cx
20	; ebx = cy	20	; ebx = cy
21	; ecx = ex	21	; ecx = ex
22	; edx = ey	22	; edx = ey
23	; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,	23	; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,
24	; è äëÿ êàæäîãî âûçâàòü setscreen	24	; è äëÿ êàæäîãî âûçâàòü setscreen
25	align 4	25	align 4
26	calculatescreen:	26	calculatescreen:
27	pushad	27	pushad
28	cli	28	cli
29		29
30	mov esi, 1	30	mov esi, 1
31	xor eax, eax	31	xor eax, eax
32	xor ebx, ebx	32	xor ebx, ebx
33	mov ecx, [0xFE00]	33	mov ecx, [0xFE00]
34	mov edx, [0xFE04]	34	mov edx, [0xFE04]
35	call setscreen	35	call setscreen
36		36
37	mov ebp, [0x3004] ; number of processes	37	mov ebp, [0x3004] ; number of processes
38	cmp ebp, 1	38	cmp ebp, 1
39	jbe .finish	39	jbe .finish
40	align 4	40	align 4
41	.new_wnd:	41	.new_wnd:
42	movzx edi, word [0xC400 + esi * 2]	42	movzx edi, word [0xC400 + esi * 2]
43	shl edi, 5	43	shl edi, 5
44	add edi, window_data	44	add edi, window_data
45	mov eax, [edi+0]	45	mov eax, [edi+0]
46	mov ebx, [edi+4]	46	mov ebx, [edi+4]
47	mov ecx, [edi+8]	47	mov ecx, [edi+8]
48	test ecx, ecx	48	test ecx, ecx
49	jz .not_wnd	49	jz .not_wnd
50	add ecx, eax	50	add ecx, eax
51	mov edx, [edi+12]	51	mov edx, [edi+12]
52	add edx, ebx	52	add edx, ebx
53	push esi	53	push esi
54	movzx esi, word [0xC400 + esi * 2]	54	movzx esi, word [0xC400 + esi * 2]
55	call setscreen	55	call setscreen
56	pop esi	56	pop esi
57	.not_wnd:	57	.not_wnd:
58	inc esi	58	inc esi
59	dec ebp	59	dec ebp
60	jnz .new_wnd	60	jnz .new_wnd
61	.finish:	61	.finish:
62	sti	62	sti
63	popad	63	popad
64	ret	64	ret
65		65
66		66
67		67
68	virtual at esp	68	virtual at esp
69	ff_xsz dd ?	69	ff_xsz dd ?
70	ff_ysz dd ?	70	ff_ysz dd ?
71	ff_scale dd ?	71	ff_scale dd ?
72	end virtual	72	end virtual
73		73
74	align 4	74	align 4
75	; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà	75	; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà
76	setscreen:	76	setscreen:
77	; eax x start	77	; eax x start
78	; ebx y start	78	; ebx y start
79	; ecx x end	79	; ecx x end
80	; edx y end	80	; edx y end
81	; esi process number	81	; esi process number
82	pushad	82	pushad
83	mov edi, esi ;;;word [esi*2+0xc400]	83	mov edi, esi ;;;word [esi*2+0xc400]
84	shl edi, 8	84	shl edi, 8
85	add edi, 0x80000+0x80 ; address of random shaped window area	85	add edi, 0x80000+0x80 ; address of random shaped window area
86	cmp [edi], dword 0	86	cmp [edi], dword 0
87	jne .free_form	87	jne .free_form
88		88
89	; get x&y size	89	; get x&y size
90	sub ecx, eax	90	sub ecx, eax
91	sub edx, ebx	91	sub edx, ebx
92	inc ecx	92	inc ecx
93	inc edx	93	inc edx
94		94
95	; get WinMap start	95	; get WinMap start
96	mov edi, [0xFE00] ; screen_sx	96	mov edi, [0xFE00] ; screen_sx
97	inc edi	97	inc edi
98	imul edi, ebx	98	imul edi, ebx
99	add edi, eax	99	add edi, eax
100	add edi, WinMapAddress	100	add edi, WinMapAddress
101		101
102	.new_y:	102	.new_y:
103	push ecx ; sx	103	push ecx ; sx
104	push edx	104	push edx
105		105
106	mov edx, esi	106	mov edx, esi
107	align 4	107	align 4
108	.new_x:	108	.new_x:
109	mov byte [edi], dl	109	mov byte [edi], dl
110	inc edi	110	inc edi
111	dec ecx	111	dec ecx
112	jnz .new_x	112	jnz .new_x
113		113
114	pop edx	114	pop edx
115	pop ecx	115	pop ecx
116	add edi, [0xFE00]	116	add edi, [0xFE00]
117	inc edi	117	inc edi
118	sub edi, ecx	118	sub edi, ecx
119	dec edx	119	dec edx
120	jnz .new_y	120	jnz .new_y
121	popad	121	popad
122	ret	122	ret
123	.read_byte:	123	.read_byte:
124	;eax - address	124	;eax - address
125	;esi - slot	125	;esi - slot
126	push eax	126	push eax
127	push ebx	127	push ebx
128	push ecx	128	push ecx
129	push edx	129	push edx
130	mov edx,eax	130	mov edx,eax
131	mov eax,esi	131	mov eax,esi
132	lea ebx,[esp+12]	132	lea ebx,[esp+12]
133	mov ecx,1	133	mov ecx,1
134	call read_process_memory	134	call read_process_memory
135	pop edx	135	pop edx
136	pop ecx	136	pop ecx
137	pop ebx	137	pop ebx
138	pop eax	138	pop eax
139	ret	139	ret
140	.free_form:	140	.free_form:
141		141
142	; for (y=0; y <= x_size; y++)	142	; for (y=0; y <= x_size; y++)
143	; for (x=0; x <= x_size; x++)	143	; for (x=0; x <= x_size; x++)
144	; if (shape[coord(x,y,scale)]==1)	144	; if (shape[coord(x,y,scale)]==1)
145	; set_pixel(x, y, process_number);	145	; set_pixel(x, y, process_number);
146		146
147	sub ecx, eax	147	sub ecx, eax
148	sub edx, ebx	148	sub edx, ebx
149	inc ecx	149	inc ecx
150	inc edx	150	inc edx
151		151
152	push dword [edi+4] ; push scale first -> for loop	152	push dword [edi+4] ; push scale first -> for loop
153		153
154	; get WinMap start -> ebp	154	; get WinMap start -> ebp
155	push eax	155	push eax
156	mov eax, [0xFE00] ; screen_sx	156	mov eax, [0xFE00] ; screen_sx
157	inc eax	157	inc eax
158	imul eax, ebx ;ebx	158	imul eax, ebx ;ebx
159	add eax, [esp] ;eax	159	add eax, [esp] ;eax
160	add eax, WinMapAddress	160	add eax, WinMapAddress
161	mov ebp, eax	161	mov ebp, eax
162		162
163	mov edi, [edi]	163	mov edi, [edi]
164	; mov eax, esi	164	; mov eax, esi
165	; shl eax, 5	165	; shl eax, 5
166	; add edi, [eax+0x3000+0x10]	166	; add edi, [eax+0x3000+0x10]
167	pop eax	167	pop eax
168		168
169	; eax = x_start	169	; eax = x_start
170	; ebx = y_start	170	; ebx = y_start
171	; ecx = x_size	171	; ecx = x_size
172	; edx = y_size	172	; edx = y_size
173	; esi = process_number	173	; esi = process_number
174	; edi = &shape	174	; edi = &shape
175	; [scale]	175	; [scale]
176	push edx ecx ;ebx eax	176	push edx ecx ;ebx eax
177	xor ebx, ebx	177	xor ebx, ebx
178	align 4	178	align 4
179	.ff_new_y:	179	.ff_new_y:
180	xor edx, edx	180	xor edx, edx
181	align 4	181	align 4
182	.ff_new_x:	182	.ff_new_x:
183	; -- body --	183	; -- body --
184	mov ecx, [ff_scale]	184	mov ecx, [ff_scale]
185	mov eax, [ff_xsz]	185	mov eax, [ff_xsz]
186	shr eax, cl	186	shr eax, cl
187	push ebx edx	187	push ebx edx
188	shr ebx, cl	188	shr ebx, cl
189	shr edx, cl	189	shr edx, cl
190	imul eax, ebx	190	imul eax, ebx
191	add eax, edx	191	add eax, edx
192	pop edx ebx	192	pop edx ebx
193	add eax, edi ;[ff_shape]	193	add eax, edi ;[ff_shape]
194	call .read_byte	194	call .read_byte
195	; cmp byte [eax], 1	195	; cmp byte [eax], 1
196	; jne @f	196	; jne @f
197	test al,al	197	test al,al
198	jz @f	198	jz @f
199	mov eax, esi ; [ff_proc]	199	mov eax, esi ; [ff_proc]
200	mov [ebp], al	200	mov [ebp], al
201	@@:	201	@@:
202	; -- end body --	202	; -- end body --
203	inc ebp	203	inc ebp
204	inc edx	204	inc edx
205	cmp edx, [ff_xsz]	205	cmp edx, [ff_xsz]
206	jb .ff_new_x	206	jb .ff_new_x
207	sub ebp, [ff_xsz]	207	sub ebp, [ff_xsz]
208	add ebp, [0xFE00] ; screen.x	208	add ebp, [0xFE00] ; screen.x
209	inc ebp	209	inc ebp
210	inc ebx	210	inc ebx
211	cmp ebx, [ff_ysz]	211	cmp ebx, [ff_ysz]
212	jb .ff_new_y	212	jb .ff_new_y
213		213
214	pop ecx edx ; eax ebx first	214	pop ecx edx ; eax ebx first
215	add esp, 4	215	add esp, 4
216	popad	216	popad
217	ret	217	ret
218		218
219		219
220	display_settings:	220	display_settings:
221		221
222	; eax = 0 ; DISPLAY redraw	222	; eax = 0 ; DISPLAY redraw
223	; ebx = 0 ; all	223	; ebx = 0 ; all
224	;	224	;
225	; eax = 1 ; BUTTON type	225	; eax = 1 ; BUTTON type
226	; ebx = 0 ; flat	226	; ebx = 0 ; flat
227	; ebx = 1 ; 3D	227	; ebx = 1 ; 3D
228	; eax = 2 ; set WINDOW colours	228	; eax = 2 ; set WINDOW colours
229	; ebx = pointer to table	229	; ebx = pointer to table
230	; ecx = number of bytes define	230	; ecx = number of bytes define
231	; eax = 3 ; get WINDOW colours	231	; eax = 3 ; get WINDOW colours
232	; ebx = pointer to table	232	; ebx = pointer to table
233	; ecx = number of bytes wanted	233	; ecx = number of bytes wanted
234	; eax = 4 ; get skin height	234	; eax = 4 ; get skin height
235	; input : nothing	235	; input : nothing
236	; output : eax = skin height in pixel	236	; output : eax = skin height in pixel
237		237
238		238
239	pushad	239	pushad
240		240
241	test eax, eax ; redraw display	241	test eax, eax ; redraw display
242	jnz dspl0	242	jnz dspl0
243	test ebx, ebx	243	test ebx, ebx
244	jnz dspl0	244	jnz dspl0
245	cmp [windowtypechanged],dword 1	245	cmp [windowtypechanged],dword 1
246	jne dspl00	246	jne dspl00
247	mov [windowtypechanged],dword 0	247	mov [windowtypechanged],dword 0
248	mov [dlx],dword 0	248	mov [dlx],dword 0
249	mov [dly],dword 0	249	mov [dly],dword 0
250	mov eax,[0xfe00]	250	mov eax,[0xfe00]
251	mov [dlxe],eax	251	mov [dlxe],eax
252	mov eax,[0xfe04]	252	mov eax,[0xfe04]
253	mov [dlye],eax	253	mov [dlye],eax
254	mov eax,window_data	254	mov eax,window_data
255	call redrawscreen	255	call redrawscreen
256	dspl00:	256	dspl00:
257	popad	257	popad
258	ret	258	ret
259	dspl0:	259	dspl0:
260		260
261	cmp eax,1 ; button type	261	cmp eax,1 ; button type
262	jne dspl1	262	jne dspl1
263	and ebx,1	263	and ebx,1
264	cmp ebx,[buttontype]	264	cmp ebx,[buttontype]
265	je dspl9	265	je dspl9
266	mov [buttontype],ebx	266	mov [buttontype],ebx
267	mov [windowtypechanged],dword 1	267	mov [windowtypechanged],dword 1
268	dspl9:	268	dspl9:
269	popad	269	popad
270	ret	270	ret
271	dspl1:	271	dspl1:
272		272
273	cmp eax,2 ; set common window colours	273	cmp eax,2 ; set common window colours
274	jne no_com_colours	274	jne no_com_colours
275	mov [windowtypechanged],dword 1	275	mov [windowtypechanged],dword 1
276	mov esi,[0x3010]	276	mov esi,[0x3010]
277	add esi,0x10	277	add esi,0x10
278	add ebx,[esi]	278	add ebx,[esi]
279	mov esi,ebx	279	mov esi,ebx
280	mov edi,common_colours	280	mov edi,common_colours
281	and ecx,127	281	and ecx,127
282	cld	282	cld
283	rep movsb	283	rep movsb
284	popad	284	popad
285	ret	285	ret
286	no_com_colours:	286	no_com_colours:
287		287
288	cmp eax,3 ; get common window colours	288	cmp eax,3 ; get common window colours
289	jne no_get_com	289	jne no_get_com
290	mov esi,[0x3010]	290	mov esi,[0x3010]
291	add esi,0x10	291	add esi,0x10
292	add ebx,[esi]	292	add ebx,[esi]
293	mov edi,ebx	293	mov edi,ebx
294	mov esi,common_colours	294	mov esi,common_colours
295	and ecx,127	295	and ecx,127
296	cld	296	cld
297	rep movsb	297	rep movsb
298	popad	298	popad
299	ret	299	ret
300	no_get_com:	300	no_get_com:
301		301
302	cmp eax,4 ; get skin height	302	cmp eax,4 ; get skin height
303	jne no_skin_height	303	jne no_skin_height
304	popad	304	popad
305	mov eax,[_skinh]	305	mov eax,[_skinh]
306	mov [esp+36],eax	306	mov [esp+36],eax
307	ret	307	ret
308	no_skin_height:	308	no_skin_height:
309		309
310	popad	310	popad
311	ret	311	ret
312		312
313	uglobal	313	uglobal
314	common_colours:	314	common_colours:
315	times 128 db 0x0	315	times 128 db 0x0
316	endg	316	endg
317		317
318	check_window_move_request:	318	check_window_move_request:
319		319
320	pushad	320	pushad
321		321
322	mov edi,[window_move_pr] ; requestor process base	322	mov edi,[window_move_pr] ; requestor process base
323		323
324	cmp edi,0	324	cmp edi,0
325	je window_move_return	325	je window_move_return
326		326
327	shl edi,5	327	shl edi,5
328	add edi,window_data	328	add edi,window_data
329		329
330	push dword [edi+0] ; save old coordinates	330	push dword [edi+0] ; save old coordinates
331	push dword [edi+4]	331	push dword [edi+4]
332	push dword [edi+8]	332	push dword [edi+8]
333	push dword [edi+12]	333	push dword [edi+12]
334		334
335	mov eax,[window_move_eax]	335	mov eax,[window_move_eax]
336	mov ebx,[window_move_ebx]	336	mov ebx,[window_move_ebx]
337	mov ecx,[window_move_ecx]	337	mov ecx,[window_move_ecx]
338	mov edx,[window_move_edx]	338	mov edx,[window_move_edx]
339		339
340	cmp eax,-1 ; set new position and size	340	cmp eax,-1 ; set new position and size
341	je no_x_reposition	341	je no_x_reposition
342	mov [edi+0],eax	342	mov [edi+0],eax
343	no_x_reposition:	343	no_x_reposition:
344	cmp ebx,-1	344	cmp ebx,-1
345	je no_y_reposition	345	je no_y_reposition
346	mov [edi+4],ebx	346	mov [edi+4],ebx
347	no_y_reposition:	347	no_y_reposition:
348	cmp ecx,-1	348	cmp ecx,-1
349	je no_x_resizing	349	je no_x_resizing
350	mov [edi+8],ecx	350	mov [edi+8],ecx
351	no_x_resizing:	351	no_x_resizing:
352	cmp edx,-1	352	cmp edx,-1
353	je no_y_resizing	353	je no_y_resizing
354	mov [edi+12],edx	354	mov [edi+12],edx
355	no_y_resizing:	355	no_y_resizing:
356		356
357	call check_window_position	357	call check_window_position
358		358
359	pushad ; save for window fullscreen/resize	359	pushad ; save for window fullscreen/resize
360	mov esi,edi	360	mov esi,edi
361	sub edi,window_data	361	sub edi,window_data
362	shr edi,5	362	shr edi,5
363	shl edi,8	363	shl edi,8
364	add edi,0x80000+0x90	364	add edi,0x80000+0x90
365	mov ecx,4	365	mov ecx,4
366	cld	366	cld
367	rep movsd	367	rep movsd
368	popad	368	popad
369		369
370	pushad ; calculcate screen at new position	370	pushad ; calculcate screen at new position
371	mov eax,[edi+00]	371	mov eax,[edi+00]
372	mov ebx,[edi+04]	372	mov ebx,[edi+04]
373	mov ecx,[edi+8]	373	mov ecx,[edi+8]
374	mov edx,[edi+12]	374	mov edx,[edi+12]
375	add ecx,eax	375	add ecx,eax
376	add edx,ebx	376	add edx,ebx
377	call calculatescreen	377	call calculatescreen
378	popad	378	popad
379		379
380	pop edx ; calculcate screen at old position	380	pop edx ; calculcate screen at old position
381	pop ecx	381	pop ecx
382	pop ebx	382	pop ebx
383	pop eax	383	pop eax
384	add ecx,eax	384	add ecx,eax
385	add edx,ebx	385	add edx,ebx
386	mov [dlx],eax ; save for drawlimits	386	mov [dlx],eax ; save for drawlimits
387	mov [dly],ebx	387	mov [dly],ebx
388	mov [dlxe],ecx	388	mov [dlxe],ecx
389	mov [dlye],edx	389	mov [dlye],edx
390	call calculatescreen	390	call calculatescreen
391		391
392	mov [edi+31],byte 1 ; flag the process as redraw	392	mov [edi+31],byte 1 ; flag the process as redraw
393		393
394	mov eax,edi ; redraw screen at old position	394	mov eax,edi ; redraw screen at old position
395	xor esi,esi	395	xor esi,esi
396	call redrawscreen	396	call redrawscreen
397		397
398	mov [0xfff5],byte 0 ; mouse pointer	398	mov [0xfff5],byte 0 ; mouse pointer
399	mov [0xfff4],byte 0 ; no mouse under	399	mov [0xfff4],byte 0 ; no mouse under
400	mov [0xfb44],byte 0 ; react to mouse up/down	400	mov [0xfb44],byte 0 ; react to mouse up/down
401		401
402	mov ecx,10 ; wait 1/10 second	402	mov ecx,10 ; wait 1/10 second
403	wmrl3:	403	wmrl3:
404	call check_mouse_data	-
405	call [draw_pointer]	404	call [draw_pointer]
406	mov eax,1	405	mov eax,1
407	call delay_hs	406	call delay_hs
408	loop wmrl3	407	loop wmrl3
409		408
410	mov [window_move_pr],0	409	mov [window_move_pr],0
411		410
412	window_move_return:	411	window_move_return:
413		412
414	popad	413	popad
415		414
416	ret	415	ret
417		416
418		417
419		418
420		419
421	check_window_position:	420	check_window_position:
422		421
423	pushad ; window inside screen ?	422	pushad ; window inside screen ?
424		423
425	movzx eax,word [edi+0]	424	movzx eax,word [edi+0]
426	movzx ebx,word [edi+4]	425	movzx ebx,word [edi+4]
427	movzx ecx,word [edi+8]	426	movzx ecx,word [edi+8]
428	movzx edx,word [edi+12]	427	movzx edx,word [edi+12]
429		428
430	mov esi,ecx ; check x pos	429	mov esi,ecx ; check x pos
431	add esi,eax	430	add esi,eax
432	cmp esi,[0xfe00]	431	cmp esi,[0xfe00]
433	jbe x_pos_ok	432	jbe x_pos_ok
434	mov [edi+0],dword 0	433	mov [edi+0],dword 0
435	xor eax, eax	434	xor eax, eax
436	x_pos_ok:	435	x_pos_ok:
437		436
438	mov esi,edx ; check y pos	437	mov esi,edx ; check y pos
439	add esi,ebx	438	add esi,ebx
440	cmp esi,[0xfe04]	439	cmp esi,[0xfe04]
441	jbe y_pos_ok	440	jbe y_pos_ok
442	mov [edi+4],dword 0	441	mov [edi+4],dword 0
443	mov ebx,0	442	mov ebx,0
444	y_pos_ok:	443	y_pos_ok:
445		444
446	mov esi,ecx ; check x size	445	mov esi,ecx ; check x size
447	add esi,eax	446	add esi,eax
448	cmp esi,[0xfe00]	447	cmp esi,[0xfe00]
449	jbe x_size_ok	448	jbe x_size_ok
450	mov ecx,[0xfe00]	449	mov ecx,[0xfe00]
451	mov [edi+8],ecx	450	mov [edi+8],ecx
452	x_size_ok:	451	x_size_ok:
453		452
454	mov esi,edx ; check y size	453	mov esi,edx ; check y size
455	add esi,ebx	454	add esi,ebx
456	cmp esi,[0xfe04]	455	cmp esi,[0xfe04]
457	jbe y_size_ok	456	jbe y_size_ok
458	mov edx,[0xfe04]	457	mov edx,[0xfe04]
459	mov [edi+12],edx	458	mov [edi+12],edx
460	y_size_ok:	459	y_size_ok:
461		460
462	popad	461	popad
463		462
464	ret	463	ret
465		464
466		465
467	uglobal	466	uglobal
468	new_window_starting dd 0	467	new_window_starting dd 0
469	endg	468	endg
470		469
471		470
472	sys_window_mouse:	471	sys_window_mouse:
473		472
474	push eax	473	push eax
475		474
476	mov eax,[timer_ticks] ;[0xfdf0]	475	mov eax,[timer_ticks] ;[0xfdf0]
477	cmp [new_window_starting],eax	476	cmp [new_window_starting],eax
478	jb swml1	477	jb swml1
479		478
480	mov [0xfff4],byte 0 ; no mouse background	479	mov [0xfff4],byte 0 ; no mouse background
481	mov [0xfff5],byte 0 ; draw mouse	480	mov [0xfff5],byte 0 ; draw mouse
482		481
483	mov [new_window_starting],eax	482	mov [new_window_starting],eax
484		483
485	swml1:	484	swml1:
486		485
487	pop eax	486	pop eax
488		487
489	ret	488	ret
490		489
491	drawwindow_I:	490	drawwindow_I:
492		491
493	pushad	492	pushad
494		493
495	mov esi,[edx+24] ; rectangle	494	mov esi,[edx+24] ; rectangle
496	mov eax,[edx+0]	495	mov eax,[edx+0]
497	shl eax,16	496	shl eax,16
498	add eax,[edx+0]	497	add eax,[edx+0]
499	add eax,[edx+8]	498	add eax,[edx+8]
500	mov ebx,[edx+04]	499	mov ebx,[edx+04]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/window.inc – Rev 2 → 33