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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2010-2023. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
$Revision: 9941 $
 
;================================
;/////// public functions ///////
;================================
 
mouse.LEFT_BUTTON_FLAG   = 0001b
mouse.RIGHT_BUTTON_FLAG  = 0010b
mouse.MIDDLE_BUTTON_FLAG = 0100b
 
mouse.BUTTONS_MASK = \
  mouse.LEFT_BUTTON_FLAG or \
  mouse.RIGHT_BUTTON_FLAG or \
  mouse.MIDDLE_BUTTON_FLAG
 
mouse.WINDOW_RESIZE_N_FLAG = 000001b
mouse.WINDOW_RESIZE_W_FLAG = 000010b
mouse.WINDOW_RESIZE_S_FLAG = 000100b
mouse.WINDOW_RESIZE_E_FLAG = 001000b
mouse.WINDOW_MOVE_FLAG     = 010000b
 
mouse.WINDOW_RESIZE_SW_FLAG = \
  mouse.WINDOW_RESIZE_S_FLAG or \
  mouse.WINDOW_RESIZE_W_FLAG
mouse.WINDOW_RESIZE_SE_FLAG = \
  mouse.WINDOW_RESIZE_S_FLAG or \
  mouse.WINDOW_RESIZE_E_FLAG
 
align 4
;-----------------------------------------------------------------
mouse_check_events:
; Check if mouse buttons state or cursor position has changed
        push    eax ebx
        mov     al, [BTN_DOWN]
        mov     bl, [mouse.state.buttons]
        and     al, mouse.BUTTONS_MASK
        mov     cl, al
        xchg    cl, [mouse.state.buttons]
        xor     bl, al
        push    eax ebx
 
        ; did any mouse button changed its state?
        or      bl, bl
        jz      .check_position
 
        ; yes it did, is that the first button of all pressed down?
        or      cl, cl
        jnz     .check_buttons_released
 
        ; yes it is, activate window user is pointing at, if needed
        call    mouse._.activate_sys_window_under_cursor
 
        ; is there any system button under cursor?
        call    mouse._.find_sys_button_under_cursor
        or      eax, eax
        jz      .check_buttons_released
 
        ; yes there is, activate it and exit
        mov     [mouse.active_sys_button.pbid], eax
        mov     [mouse.active_sys_button.coord], ebx
        mov     cl, [mouse.state.buttons]
        mov     [mouse.active_sys_button.buttons], cl
        call    sys_button_activate_handler
        jmp     .exit
 
  .check_buttons_released:
        cmp     [mouse.state.buttons], 0
        jnz     .buttons_changed
 
        ; did we press some button earlier?
        cmp     [mouse.active_sys_button.pbid], 0
        je      .buttons_changed
 
        ; yes we did, deactivate it
        xor     eax, eax
        xchg    eax, [mouse.active_sys_button.pbid]
        mov     ebx, [mouse.active_sys_button.coord]
        mov     cl, [mouse.active_sys_button.buttons]
        push    eax ebx
        call    sys_button_deactivate_handler
        pop     edx ecx
 
        ; is the button under cursor the one we deactivated?
        call    mouse._.find_sys_button_under_cursor
        cmp     eax, ecx
        jne     .exit
        cmp     ebx, edx
        jne     .exit
 
        ; yes it is, perform associated action
        mov     cl, [mouse.active_sys_button.buttons]
        call    sys_button_perform_handler
        jmp     .exit
 
  .buttons_changed:
        test    byte[esp], mouse.LEFT_BUTTON_FLAG
        jz      @f
        mov     eax, [esp + 4]
        call    .call_left_button_handler
 
    @@:
        test    byte[esp], mouse.RIGHT_BUTTON_FLAG
        jz      @f
        mov     eax, [esp + 4]
        call    .call_right_button_handler
 
    @@:
        test    byte[esp], mouse.MIDDLE_BUTTON_FLAG
        jz      .check_position
        mov     eax, [esp + 4]
        call    .call_middle_button_handler
 
  .check_position:
        movzx   eax, word[MOUSE_X]
        movzx   ebx, word[MOUSE_Y]
        cmp     eax, [mouse.state.pos.x]
        jne     .position_changed
        cmp     ebx, [mouse.state.pos.y]
        je      .exit
 
  .position_changed:
        xchg    eax, [mouse.state.pos.x]
        xchg    ebx, [mouse.state.pos.y]
 
        call    mouse._.move_handler
 
  .exit:
        add     esp, 8
        pop     ebx eax
        ret
 
  .call_left_button_handler:
        test    eax, mouse.LEFT_BUTTON_FLAG
        jnz     mouse._.left_button_press_handler
        jmp     mouse._.left_button_release_handler
 
  .call_right_button_handler:
        test    eax, mouse.RIGHT_BUTTON_FLAG
        jnz     mouse._.right_button_press_handler
        jmp     mouse._.right_button_release_handler
 
  .call_middle_button_handler:
        test    eax, mouse.MIDDLE_BUTTON_FLAG
        jnz     mouse._.middle_button_press_handler
        jmp     mouse._.middle_button_release_handler
 
;===============================
;////// private functions //////
;===============================
 
uglobal
  mouse.state:
    .pos     POINT
    .buttons db ?
 
; NOTE: since there's no unique and lifetime-constant button identifiers,
; we are using two dwords to identify each of them:
;   * pbid - process slot (high 8 bits) and button id (low 24 bits) pack
;   * coord - left (high 16 bits) and top (low 16 bits) coordinates pack
  align 4
  mouse.active_sys_button:
    .pbid    dd ?
    .coord   dd ?
    .buttons db ?
 
  align 4
  mouse.active_sys_window:
    .pslot      dd ?
    .old_box    BOX
    .new_box    BOX
    .delta      POINT
    .last_ticks dd ?
    .action     db ?
endg
 
iglobal
        fl_moving db 0
        rb 3
endg
 
align 4
;-----------------------------------------------------------------
mouse._.left_button_press_handler:
; Called when left mouse button has been pressed down
        bts     word [BTN_DOWN], 8
        mov     eax, [timer_ticks]
        mov     ebx, eax
        xchg    ebx, [mouse.active_sys_window.last_ticks]
        sub     eax, ebx
        movzx   ebx, [mouse_doubleclick_delay]
        cmp     eax, ebx
        jg      @f
        bts     dword [BTN_DOWN], 24
@@:
        test    [mouse.state.buttons], not mouse.LEFT_BUTTON_FLAG
        jnz     .exit
 
        call    mouse._.find_sys_window_under_cursor
        call    mouse._.check_sys_window_actions
        mov     [mouse.active_sys_window.action], al
        or      eax, eax
        jz      .exit
 
        xchg    eax, edx
        test    dl, mouse.WINDOW_MOVE_FLAG
        jz      @f
 
        bt      dword [BTN_DOWN], 24
        jnc     @f
 
        mov     [mouse.active_sys_window.last_ticks], 0
        call    sys_window_maximize_handler
        jmp     .exit
 
    @@:
        test    [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
        jnz     .exit
        mov     [mouse.active_sys_window.pslot], esi
        lea     eax, [edi + WDATA.box]
        mov     ebx, mouse.active_sys_window.old_box
        mov     ecx, sizeof.BOX
        call    memmove
        mov     ebx, mouse.active_sys_window.new_box
        call    memmove
        test    edx, mouse.WINDOW_MOVE_FLAG
        jz      @f
 
        call    .calculate_n_delta
        call    .calculate_w_delta
        jmp     .call_window_handler
 
    @@:
        test    dl, mouse.WINDOW_RESIZE_W_FLAG
        jz      @f
        call    .calculate_w_delta
 
    @@:
        test    dl, mouse.WINDOW_RESIZE_S_FLAG
        jz      @f
        call    .calculate_s_delta
 
    @@:
        test    dl, mouse.WINDOW_RESIZE_E_FLAG
        jz      .call_window_handler
        call    .calculate_e_delta
 
  .call_window_handler:
  .exit:
        ret
 
  .calculate_n_delta:
        mov     eax, [mouse.state.pos.y]
        sub     eax, [mouse.active_sys_window.old_box.top]
        mov     [mouse.active_sys_window.delta.y], eax
        ret
 
  .calculate_w_delta:
        mov     eax, [mouse.state.pos.x]
        sub     eax, [mouse.active_sys_window.old_box.left]
        mov     [mouse.active_sys_window.delta.x], eax
        ret
 
  .calculate_s_delta:
        mov     eax, [mouse.active_sys_window.old_box.top]
        add     eax, [mouse.active_sys_window.old_box.height]
        sub     eax, [mouse.state.pos.y]
        mov     [mouse.active_sys_window.delta.y], eax
        ret
 
  .calculate_e_delta:
        mov     eax, [mouse.active_sys_window.old_box.left]
        add     eax, [mouse.active_sys_window.old_box.width]
        sub     eax, [mouse.state.pos.x]
        mov     [mouse.active_sys_window.delta.x], eax
        ret
 
align 4
;-----------------------------------------------------------------
mouse._.left_button_release_handler:
; Called when left mouse button has been released
        bts     dword [BTN_DOWN], 16
        xor     esi, esi
        xchg    esi, [mouse.active_sys_window.pslot]
        or      esi, esi
        jz      .exit
 
        mov     eax, esi
        shl     eax, BSF sizeof.WDATA
        add     eax, window_data + WDATA.box
        mov     ebx, mouse.active_sys_window.old_box
        mov     ecx, sizeof.BOX
        call    memmove
 
        mov     eax, mouse.active_sys_window.old_box
        mov     ebx, mouse.active_sys_window.new_box
        call    sys_window_end_moving_handler
 
  .exit:
        and     [mouse.active_sys_window.action], 0
        mov     [fl_moving], 0
        ret
 
mouse._.right_button_press_handler:
        bts     word [BTN_DOWN], 9
        test    [mouse.state.buttons], not mouse.RIGHT_BUTTON_FLAG
        jnz     @f
        call    mouse._.find_sys_window_under_cursor
        call    mouse._.check_sys_window_actions
        test    al, mouse.WINDOW_MOVE_FLAG
        jz      @f
        jmp     sys_window_rollup_handler
 
mouse._.right_button_release_handler:
        bts     dword [BTN_DOWN], 17
@@:
        ret
 
mouse._.middle_button_press_handler:
        bts     word [BTN_DOWN], 10
        ret
 
mouse._.middle_button_release_handler:
        bts     dword [BTN_DOWN], 18
        ret
 
align 4
;-----------------------------------------------------------------
mouse._.move_handler:
; Called when cursor has been moved
;> eax = old x coord
;> ebx = old y coord
        push    eax ebx
 
        call    mouse._.find_sys_window_under_cursor
        call    mouse._.check_sys_window_actions
 
        ; if now we are resizing the window, dont change the cursor
        mov     bl, [mouse.active_sys_window.action]
        and     bl, mouse.WINDOW_RESIZE_S_FLAG or mouse.WINDOW_RESIZE_W_FLAG or mouse.WINDOW_RESIZE_E_FLAG
        test    bl, bl
        jnz     .end1
 
        cmp     al, mouse.WINDOW_RESIZE_SW_FLAG
        jne     .not_sw
        ; DEBUGF  1, "RESIZE SOUTH-WEST\n"
 
        mov     eax, [def_cursor_dresize2]
 
        jmp     .set_resizing_cursor
.not_sw:
        cmp     al, mouse.WINDOW_RESIZE_SE_FLAG
        jne     .not_se
        ; DEBUGF  1, "RESIZE SOUTH-EAST\n"
 
        mov     eax, [def_cursor_dresize1]
 
        jmp     .set_resizing_cursor
.not_se:
        cmp     al, mouse.WINDOW_RESIZE_W_FLAG
        jne     .not_w
        ; DEBUGF  1, "RESIZE WEST\n"
 
        mov     eax, [def_cursor_hresize]
 
        jmp     .set_resizing_cursor
.not_w:
        cmp     al, mouse.WINDOW_RESIZE_S_FLAG
        jne     .not_s
        ; DEBUGF  1, "RESIZE SOUTH\n"
 
        mov     eax, [def_cursor_vresize]
 
        jmp     .set_resizing_cursor
.not_s:
        cmp     al, mouse.WINDOW_RESIZE_E_FLAG
        jne     .not_in_resize_area
        ; DEBUGF  1, "RESIZE EAST\n"
 
        mov     eax, [def_cursor_hresize]
 
.set_resizing_cursor:
        ; DEBUGF  1, ".set_resizing_cursor eax = %x\n", eax
        ; change cursor to resizing cursor
        shl     esi, BSF sizeof.WDATA
        add     esi, window_data
        
        ; if resizing cursor we need (eax) isnt set already, set it
        cmp     eax, [esi + WDATA.cursor]
        je      @f
        
        ; DEBUGF  1, "changing cursor to resizing\n"
        xchg    eax, [esi + WDATA.cursor] ; set resizing cursor, prev cursor goes to eax
        ; save previous cursor (will be restored when we'll get out of the resizing area)
        ; if we change resizing cursor to resizing cursor then dont update previous cursor
        cmp     eax, [def_cursor_hresize]
        je      @f
        cmp     eax, [def_cursor_vresize]
        je      @f
        cmp     eax, [def_cursor_dresize1]
        je      @f
        cmp     eax, [def_cursor_dresize2]
        je      @f
 
        mov     [esi + WDATA.temp_cursor], eax ; save prev cursor
 
@@:
        jmp     .end1
.not_in_resize_area:
        ; DEBUGF  1, ".not_in_resize_area\n"
 
        shl     esi, BSF sizeof.WDATA
        add     esi, window_data
        mov     eax, [esi + WDATA.temp_cursor]
 
        test    eax, eax
        jz      .end1
        
        ; restore prev cursor
        mov     [esi + WDATA.temp_cursor], 0
        mov     [esi + WDATA.cursor], eax
 
.end1:
        pop     ebx eax
 
        cmp     [mouse.active_sys_button.pbid], 0
        jnz     .exit
 
        mov     esi, [mouse.active_sys_window.pslot]
        or      esi, esi
        jz      .exit
 
        mov     eax, mouse.active_sys_window.new_box
        mov     ebx, mouse.active_sys_window.old_box
        mov     ecx, sizeof.BOX
        call    memmove
 
        mov     dl, [mouse.active_sys_window.action]
        test    dl, mouse.WINDOW_MOVE_FLAG
        jz      .check_resize_w
 
        mov     eax, [mouse.state.pos.x]
        sub     eax, [mouse.active_sys_window.delta.x]
        mov     [mouse.active_sys_window.new_box.left], eax
        mov     eax, [mouse.state.pos.y]
        sub     eax, [mouse.active_sys_window.delta.y]
        mov     [mouse.active_sys_window.new_box.top], eax
 
        mov     eax, [mouse.active_sys_window.new_box.left]
        or      eax, eax
        jge     @f
        xor     eax, eax
        mov     [mouse.active_sys_window.new_box.left], eax
    @@:
        add     eax, [mouse.active_sys_window.new_box.width]
        cmp     eax, [_display.width]
        jl      @f
        sub     eax, [_display.width]
        inc     eax
        sub     [mouse.active_sys_window.new_box.left], eax
    @@:
        mov     eax, [mouse.active_sys_window.new_box.top]
        or      eax, eax
        jge     @f
        xor     eax, eax
        mov     [mouse.active_sys_window.new_box.top], eax
    @@:
        add     eax, [mouse.active_sys_window.new_box.height]
        cmp     eax, [_display.height]
        jl      .call_window_handler
        sub     eax, [_display.height]
        inc     eax
        sub     [mouse.active_sys_window.new_box.top], eax
        jmp     .call_window_handler
 
  .check_resize_w:
        test    dl, mouse.WINDOW_RESIZE_W_FLAG
        jz      .check_resize_s
 
        mov     eax, [mouse.state.pos.x]
        sub     eax, [mouse.active_sys_window.delta.x]
        mov     [mouse.active_sys_window.new_box.left], eax
        sub     eax, [mouse.active_sys_window.old_box.left]
        sub     [mouse.active_sys_window.new_box.width], eax
 
        mov     eax, [mouse.active_sys_window.new_box.width]
        sub     eax, 127
        jge     @f
        add     [mouse.active_sys_window.new_box.left], eax
        mov     [mouse.active_sys_window.new_box.width], 127
    @@:
        mov     eax, [mouse.active_sys_window.new_box.left]
        or      eax, eax
        jge     .check_resize_s
        add     [mouse.active_sys_window.new_box.width], eax
        xor     eax, eax
        mov     [mouse.active_sys_window.new_box.left], eax
 
  .check_resize_s:
        test    dl, mouse.WINDOW_RESIZE_S_FLAG
        jz      .check_resize_e
 
        mov     eax, [mouse.state.pos.y]
        add     eax, [mouse.active_sys_window.delta.y]
        sub     eax, [mouse.active_sys_window.old_box.top]
        mov     [mouse.active_sys_window.new_box.height], eax
 
        push    eax
        mov     edi, esi
        shl     edi, BSF sizeof.WDATA
        add     edi, window_data
        call    window._.get_rolledup_height
        mov     ecx, eax
        pop     eax
        mov     eax, [mouse.active_sys_window.new_box.height]
        cmp     eax, ecx
        jge     @f
        mov     eax, ecx
        mov     [mouse.active_sys_window.new_box.height], eax
    @@:
        add     eax, [mouse.active_sys_window.new_box.top]
        cmp     eax, [_display.height]
        jl      .check_resize_e
        sub     eax, [_display.height]
        neg     eax
        add     [mouse.active_sys_window.new_box.height], eax
        mov     ecx, [_display.height]
        cmp     ecx, eax
        jg      .check_resize_e
        mov     [mouse.active_sys_window.new_box.height], ecx
 
  .check_resize_e:
        test    dl, mouse.WINDOW_RESIZE_E_FLAG
        jz      .call_window_handler
 
        mov     eax, [mouse.state.pos.x]
        add     eax, [mouse.active_sys_window.delta.x]
        sub     eax, [mouse.active_sys_window.old_box.left]
        mov     [mouse.active_sys_window.new_box.width], eax
 
        mov     eax, [mouse.active_sys_window.new_box.width]
        cmp     eax, 127
        jge     @f
        mov     eax, 127
        mov     [mouse.active_sys_window.new_box.width], eax
    @@:
        add     eax, [mouse.active_sys_window.new_box.left]
        cmp     eax, [_display.width]
        jl      .call_window_handler
        sub     eax, [_display.width]
        neg     eax
        add     [mouse.active_sys_window.new_box.width], eax
        mov     ecx, [_display.width]
        cmp     ecx, eax
        jg      .call_window_handler
        mov     [mouse.active_sys_window.new_box.width], ecx
 
  .call_window_handler:
        mov     eax, mouse.active_sys_window.old_box
        mov     ebx, mouse.active_sys_window.new_box
 
        push    esi
        mov     esi, mouse.active_sys_window.old_box
        mov     edi, mouse.active_sys_window.new_box
        mov     ecx, sizeof.BOX / 4
        repe
        cmpsd
        pop     esi
        je      .exit
 
        test    [fl_moving], 1
        jnz     @f
 
        mov     [fl_moving], 1
        push    edi
        mov     edi, esi
        shl     edi, BSF sizeof.WDATA
        add     edi, WDATA.box + window_data
        call    window._.draw_negative_box
        pop     edi
     @@:
 
 
        mov     [mouse.active_sys_window.last_ticks], 0
        call    sys_window_moving_handler
 
  .exit:
        ret
 
align 4
;-----------------------------------------------------------------
mouse._.find_sys_window_under_cursor:
; Find system window object which is currently visible on screen
; and has mouse cursor within its bounds
;< esi = process slot
;< edi = pointer to WDATA struct
        mov     esi, [mouse.state.pos.y]
        mov     esi, [d_width_calc_area + esi*4]
 
        add     esi, [_display.win_map]
        add     esi, [mouse.state.pos.x]
        movzx   esi, byte[esi]
        mov     edi, esi
        shl     edi, BSF sizeof.WDATA
        add     edi, window_data
        ret
 
align 4
;-----------------------------------------------------------------
mouse._.activate_sys_window_under_cursor:
; activate and redraw window under cursor (if necessary)
        call    mouse._.find_sys_window_under_cursor
        movzx   esi, word[WIN_STACK + esi * 2]
        lea     esi, [WIN_POS + esi * 2]
        jmp     waredraw
 
align 4
;-----------------------------------------------------------------
mouse._.find_sys_button_under_cursor:
; Find system button object which is currently visible on screen
; and has mouse cursor within its bounds
;< eax = pack[8(process slot), 24(button id)] or 0
;< ebx = pack[16(button x coord), 16(button y coord)]
        push    ecx edx esi edi
 
        call    mouse._.find_sys_window_under_cursor
        mov     edx, esi
 
        ; check if any process button contains cursor
        mov     eax, [BTN_ADDR]
        mov     ecx, [eax]
        imul    esi, ecx, sizeof.SYS_BUTTON
        add     esi, eax
        inc     ecx
        add     esi, sizeof.SYS_BUTTON
 
  .next_button:
        dec     ecx
        jz      .not_found
 
        add     esi, -sizeof.SYS_BUTTON
 
        ; does it belong to our process?
        cmp     dx, [esi + SYS_BUTTON.pslot]
        jne     .next_button
 
        ; does it contain cursor coordinates?
        mov     eax, [mouse.state.pos.x]
        sub     eax, [edi + WDATA.box.left]
        sub     ax, [esi + SYS_BUTTON.left]
        jl      .next_button
        sub     ax, [esi + SYS_BUTTON.width]
        jge     .next_button
        mov     eax, [mouse.state.pos.y]
        sub     eax, [edi + WDATA.box.top]
        sub     ax, [esi + SYS_BUTTON.top]
        jl      .next_button
        sub     ax, [esi + SYS_BUTTON.height]
        jge     .next_button
 
        ; okay, return it
        shl     edx, 24
        mov     eax, dword[esi + SYS_BUTTON.id_hi - 2]
        mov     ax, [esi + SYS_BUTTON.id_lo]
        and     eax, 0x0ffffff
        or      eax, edx
        mov     ebx, dword[esi + SYS_BUTTON.left - 2]
        mov     bx, [esi + SYS_BUTTON.top]
        jmp     .exit
 
  .not_found:
        xor     eax, eax
        xor     ebx, ebx
 
  .exit:
        pop     edi esi edx ecx
        ret
 
align 4
;-----------------------------------------------------------------
mouse._.check_sys_window_actions:
;< eax = action flags or 0
        ; is window movable?
        test    byte[edi + WDATA.cl_titlebar + 3], 0x01
        jnz     .no_action
 
        mov     eax, [mouse.state.pos.x]
        mov     ebx, [mouse.state.pos.y]
        sub     eax, [edi + WDATA.box.left]
        sub     ebx, [edi + WDATA.box.top]
 
        ; is there a window titlebar under cursor?
        push    eax
        call    window._.get_titlebar_height
        cmp     ebx, eax
        pop     eax
        jl      .move_action
 
        ; no there isn't, can it be resized then?
        mov     dl, [edi + WDATA.fl_wstyle]
        and     dl, 0x0f
; NOTE: dangerous optimization, revise if window types changed
; this currently implies only types 2 and 3 could be resized
        test    dl, 2
        jz      .no_action
 
        mov     ecx, [edi + WDATA.box.width]
        add     ecx, -window.BORDER_SIZE
        mov     edx, [edi + WDATA.box.height]
        add     edx, -window.BORDER_SIZE
 
        ; is it rolled up?
        test    [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP
        jnz     .resize_w_or_e_action
 
        cmp     eax, window.BORDER_SIZE
        jl      .resize_w_action
        cmp     eax, ecx
        jg      .resize_e_action
        cmp     ebx, edx
        jle     .no_action
 
  .resize_s_action:
        cmp     eax, window.BORDER_SIZE + 10
        jl      .resize_sw_action
        add     ecx, -10
        cmp     eax, ecx
        jge     .resize_se_action
        mov     eax, mouse.WINDOW_RESIZE_S_FLAG
        jmp     .exit
 
  .resize_w_or_e_action:
        cmp     eax, window.BORDER_SIZE + 10
        jl      .resize_w_action.direct
        add     ecx, -10
        cmp     eax, ecx
        jg      .resize_e_action.direct
        jmp     .no_action
 
  .resize_w_action:
        add     edx, -10
        cmp     ebx, edx
        jge     .resize_sw_action
  .resize_w_action.direct:
        mov     eax, mouse.WINDOW_RESIZE_W_FLAG
        jmp     .exit
 
  .resize_e_action:
        add     edx, -10
        cmp     ebx, edx
        jge     .resize_se_action
  .resize_e_action.direct:
        mov     eax, mouse.WINDOW_RESIZE_E_FLAG
        jmp     .exit
 
  .resize_sw_action:
        mov     eax, mouse.WINDOW_RESIZE_SW_FLAG
        jmp     .exit
 
  .resize_se_action:
        mov     eax, mouse.WINDOW_RESIZE_SE_FLAG
        jmp     .exit
 
  .move_action:
        mov     eax, mouse.WINDOW_MOVE_FLAG
        jmp     .exit
 
  .no_action:
        xor     eax, eax
 
  .exit:
        ret
;-----------------------------------------------------------------------------
 
align 4
readmousepos:
; eax=0 screen relative
; eax=1 window relative
; eax=2 buttons pressed
; eax=3 buttons pressed ext
; eax=4 load cursor
; eax=5 set cursor
; eax=6 delete cursor
; eax=7 get mouse_z
; eax=8 load cursor unicode
        cmp     ebx, 8
        ja      @f
        jmp     dword[.mousefn+ebx*4]
 
align 4
.mousefn:
dd  .msscreen
dd  .mswin
dd  .msbutton
dd  .msbuttonExt
dd  .app_load_cursor
dd  .app_set_cursor
dd  .app_delete_cursor
dd  .msz
dd  .loadCursorUni
 
.msscreen:
        mov     eax, [MOUSE_X]
        shl     eax, 16
        mov     ax, [MOUSE_Y]
        mov     [esp + SYSCALL_STACK.eax], eax
@@:
        ret
 
.mswin:
        mov     eax, [MOUSE_X]
        shl     eax, 16
        mov     ax, [MOUSE_Y]
        mov     esi, [current_slot]
        mov     esi, [esi + APPDATA.window]
        mov     bx, word[esi + WDATA.box.left]
        shl     ebx, 16
        mov     bx, word[esi + WDATA.box.top]
        sub     eax, ebx
        sub     ax, word[esi + WDATA.clientbox.top]
        rol     eax, 16
        sub     ax, word[esi + WDATA.clientbox.left]
        rol     eax, 16
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
.msbutton:
        movzx   eax, byte [BTN_DOWN]
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
.msbuttonExt:
        mov     eax, [BTN_DOWN]
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
.app_load_cursor:
        cmp     ecx, OS_BASE
        jae     @f
        stdcall load_cursor, ecx, edx
        mov     [esp + SYSCALL_STACK.eax], eax
@@:
        ret
 
.loadCursorUni:
        cmp     ecx, OS_BASE
        jae     @b
        push    ecx edx
        stdcall kernel_alloc, maxPathLength
        mov     edi, eax
        pop     eax esi
        push    edi
        call    getFullPath
        pop     ebp
        test    eax, eax
        jz      @f
        stdcall load_cursor, ebp, LOAD_FROM_FILE
        mov     [esp + SYSCALL_STACK.eax], eax
@@:
        stdcall kernel_free, ebp
        ret
 
.app_set_cursor:
        stdcall set_cursor, ecx
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
.app_delete_cursor:
        stdcall delete_cursor, ecx
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
.msz:
        mov     edi, [thread_count]
        movzx   edi, word [WIN_POS + edi*2]
        cmp     edi, [current_slot_idx]
        jne     @f
        mov     ax, [MOUSE_SCROLL_H]
        shl     eax, 16
        mov     ax, [MOUSE_SCROLL_V]
        mov     [esp + SYSCALL_STACK.eax], eax
        and     [MOUSE_SCROLL_H], word 0
        and     [MOUSE_SCROLL_V], word 0
        ret
@@:
        and     [esp + SYSCALL_STACK.eax], dword 0
        ret

Rev 9930	Rev 9941
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2010-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2010-2023. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 9930 $	-
9		-
10	include 'mousepointer.inc'	8	$Revision: 9941 $
11		9
12	;================================	10	;================================
13	;/////// public functions ///////	11	;/////// public functions ///////
14	;================================	12	;================================
15		13
16	mouse.LEFT_BUTTON_FLAG = 0001b	14	mouse.LEFT_BUTTON_FLAG = 0001b
17	mouse.RIGHT_BUTTON_FLAG = 0010b	15	mouse.RIGHT_BUTTON_FLAG = 0010b
18	mouse.MIDDLE_BUTTON_FLAG = 0100b	16	mouse.MIDDLE_BUTTON_FLAG = 0100b
19		17
20	mouse.BUTTONS_MASK = \	18	mouse.BUTTONS_MASK = \
21	mouse.LEFT_BUTTON_FLAG or \	19	mouse.LEFT_BUTTON_FLAG or \
22	mouse.RIGHT_BUTTON_FLAG or \	20	mouse.RIGHT_BUTTON_FLAG or \
23	mouse.MIDDLE_BUTTON_FLAG	21	mouse.MIDDLE_BUTTON_FLAG
24		22
25	mouse.WINDOW_RESIZE_N_FLAG = 000001b	23	mouse.WINDOW_RESIZE_N_FLAG = 000001b
26	mouse.WINDOW_RESIZE_W_FLAG = 000010b	24	mouse.WINDOW_RESIZE_W_FLAG = 000010b
27	mouse.WINDOW_RESIZE_S_FLAG = 000100b	25	mouse.WINDOW_RESIZE_S_FLAG = 000100b
28	mouse.WINDOW_RESIZE_E_FLAG = 001000b	26	mouse.WINDOW_RESIZE_E_FLAG = 001000b
29	mouse.WINDOW_MOVE_FLAG = 010000b	27	mouse.WINDOW_MOVE_FLAG = 010000b
30		28
31	mouse.WINDOW_RESIZE_SW_FLAG = \	29	mouse.WINDOW_RESIZE_SW_FLAG = \
32	mouse.WINDOW_RESIZE_S_FLAG or \	30	mouse.WINDOW_RESIZE_S_FLAG or \
33	mouse.WINDOW_RESIZE_W_FLAG	31	mouse.WINDOW_RESIZE_W_FLAG
34	mouse.WINDOW_RESIZE_SE_FLAG = \	32	mouse.WINDOW_RESIZE_SE_FLAG = \
35	mouse.WINDOW_RESIZE_S_FLAG or \	33	mouse.WINDOW_RESIZE_S_FLAG or \
36	mouse.WINDOW_RESIZE_E_FLAG	34	mouse.WINDOW_RESIZE_E_FLAG
37		35
38	align 4	36	align 4
39	;-----------------------------------------------------------------	37	;-----------------------------------------------------------------
40	mouse_check_events:	38	mouse_check_events:
41	; Check if mouse buttons state or cursor position has changed	39	; Check if mouse buttons state or cursor position has changed
42	push eax ebx	40	push eax ebx
43	mov al, [BTN_DOWN]	41	mov al, [BTN_DOWN]
44	mov bl, [mouse.state.buttons]	42	mov bl, [mouse.state.buttons]
45	and al, mouse.BUTTONS_MASK	43	and al, mouse.BUTTONS_MASK
46	mov cl, al	44	mov cl, al
47	xchg cl, [mouse.state.buttons]	45	xchg cl, [mouse.state.buttons]
48	xor bl, al	46	xor bl, al
49	push eax ebx	47	push eax ebx
50		48
51	; did any mouse button changed its state?	49	; did any mouse button changed its state?
52	or bl, bl	50	or bl, bl
53	jz .check_position	51	jz .check_position
54		52
55	; yes it did, is that the first button of all pressed down?	53	; yes it did, is that the first button of all pressed down?
56	or cl, cl	54	or cl, cl
57	jnz .check_buttons_released	55	jnz .check_buttons_released
58		56
59	; yes it is, activate window user is pointing at, if needed	57	; yes it is, activate window user is pointing at, if needed
60	call mouse._.activate_sys_window_under_cursor	58	call mouse._.activate_sys_window_under_cursor
61		59
62	; is there any system button under cursor?	60	; is there any system button under cursor?
63	call mouse._.find_sys_button_under_cursor	61	call mouse._.find_sys_button_under_cursor
64	or eax, eax	62	or eax, eax
65	jz .check_buttons_released	63	jz .check_buttons_released
66		64
67	; yes there is, activate it and exit	65	; yes there is, activate it and exit
68	mov [mouse.active_sys_button.pbid], eax	66	mov [mouse.active_sys_button.pbid], eax
69	mov [mouse.active_sys_button.coord], ebx	67	mov [mouse.active_sys_button.coord], ebx
70	mov cl, [mouse.state.buttons]	68	mov cl, [mouse.state.buttons]
71	mov [mouse.active_sys_button.buttons], cl	69	mov [mouse.active_sys_button.buttons], cl
72	call sys_button_activate_handler	70	call sys_button_activate_handler
73	jmp .exit	71	jmp .exit
74		72
75	.check_buttons_released:	73	.check_buttons_released:
76	cmp [mouse.state.buttons], 0	74	cmp [mouse.state.buttons], 0
77	jnz .buttons_changed	75	jnz .buttons_changed
78		76
79	; did we press some button earlier?	77	; did we press some button earlier?
80	cmp [mouse.active_sys_button.pbid], 0	78	cmp [mouse.active_sys_button.pbid], 0
81	je .buttons_changed	79	je .buttons_changed
82		80
83	; yes we did, deactivate it	81	; yes we did, deactivate it
84	xor eax, eax	82	xor eax, eax
85	xchg eax, [mouse.active_sys_button.pbid]	83	xchg eax, [mouse.active_sys_button.pbid]
86	mov ebx, [mouse.active_sys_button.coord]	84	mov ebx, [mouse.active_sys_button.coord]
87	mov cl, [mouse.active_sys_button.buttons]	85	mov cl, [mouse.active_sys_button.buttons]
88	push eax ebx	86	push eax ebx
89	call sys_button_deactivate_handler	87	call sys_button_deactivate_handler
90	pop edx ecx	88	pop edx ecx
91		89
92	; is the button under cursor the one we deactivated?	90	; is the button under cursor the one we deactivated?
93	call mouse._.find_sys_button_under_cursor	91	call mouse._.find_sys_button_under_cursor
94	cmp eax, ecx	92	cmp eax, ecx
95	jne .exit	93	jne .exit
96	cmp ebx, edx	94	cmp ebx, edx
97	jne .exit	95	jne .exit
98		96
99	; yes it is, perform associated action	97	; yes it is, perform associated action
100	mov cl, [mouse.active_sys_button.buttons]	98	mov cl, [mouse.active_sys_button.buttons]
101	call sys_button_perform_handler	99	call sys_button_perform_handler
102	jmp .exit	100	jmp .exit
103		101
104	.buttons_changed:	102	.buttons_changed:
105	test byte[esp], mouse.LEFT_BUTTON_FLAG	103	test byte[esp], mouse.LEFT_BUTTON_FLAG
106	jz @f	104	jz @f
107	mov eax, [esp + 4]	105	mov eax, [esp + 4]
108	call .call_left_button_handler	106	call .call_left_button_handler
109		107
110	@@:	108	@@:
111	test byte[esp], mouse.RIGHT_BUTTON_FLAG	109	test byte[esp], mouse.RIGHT_BUTTON_FLAG
112	jz @f	110	jz @f
113	mov eax, [esp + 4]	111	mov eax, [esp + 4]
114	call .call_right_button_handler	112	call .call_right_button_handler
115		113
116	@@:	114	@@:
117	test byte[esp], mouse.MIDDLE_BUTTON_FLAG	115	test byte[esp], mouse.MIDDLE_BUTTON_FLAG
118	jz .check_position	116	jz .check_position
119	mov eax, [esp + 4]	117	mov eax, [esp + 4]
120	call .call_middle_button_handler	118	call .call_middle_button_handler
121		119
122	.check_position:	120	.check_position:
123	movzx eax, word[MOUSE_X]	121	movzx eax, word[MOUSE_X]
124	movzx ebx, word[MOUSE_Y]	122	movzx ebx, word[MOUSE_Y]
125	cmp eax, [mouse.state.pos.x]	123	cmp eax, [mouse.state.pos.x]
126	jne .position_changed	124	jne .position_changed
127	cmp ebx, [mouse.state.pos.y]	125	cmp ebx, [mouse.state.pos.y]
128	je .exit	126	je .exit
129		127
130	.position_changed:	128	.position_changed:
131	xchg eax, [mouse.state.pos.x]	129	xchg eax, [mouse.state.pos.x]
132	xchg ebx, [mouse.state.pos.y]	130	xchg ebx, [mouse.state.pos.y]
133		131
134	call mouse._.move_handler	132	call mouse._.move_handler
135		133
136	.exit:	134	.exit:
137	add esp, 8	135	add esp, 8
138	pop ebx eax	136	pop ebx eax
139	ret	137	ret
140		138
141	.call_left_button_handler:	139	.call_left_button_handler:
142	test eax, mouse.LEFT_BUTTON_FLAG	140	test eax, mouse.LEFT_BUTTON_FLAG
143	jnz mouse._.left_button_press_handler	141	jnz mouse._.left_button_press_handler
144	jmp mouse._.left_button_release_handler	142	jmp mouse._.left_button_release_handler
145		143
146	.call_right_button_handler:	144	.call_right_button_handler:
147	test eax, mouse.RIGHT_BUTTON_FLAG	145	test eax, mouse.RIGHT_BUTTON_FLAG
148	jnz mouse._.right_button_press_handler	146	jnz mouse._.right_button_press_handler
149	jmp mouse._.right_button_release_handler	147	jmp mouse._.right_button_release_handler
150		148
151	.call_middle_button_handler:	149	.call_middle_button_handler:
152	test eax, mouse.MIDDLE_BUTTON_FLAG	150	test eax, mouse.MIDDLE_BUTTON_FLAG
153	jnz mouse._.middle_button_press_handler	151	jnz mouse._.middle_button_press_handler
154	jmp mouse._.middle_button_release_handler	152	jmp mouse._.middle_button_release_handler
155		153
156	;===============================	154	;===============================
157	;////// private functions //////	155	;////// private functions //////
158	;===============================	156	;===============================
159		157
160	uglobal	158	uglobal
161	mouse.state:	159	mouse.state:
162	.pos POINT	160	.pos POINT
163	.buttons db ?	161	.buttons db ?
164		162
165	; NOTE: since there's no unique and lifetime-constant button identifiers,	163	; NOTE: since there's no unique and lifetime-constant button identifiers,
166	; we are using two dwords to identify each of them:	164	; we are using two dwords to identify each of them:
167	; * pbid - process slot (high 8 bits) and button id (low 24 bits) pack	165	; * pbid - process slot (high 8 bits) and button id (low 24 bits) pack
168	; * coord - left (high 16 bits) and top (low 16 bits) coordinates pack	166	; * coord - left (high 16 bits) and top (low 16 bits) coordinates pack
169	align 4	167	align 4
170	mouse.active_sys_button:	168	mouse.active_sys_button:
171	.pbid dd ?	169	.pbid dd ?
172	.coord dd ?	170	.coord dd ?
173	.buttons db ?	171	.buttons db ?
174		172
175	align 4	173	align 4
176	mouse.active_sys_window:	174	mouse.active_sys_window:
177	.pslot dd ?	175	.pslot dd ?
178	.old_box BOX	176	.old_box BOX
179	.new_box BOX	177	.new_box BOX
180	.delta POINT	178	.delta POINT
181	.last_ticks dd ?	179	.last_ticks dd ?
182	.action db ?	180	.action db ?
183	endg	181	endg
184		182
185	iglobal	183	iglobal
186	fl_moving db 0	184	fl_moving db 0
187	rb 3	185	rb 3
188	endg	186	endg
189		187
190	align 4	188	align 4
191	;-----------------------------------------------------------------	189	;-----------------------------------------------------------------
192	mouse._.left_button_press_handler:	190	mouse._.left_button_press_handler:
193	; Called when left mouse button has been pressed down	191	; Called when left mouse button has been pressed down
194	bts word [BTN_DOWN], 8	192	bts word [BTN_DOWN], 8
195	mov eax, [timer_ticks]	193	mov eax, [timer_ticks]
196	mov ebx, eax	194	mov ebx, eax
197	xchg ebx, [mouse.active_sys_window.last_ticks]	195	xchg ebx, [mouse.active_sys_window.last_ticks]
198	sub eax, ebx	196	sub eax, ebx
199	movzx ebx, [mouse_doubleclick_delay]	197	movzx ebx, [mouse_doubleclick_delay]
200	cmp eax, ebx	198	cmp eax, ebx
201	jg @f	199	jg @f
202	bts dword [BTN_DOWN], 24	200	bts dword [BTN_DOWN], 24
203	@@:	201	@@:
204	test [mouse.state.buttons], not mouse.LEFT_BUTTON_FLAG	202	test [mouse.state.buttons], not mouse.LEFT_BUTTON_FLAG
205	jnz .exit	203	jnz .exit
206		204
207	call mouse._.find_sys_window_under_cursor	205	call mouse._.find_sys_window_under_cursor
208	call mouse._.check_sys_window_actions	206	call mouse._.check_sys_window_actions
209	mov [mouse.active_sys_window.action], al	207	mov [mouse.active_sys_window.action], al
210	or eax, eax	208	or eax, eax
211	jz .exit	209	jz .exit
212		210
213	xchg eax, edx	211	xchg eax, edx
214	test dl, mouse.WINDOW_MOVE_FLAG	212	test dl, mouse.WINDOW_MOVE_FLAG
215	jz @f	213	jz @f
216		214
217	bt dword [BTN_DOWN], 24	215	bt dword [BTN_DOWN], 24
218	jnc @f	216	jnc @f
219		217
220	mov [mouse.active_sys_window.last_ticks], 0	218	mov [mouse.active_sys_window.last_ticks], 0
221	call sys_window_maximize_handler	219	call sys_window_maximize_handler
222	jmp .exit	220	jmp .exit
223		221
224	@@:	222	@@:
225	test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED	223	test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
226	jnz .exit	224	jnz .exit
227	mov [mouse.active_sys_window.pslot], esi	225	mov [mouse.active_sys_window.pslot], esi
228	lea eax, [edi + WDATA.box]	226	lea eax, [edi + WDATA.box]
229	mov ebx, mouse.active_sys_window.old_box	227	mov ebx, mouse.active_sys_window.old_box
230	mov ecx, sizeof.BOX	228	mov ecx, sizeof.BOX
231	call memmove	229	call memmove
232	mov ebx, mouse.active_sys_window.new_box	230	mov ebx, mouse.active_sys_window.new_box
233	call memmove	231	call memmove
234	test edx, mouse.WINDOW_MOVE_FLAG	232	test edx, mouse.WINDOW_MOVE_FLAG
235	jz @f	233	jz @f
236		234
237	call .calculate_n_delta	235	call .calculate_n_delta
238	call .calculate_w_delta	236	call .calculate_w_delta
239	jmp .call_window_handler	237	jmp .call_window_handler
240		238
241	@@:	239	@@:
242	test dl, mouse.WINDOW_RESIZE_W_FLAG	240	test dl, mouse.WINDOW_RESIZE_W_FLAG
243	jz @f	241	jz @f
244	call .calculate_w_delta	242	call .calculate_w_delta
245		243
246	@@:	244	@@:
247	test dl, mouse.WINDOW_RESIZE_S_FLAG	245	test dl, mouse.WINDOW_RESIZE_S_FLAG
248	jz @f	246	jz @f
249	call .calculate_s_delta	247	call .calculate_s_delta
250		248
251	@@:	249	@@:
252	test dl, mouse.WINDOW_RESIZE_E_FLAG	250	test dl, mouse.WINDOW_RESIZE_E_FLAG
253	jz .call_window_handler	251	jz .call_window_handler
254	call .calculate_e_delta	252	call .calculate_e_delta
255		253
256	.call_window_handler:	254	.call_window_handler:
257	.exit:	255	.exit:
258	ret	256	ret
259		257
260	.calculate_n_delta:	258	.calculate_n_delta:
261	mov eax, [mouse.state.pos.y]	259	mov eax, [mouse.state.pos.y]
262	sub eax, [mouse.active_sys_window.old_box.top]	260	sub eax, [mouse.active_sys_window.old_box.top]
263	mov [mouse.active_sys_window.delta.y], eax	261	mov [mouse.active_sys_window.delta.y], eax
264	ret	262	ret
265		263
266	.calculate_w_delta:	264	.calculate_w_delta:
267	mov eax, [mouse.state.pos.x]	265	mov eax, [mouse.state.pos.x]
268	sub eax, [mouse.active_sys_window.old_box.left]	266	sub eax, [mouse.active_sys_window.old_box.left]
269	mov [mouse.active_sys_window.delta.x], eax	267	mov [mouse.active_sys_window.delta.x], eax
270	ret	268	ret
271		269
272	.calculate_s_delta:	270	.calculate_s_delta:
273	mov eax, [mouse.active_sys_window.old_box.top]	271	mov eax, [mouse.active_sys_window.old_box.top]
274	add eax, [mouse.active_sys_window.old_box.height]	272	add eax, [mouse.active_sys_window.old_box.height]
275	sub eax, [mouse.state.pos.y]	273	sub eax, [mouse.state.pos.y]
276	mov [mouse.active_sys_window.delta.y], eax	274	mov [mouse.active_sys_window.delta.y], eax
277	ret	275	ret
278		276
279	.calculate_e_delta:	277	.calculate_e_delta:
280	mov eax, [mouse.active_sys_window.old_box.left]	278	mov eax, [mouse.active_sys_window.old_box.left]
281	add eax, [mouse.active_sys_window.old_box.width]	279	add eax, [mouse.active_sys_window.old_box.width]
282	sub eax, [mouse.state.pos.x]	280	sub eax, [mouse.state.pos.x]
283	mov [mouse.active_sys_window.delta.x], eax	281	mov [mouse.active_sys_window.delta.x], eax
284	ret	282	ret
285		283
286	align 4	284	align 4
287	;-----------------------------------------------------------------	285	;-----------------------------------------------------------------
288	mouse._.left_button_release_handler:	286	mouse._.left_button_release_handler:
289	; Called when left mouse button has been released	287	; Called when left mouse button has been released
290	bts dword [BTN_DOWN], 16	288	bts dword [BTN_DOWN], 16
291	xor esi, esi	289	xor esi, esi
292	xchg esi, [mouse.active_sys_window.pslot]	290	xchg esi, [mouse.active_sys_window.pslot]
293	or esi, esi	291	or esi, esi
294	jz .exit	292	jz .exit
295		293
296	mov eax, esi	294	mov eax, esi
297	shl eax, BSF sizeof.WDATA	295	shl eax, BSF sizeof.WDATA
298	add eax, window_data + WDATA.box	296	add eax, window_data + WDATA.box
299	mov ebx, mouse.active_sys_window.old_box	297	mov ebx, mouse.active_sys_window.old_box
300	mov ecx, sizeof.BOX	298	mov ecx, sizeof.BOX
301	call memmove	299	call memmove
302		300
303	mov eax, mouse.active_sys_window.old_box	301	mov eax, mouse.active_sys_window.old_box
304	mov ebx, mouse.active_sys_window.new_box	302	mov ebx, mouse.active_sys_window.new_box
305	call sys_window_end_moving_handler	303	call sys_window_end_moving_handler
306		304
307	.exit:	305	.exit:
308	and [mouse.active_sys_window.action], 0	306	and [mouse.active_sys_window.action], 0
309	mov [fl_moving], 0	307	mov [fl_moving], 0
310	ret	308	ret
311		309
312	mouse._.right_button_press_handler:	310	mouse._.right_button_press_handler:
313	bts word [BTN_DOWN], 9	311	bts word [BTN_DOWN], 9
314	test [mouse.state.buttons], not mouse.RIGHT_BUTTON_FLAG	312	test [mouse.state.buttons], not mouse.RIGHT_BUTTON_FLAG
315	jnz @f	313	jnz @f
316	call mouse._.find_sys_window_under_cursor	314	call mouse._.find_sys_window_under_cursor
317	call mouse._.check_sys_window_actions	315	call mouse._.check_sys_window_actions
318	test al, mouse.WINDOW_MOVE_FLAG	316	test al, mouse.WINDOW_MOVE_FLAG
319	jz @f	317	jz @f
320	jmp sys_window_rollup_handler	318	jmp sys_window_rollup_handler
321		319
322	mouse._.right_button_release_handler:	320	mouse._.right_button_release_handler:
323	bts dword [BTN_DOWN], 17	321	bts dword [BTN_DOWN], 17
324	@@:	322	@@:
325	ret	323	ret
326		324
327	mouse._.middle_button_press_handler:	325	mouse._.middle_button_press_handler:
328	bts word [BTN_DOWN], 10	326	bts word [BTN_DOWN], 10
329	ret	327	ret
330		328
331	mouse._.middle_button_release_handler:	329	mouse._.middle_button_release_handler:
332	bts dword [BTN_DOWN], 18	330	bts dword [BTN_DOWN], 18
333	ret	331	ret
334		332
335	align 4	333	align 4
336	;-----------------------------------------------------------------	334	;-----------------------------------------------------------------
337	mouse._.move_handler:	335	mouse._.move_handler:
338	; Called when cursor has been moved	336	; Called when cursor has been moved
339	;> eax = old x coord	337	;> eax = old x coord
340	;> ebx = old y coord	338	;> ebx = old y coord
341	push eax ebx	339	push eax ebx
342		340
343	call mouse._.find_sys_window_under_cursor	341	call mouse._.find_sys_window_under_cursor
344	call mouse._.check_sys_window_actions	342	call mouse._.check_sys_window_actions
345		343
346	; if now we are resizing the window, dont change the cursor	344	; if now we are resizing the window, dont change the cursor
347	mov bl, [mouse.active_sys_window.action]	345	mov bl, [mouse.active_sys_window.action]
348	and bl, mouse.WINDOW_RESIZE_S_FLAG or mouse.WINDOW_RESIZE_W_FLAG or mouse.WINDOW_RESIZE_E_FLAG	346	and bl, mouse.WINDOW_RESIZE_S_FLAG or mouse.WINDOW_RESIZE_W_FLAG or mouse.WINDOW_RESIZE_E_FLAG
349	test bl, bl	347	test bl, bl
350	jnz .end1	348	jnz .end1
351		349
352	cmp al, mouse.WINDOW_RESIZE_SW_FLAG	350	cmp al, mouse.WINDOW_RESIZE_SW_FLAG
353	jne .not_sw	351	jne .not_sw
354	; DEBUGF 1, "RESIZE SOUTH-WEST\n"	352	; DEBUGF 1, "RESIZE SOUTH-WEST\n"
355		353
356	mov eax, [def_cursor_dresize2]	354	mov eax, [def_cursor_dresize2]
357		355
358	jmp .set_resizing_cursor	356	jmp .set_resizing_cursor
359	.not_sw:	357	.not_sw:
360	cmp al, mouse.WINDOW_RESIZE_SE_FLAG	358	cmp al, mouse.WINDOW_RESIZE_SE_FLAG
361	jne .not_se	359	jne .not_se
362	; DEBUGF 1, "RESIZE SOUTH-EAST\n"	360	; DEBUGF 1, "RESIZE SOUTH-EAST\n"
363		361
364	mov eax, [def_cursor_dresize1]	362	mov eax, [def_cursor_dresize1]
365		363
366	jmp .set_resizing_cursor	364	jmp .set_resizing_cursor
367	.not_se:	365	.not_se:
368	cmp al, mouse.WINDOW_RESIZE_W_FLAG	366	cmp al, mouse.WINDOW_RESIZE_W_FLAG
369	jne .not_w	367	jne .not_w
370	; DEBUGF 1, "RESIZE WEST\n"	368	; DEBUGF 1, "RESIZE WEST\n"
371		369
372	mov eax, [def_cursor_hresize]	370	mov eax, [def_cursor_hresize]
373		371
374	jmp .set_resizing_cursor	372	jmp .set_resizing_cursor
375	.not_w:	373	.not_w:
376	cmp al, mouse.WINDOW_RESIZE_S_FLAG	374	cmp al, mouse.WINDOW_RESIZE_S_FLAG
377	jne .not_s	375	jne .not_s
378	; DEBUGF 1, "RESIZE SOUTH\n"	376	; DEBUGF 1, "RESIZE SOUTH\n"
379		377
380	mov eax, [def_cursor_vresize]	378	mov eax, [def_cursor_vresize]
381		379
382	jmp .set_resizing_cursor	380	jmp .set_resizing_cursor
383	.not_s:	381	.not_s:
384	cmp al, mouse.WINDOW_RESIZE_E_FLAG	382	cmp al, mouse.WINDOW_RESIZE_E_FLAG
385	jne .not_in_resize_area	383	jne .not_in_resize_area
386	; DEBUGF 1, "RESIZE EAST\n"	384	; DEBUGF 1, "RESIZE EAST\n"
387		385
388	mov eax, [def_cursor_hresize]	386	mov eax, [def_cursor_hresize]
389		387
390	.set_resizing_cursor:	388	.set_resizing_cursor:
391	; DEBUGF 1, ".set_resizing_cursor eax = %x\n", eax	389	; DEBUGF 1, ".set_resizing_cursor eax = %x\n", eax
392	; change cursor to resizing cursor	390	; change cursor to resizing cursor
393	shl esi, BSF sizeof.WDATA	391	shl esi, BSF sizeof.WDATA
394	add esi, window_data	392	add esi, window_data
395		393
396	; if resizing cursor we need (eax) isnt set already, set it	394	; if resizing cursor we need (eax) isnt set already, set it
397	cmp eax, [esi + WDATA.cursor]	395	cmp eax, [esi + WDATA.cursor]
398	je @f	396	je @f
399		397
400	; DEBUGF 1, "changing cursor to resizing\n"	398	; DEBUGF 1, "changing cursor to resizing\n"
401	xchg eax, [esi + WDATA.cursor] ; set resizing cursor, prev cursor goes to eax	399	xchg eax, [esi + WDATA.cursor] ; set resizing cursor, prev cursor goes to eax
402	; save previous cursor (will be restored when we'll get out of the resizing area)	400	; save previous cursor (will be restored when we'll get out of the resizing area)
403	; if we change resizing cursor to resizing cursor then dont update previous cursor	401	; if we change resizing cursor to resizing cursor then dont update previous cursor
404	cmp eax, [def_cursor_hresize]	402	cmp eax, [def_cursor_hresize]
405	je @f	403	je @f
406	cmp eax, [def_cursor_vresize]	404	cmp eax, [def_cursor_vresize]
407	je @f	405	je @f
408	cmp eax, [def_cursor_dresize1]	406	cmp eax, [def_cursor_dresize1]
409	je @f	407	je @f
410	cmp eax, [def_cursor_dresize2]	408	cmp eax, [def_cursor_dresize2]
411	je @f	409	je @f
412		410
413	mov [esi + WDATA.temp_cursor], eax ; save prev cursor	411	mov [esi + WDATA.temp_cursor], eax ; save prev cursor
414		412
415	@@:	413	@@:
416	jmp .end1	414	jmp .end1
417	.not_in_resize_area:	415	.not_in_resize_area:
418	; DEBUGF 1, ".not_in_resize_area\n"	416	; DEBUGF 1, ".not_in_resize_area\n"
419		417
420	shl esi, BSF sizeof.WDATA	418	shl esi, BSF sizeof.WDATA
421	add esi, window_data	419	add esi, window_data
422	mov eax, [esi + WDATA.temp_cursor]	420	mov eax, [esi + WDATA.temp_cursor]
423		421
424	test eax, eax	422	test eax, eax
425	jz .end1	423	jz .end1
426		424
427	; restore prev cursor	425	; restore prev cursor
428	mov [esi + WDATA.temp_cursor], 0	426	mov [esi + WDATA.temp_cursor], 0
429	mov [esi + WDATA.cursor], eax	427	mov [esi + WDATA.cursor], eax
430		428
431	.end1:	429	.end1:
432	pop ebx eax	430	pop ebx eax
433		431
434	cmp [mouse.active_sys_button.pbid], 0	432	cmp [mouse.active_sys_button.pbid], 0
435	jnz .exit	433	jnz .exit
436		434
437	mov esi, [mouse.active_sys_window.pslot]	435	mov esi, [mouse.active_sys_window.pslot]
438	or esi, esi	436	or esi, esi
439	jz .exit	437	jz .exit
440		438
441	mov eax, mouse.active_sys_window.new_box	439	mov eax, mouse.active_sys_window.new_box
442	mov ebx, mouse.active_sys_window.old_box	440	mov ebx, mouse.active_sys_window.old_box
443	mov ecx, sizeof.BOX	441	mov ecx, sizeof.BOX
444	call memmove	442	call memmove
445		443
446	mov dl, [mouse.active_sys_window.action]	444	mov dl, [mouse.active_sys_window.action]
447	test dl, mouse.WINDOW_MOVE_FLAG	445	test dl, mouse.WINDOW_MOVE_FLAG
448	jz .check_resize_w	446	jz .check_resize_w
449		447
450	mov eax, [mouse.state.pos.x]	448	mov eax, [mouse.state.pos.x]
451	sub eax, [mouse.active_sys_window.delta.x]	449	sub eax, [mouse.active_sys_window.delta.x]
452	mov [mouse.active_sys_window.new_box.left], eax	450	mov [mouse.active_sys_window.new_box.left], eax
453	mov eax, [mouse.state.pos.y]	451	mov eax, [mouse.state.pos.y]
454	sub eax, [mouse.active_sys_window.delta.y]	452	sub eax, [mouse.active_sys_window.delta.y]
455	mov [mouse.active_sys_window.new_box.top], eax	453	mov [mouse.active_sys_window.new_box.top], eax
456		454
457	mov eax, [mouse.active_sys_window.new_box.left]	455	mov eax, [mouse.active_sys_window.new_box.left]
458	or eax, eax	456	or eax, eax
459	jge @f	457	jge @f
460	xor eax, eax	458	xor eax, eax
461	mov [mouse.active_sys_window.new_box.left], eax	459	mov [mouse.active_sys_window.new_box.left], eax
462	@@:	460	@@:
463	add eax, [mouse.active_sys_window.new_box.width]	461	add eax, [mouse.active_sys_window.new_box.width]
464	cmp eax, [_display.width]	462	cmp eax, [_display.width]
465	jl @f	463	jl @f
466	sub eax, [_display.width]	464	sub eax, [_display.width]
467	inc eax	465	inc eax
468	sub [mouse.active_sys_window.new_box.left], eax	466	sub [mouse.active_sys_window.new_box.left], eax
469	@@:	467	@@:
470	mov eax, [mouse.active_sys_window.new_box.top]	468	mov eax, [mouse.active_sys_window.new_box.top]
471	or eax, eax	469	or eax, eax
472	jge @f	470	jge @f
473	xor eax, eax	471	xor eax, eax
474	mov [mouse.active_sys_window.new_box.top], eax	472	mov [mouse.active_sys_window.new_box.top], eax
475	@@:	473	@@:
476	add eax, [mouse.active_sys_window.new_box.height]	474	add eax, [mouse.active_sys_window.new_box.height]
477	cmp eax, [_display.height]	475	cmp eax, [_display.height]
478	jl .call_window_handler	476	jl .call_window_handler
479	sub eax, [_display.height]	477	sub eax, [_display.height]
480	inc eax	478	inc eax
481	sub [mouse.active_sys_window.new_box.top], eax	479	sub [mouse.active_sys_window.new_box.top], eax
482	jmp .call_window_handler	480	jmp .call_window_handler
483		481
484	.check_resize_w:	482	.check_resize_w:
485	test dl, mouse.WINDOW_RESIZE_W_FLAG	483	test dl, mouse.WINDOW_RESIZE_W_FLAG
486	jz .check_resize_s	484	jz .check_resize_s
487		485
488	mov eax, [mouse.state.pos.x]	486	mov eax, [mouse.state.pos.x]
489	sub eax, [mouse.active_sys_window.delta.x]	487	sub eax, [mouse.active_sys_window.delta.x]
490	mov [mouse.active_sys_window.new_box.left], eax	488	mov [mouse.active_sys_window.new_box.left], eax
491	sub eax, [mouse.active_sys_window.old_box.left]	489	sub eax, [mouse.active_sys_window.old_box.left]
492	sub [mouse.active_sys_window.new_box.width], eax	490	sub [mouse.active_sys_window.new_box.width], eax
493		491
494	mov eax, [mouse.active_sys_window.new_box.width]	492	mov eax, [mouse.active_sys_window.new_box.width]
495	sub eax, 127	493	sub eax, 127
496	jge @f	494	jge @f
497	add [mouse.active_sys_window.new_box.left], eax	495	add [mouse.active_sys_window.new_box.left], eax
498	mov [mouse.active_sys_window.new_box.width], 127	496	mov [mouse.active_sys_window.new_box.width], 127
499	@@:	497	@@:
500	mov eax, [mouse.active_sys_window.new_box.left]	498	mov eax, [mouse.active_sys_window.new_box.left]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/mouse.inc @ 6016 – Rev 9930 → 9941