WebSVN – Kolibri OS – Diff – /kernel/trunk/video/cursors.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2288 $
 
 
LOAD_FROM_FILE  equ 0
LOAD_FROM_MEM   equ 1
LOAD_INDIRECT   equ 2
LOAD_SYSTEM     equ 3
 
struc BITMAPINFOHEADER {
  .biSize          dd ? ; DWORD
  .biWidth         dd ? ; LONG
  .biHeight        dd ? ; LONG
  .biPlanes        dw ? ; WORD
  .biBitCount      dw ? ; WORD
  .biCompression   dd ? ; DWORD
  .biSizeImage     dd ? ; DWORD
  .biXPelsPerMeter dd ? ; LONG
  .biYPelsPerMeter dd ? ; LONG
  .biClrUsed       dd ? ; DWORD
  .biClrImportant  dd ? ; DWORD
}
 
virtual at 0
  BI BITMAPINFOHEADER
end virtual
 
align 4
proc init_cursor stdcall, dst:dword, src:dword
           locals
             rBase    dd ?
             pQuad    dd ?
             pBits    dd ?
             pAnd     dd ?
             width    dd ?
             height   dd ?
             counter  dd ?
           endl
 
        mov     esi, [src]
        add     esi, [esi+18]
        mov     eax, esi
 
        cmp     [esi+BI.biBitCount], 24
        je      .img_24
        cmp     [esi+BI.biBitCount], 8
        je      .img_8
        cmp     [esi+BI.biBitCount], 4
        je      .img_4
 
.img_2:
        add     eax, [esi]
        mov     [pQuad], eax
        add     eax, 8
        mov     [pBits], eax
        add     eax, 128
        mov     [pAnd], eax
        mov     eax, [esi+4]
        mov     [width], eax
        mov     ebx, [esi+8]
        shr     ebx, 1
        mov     [height], ebx
 
        mov     edi, [dst]
        add     edi, 32*31*4
        mov     [rBase], edi
 
        mov     esi, [pQuad]
.l21:
        mov     ebx, [pBits]
        mov     ebx, [ebx]
        bswap   ebx
        mov     eax, [pAnd]
        mov     eax, [eax]
        bswap   eax
        mov     [counter], 32
@@:
        xor     edx, edx
        shl     eax, 1
        setc    dl
        dec     edx
 
        xor     ecx, ecx
        shl     ebx, 1
        setc    cl
        mov     ecx, [esi+ecx*4]
        and     ecx, edx
        and     edx, 0xFF000000
        or      edx, ecx
        mov     [edi], edx
 
        add     edi, 4
        dec     [counter]
        jnz     @B
 
        add     [pBits], 4
        add     [pAnd], 4
        mov     edi, [rBase]
        sub     edi, 128
        mov     [rBase], edi
        sub     [height], 1
        jnz     .l21
        ret
 
.img_4:
        add     eax, [esi]
        mov     [pQuad], eax
        add     eax, 64
        mov     [pBits], eax
        add     eax, 0x200
        mov     [pAnd], eax
        mov     eax, [esi+4]
        mov     [width], eax
        mov     ebx, [esi+8]
        shr     ebx, 1
        mov     [height], ebx
 
        mov     edi, [dst]
        add     edi, 32*31*4
        mov     [rBase], edi
 
        mov     esi, [pQuad]
        mov     ebx, [pBits]
.l4:
        mov     eax, [pAnd]
        mov     eax, [eax]
        bswap   eax
        mov     [counter], 16
@@:
        xor     edx, edx
        shl     eax, 1
        setc    dl
        dec     edx
 
        movzx   ecx, byte [ebx]
        and     cl, 0xF0
        shr     ecx, 2
        mov     ecx, [esi+ecx]
        and     ecx, edx
        and     edx, 0xFF000000
        or      edx, ecx
        mov     [edi], edx
 
        xor     edx, edx
        shl     eax, 1
        setc    dl
        dec     edx
 
        movzx   ecx, byte [ebx]
        and     cl, 0x0F
        mov     ecx, [esi+ecx*4]
        and     ecx, edx
        and     edx, 0xFF000000
        or      edx, ecx
        mov     [edi+4], edx
 
        inc     ebx
        add     edi, 8
        dec     [counter]
        jnz     @B
 
        add     [pAnd], 4
        mov     edi, [rBase]
        sub     edi, 128
        mov     [rBase], edi
        sub     [height], 1
        jnz     .l4
        ret
.img_8:
        add     eax, [esi]
        mov     [pQuad], eax
        add     eax, 1024
        mov     [pBits], eax
        add     eax, 1024
        mov     [pAnd], eax
        mov     eax, [esi+4]
        mov     [width], eax
        mov     ebx, [esi+8]
        shr     ebx, 1
        mov     [height], ebx
 
        mov     edi, [dst]
        add     edi, 32*31*4
        mov     [rBase], edi
 
        mov     esi, [pQuad]
        mov     ebx, [pBits]
.l81:
        mov     eax, [pAnd]
        mov     eax, [eax]
        bswap   eax
        mov     [counter], 32
@@:
        xor     edx, edx
        shl     eax, 1
        setc    dl
        dec     edx
 
        movzx   ecx, byte [ebx]
        mov     ecx, [esi+ecx*4]
        and     ecx, edx
        and     edx, 0xFF000000
        or      edx, ecx
        mov     [edi], edx
 
        inc     ebx
        add     edi, 4
        dec     [counter]
        jnz     @B
 
        add     [pAnd], 4
        mov     edi, [rBase]
        sub     edi, 128
        mov     [rBase], edi
        sub     [height], 1
        jnz     .l81
        ret
.img_24:
        add     eax, [esi]
        mov     [pQuad], eax
        add     eax, 0xC00
        mov     [pAnd], eax
        mov     eax, [esi+BI.biWidth]
        mov     [width], eax
        mov     ebx, [esi+BI.biHeight]
        shr     ebx, 1
        mov     [height], ebx
 
        mov     edi, [dst]
        add     edi, 32*31*4
        mov     [rBase], edi
 
        mov     esi, [pAnd]
        mov     ebx, [pQuad]
.row_24:
        mov     eax, [esi]
        bswap   eax
        mov     [counter], 32
@@:
        xor     edx, edx
        shl     eax, 1
        setc    dl
        dec     edx
 
        mov     ecx, [ebx]
        and     ecx, 0x00FFFFFF
        and     ecx, edx
        and     edx, 0xFF000000
        or      edx, ecx
        mov     [edi], edx
        add     ebx, 3
        add     edi, 4
        dec     [counter]
        jnz     @B
 
        add     esi, 4
        mov     edi, [rBase]
        sub     edi, 128
        mov     [rBase], edi
        sub     [height], 1
        jnz     .row_24
        ret
endp
 
align 4
proc set_cursor stdcall, hcursor:dword
        mov     eax, [hcursor]
        cmp     [eax+CURSOR.magic], 'CURS'
        jne     .fail
;           cmp [eax+CURSOR.size], CURSOR_SIZE
;           jne .fail
        mov     ebx, [current_slot]
        xchg    eax, [ebx+APPDATA.cursor]
        ret
.fail:
        mov     eax, [def_cursor]
        mov     ebx, [current_slot]
        xchg    eax, [ebx+APPDATA.cursor]
        ret
endp
 
; param
;  eax= pid
;  ebx= src
;  ecx= flags
 
create_cursor:
.src     equ esp
.flags   equ esp+4
.hcursor equ esp+8
 
        sub     esp, 4         ;space for .hcursor
        push    ecx
        push    ebx
 
        mov     ebx, eax
        mov     eax, CURSOR.sizeof
        call    create_kernel_object
        test    eax, eax
        jz      .fail
 
        mov     [.hcursor], eax
 
        xor     ebx, ebx
        mov     [eax+CURSOR.magic], 'CURS'
        mov     [eax+CURSOR.destroy], destroy_cursor
        mov     [eax+CURSOR.hot_x], ebx
        mov     [eax+CURSOR.hot_y], ebx
 
        stdcall kernel_alloc, 0x1000
        test    eax, eax
        jz      .fail
 
        mov     edi, [.hcursor]
        mov     [edi+CURSOR.base], eax
 
        mov     esi, [.src]
        mov     ebx, [.flags]
        cmp     bx, LOAD_INDIRECT
        je      .indirect
 
        movzx   ecx, word [esi+10]
        movzx   edx, word [esi+12]
        mov     [edi+CURSOR.hot_x], ecx
        mov     [edi+CURSOR.hot_y], edx
 
        stdcall init_cursor, eax, esi
 
        mov     eax, [.hcursor]
        lea     eax, [eax+CURSOR.list_next]
        lea     edx, [_display.cr_list.next]
 
        pushfd
        cli
        mov     ecx, [edx]
 
        mov     [eax], ecx
        mov     [eax+4], edx
 
        mov     [ecx+4], eax
        mov     [edx], eax
        popfd
 
        mov     eax, [.hcursor]
.check_hw:
        cmp     [_display.init_cursor], 0
        je      .fail
 
        push    eax
        call    [_display.init_cursor]
        add     esp, 4
 
        mov     eax, [.hcursor]
.fail:
        add     esp, 12
        ret
.indirect:
        shr     ebx, 16
        movzx   ecx, bh
        movzx   edx, bl
        mov     [eax+CURSOR.hot_x], ecx
        mov     [eax+CURSOR.hot_y], edx
 
        xchg    edi, eax
        mov     ecx, 1024
        cld
        rep movsd
        jmp     .check_hw
 
align 4
proc load_cursor stdcall, src:dword, flags:dword
           locals
             handle  dd ?
           endl
 
        xor     eax, eax
        cmp     [create_cursor], eax
        je      .fail2
 
        mov     [handle], eax
        cmp     word [flags], LOAD_FROM_FILE
        jne     @F
 
        stdcall load_file, [src]
        test    eax, eax
        jz      .fail
        mov     [src], eax
@@:
        push    ebx
        push    esi
        push    edi
 
        mov     eax, [CURRENT_TASK]
        shl     eax, 5
        mov     eax, [CURRENT_TASK+eax+4]
        mov     ebx, [src]
        mov     ecx, [flags]
        call    create_cursor    ;eax, ebx, ecx
        mov     [handle], eax
 
        cmp     word [flags], LOAD_FROM_FILE
        jne     .exit
        stdcall kernel_free, [src]
.exit:
        pop     edi
        pop     esi
        pop     ebx
.fail:
        mov     eax, [handle]
.fail2:
        ret
endp
 
align 4
proc delete_cursor stdcall, hcursor:dword
           locals
             hsrv       dd ?
             io_code    dd ?
             input      dd ?
             inp_size   dd ?
             output     dd ?
             out_size   dd ?
           endl
 
        mov     esi, [hcursor]
        cmp     [esi+CURSOR.magic], 'CURS'
        jne     .fail
 
        mov     ebx, [CURRENT_TASK]
        shl     ebx, 5
        mov     ebx, [CURRENT_TASK+ebx+4]
        cmp     ebx, [esi+CURSOR.pid]
        jne     .fail
 
        mov     ebx, [current_slot]
        cmp     esi, [ebx+APPDATA.cursor]
        jne     @F
        mov     eax, [def_cursor]
        mov     [ebx+APPDATA.cursor], eax
@@:
        mov     eax, [hcursor]
        call    [eax+APPOBJ.destroy]
.fail:
        ret
endp
 
; param
;  eax= cursor
 
align 4
destroy_cursor:
 
        push    eax
        stdcall kernel_free, [eax+CURSOR.base]
        pop     eax
 
        call    destroy_kernel_object
        ret
 
align 4
select_cursor:
        mov     eax, [esp+4]
        mov     [_display.cursor], eax
        ret     4
 
align 4
proc restore_24 stdcall, x:dword, y:dword
 
        push    ebx
 
        mov     ebx, [cur_saved_base]
        mov     edx, [cur.h]
        test    edx, edx
        jz      .ret
 
        push    esi
        push    edi
 
        mov     esi, cur_saved_data
        mov     ecx, [cur.w]
        lea     ecx, [ecx+ecx*2]
        push    ecx
@@:
        mov     edi, ebx
        add     ebx, [BytesPerScanLine]
 
        mov     ecx, [esp]
        rep movsb
        dec     edx
        jnz     @B
 
        pop     ecx
        pop     edi
        pop     esi
.ret:
        pop     ebx
        ret
endp
 
align 4
proc restore_32 stdcall, x:dword, y:dword
 
        push    ebx
 
        mov     ebx, [cur_saved_base]
        mov     edx, [cur.h]
        test    edx, edx
        jz      .ret
 
        push    esi
        push    edi
 
        mov     esi, cur_saved_data
@@:
        mov     edi, ebx
        add     ebx, [BytesPerScanLine]
 
        mov     ecx, [cur.w]
        rep movsd
        dec     edx
        jnz     @B
 
        pop     edi
.ret:
        pop     esi
        pop     ebx
        ret
endp
 
align 4
proc move_cursor_24 stdcall, hcursor:dword, x:dword, y:dword
           locals
             h      dd ?
             _dx     dd ?
             _dy     dd ?
           endl
 
        mov     esi, [hcursor]
        mov     ecx, [x]
        mov     eax, [y]
        mov     ebx, [BytesPerScanLine]
 
        xor     edx, edx
        sub     ecx, [esi+CURSOR.hot_x]
        lea     ebx, [ecx+32-1]
        mov     [x], ecx
        sets    dl
        dec     edx
        and     ecx, edx      ;clip x to 0<=x
        mov     [cur.left], ecx
        mov     edi, ecx
        sub     edi, [x]
        mov     [_dx], edi
 
        xor     edx, edx
        sub     eax, [esi+CURSOR.hot_y]
        lea     edi, [eax+32-1]
        mov     [y], eax
        sets    dl
        dec     edx
        and     eax, edx      ;clip y to 0<=y
        mov     [cur.top], eax
        mov     edx, eax
        sub     edx, [y]
        mov     [_dy], edx
 
        mul     dword [BytesPerScanLine]
        lea     edx, [LFB_BASE+ecx*3]
        add     edx, eax
        mov     [cur_saved_base], edx
 
        cmp     ebx, [Screen_Max_X]
        jbe     @F
        mov     ebx, [Screen_Max_X]
@@:
        cmp     edi, [Screen_Max_Y]
        jbe     @F
        mov     edi, [Screen_Max_Y]
@@:
        mov     [cur.right], ebx
        mov     [cur.bottom], edi
 
        sub     ebx, [x]
        sub     edi, [y]
        inc     ebx
        inc     edi
 
        mov     [cur.w], ebx
        mov     [cur.h], edi
        mov     [h], edi
 
        mov     eax, edi
        mov     edi, cur_saved_data
@@:
        mov     esi, edx
        add     edx, [BytesPerScanLine]
        mov     ecx, [cur.w]
        lea     ecx, [ecx+ecx*2]
        rep movsb
        dec     eax
        jnz     @B
 
;draw cursor
        mov     ebx, [cur_saved_base]
        mov     eax, [_dy]
        shl     eax, 5
        add     eax, [_dx]
 
        mov     esi, [hcursor]
        mov     esi, [esi+CURSOR.base]
        lea     edx, [esi+eax*4]
.row:
        mov     ecx, [cur.w]
        mov     esi, edx
        mov     edi, ebx
        add     edx, 32*4
        add     ebx, [BytesPerScanLine]
.pix:
        lodsd
        test    eax, 0xFF000000
        jz      @F
        mov     [edi], ax
        shr     eax, 16
        mov     [edi+2], al
@@:
        add     edi, 3
        dec     ecx
        jnz     .pix
 
        dec     [h]
        jnz     .row
        ret
endp
 
 
align 4
proc move_cursor_32 stdcall, hcursor:dword, x:dword, y:dword
           locals
             h      dd ?
             _dx     dd ?
             _dy     dd ?
           endl
 
        mov     esi, [hcursor]
        mov     ecx, [x]
        mov     eax, [y]
 
        xor     edx, edx
        sub     ecx, [esi+CURSOR.hot_x]
        lea     ebx, [ecx+32-1]
        mov     [x], ecx
        sets    dl
        dec     edx
        and     ecx, edx      ;clip x to 0<=x
        mov     [cur.left], ecx
        mov     edi, ecx
        sub     edi, [x]
        mov     [_dx], edi
 
        xor     edx, edx
        sub     eax, [esi+CURSOR.hot_y]
        lea     edi, [eax+32-1]
        mov     [y], eax
        sets    dl
        dec     edx
        and     eax, edx      ;clip y to 0<=y
        mov     [cur.top], eax
        mov     edx, eax
        sub     edx, [y]
        mov     [_dy], edx
 
        mul     dword [BytesPerScanLine]
        lea     edx, [LFB_BASE+eax+ecx*4]
        mov     [cur_saved_base], edx
 
        cmp     ebx, [Screen_Max_X]
        jbe     @F
        mov     ebx, [Screen_Max_X]
@@:
        cmp     edi, [Screen_Max_Y]
        jbe     @F
        mov     edi, [Screen_Max_Y]
@@:
        mov     [cur.right], ebx
        mov     [cur.bottom], edi
 
        sub     ebx, [x]
        sub     edi, [y]
        inc     ebx
        inc     edi
 
        mov     [cur.w], ebx
        mov     [cur.h], edi
        mov     [h], edi
 
        mov     eax, edi
        mov     edi, cur_saved_data
@@:
        mov     esi, edx
        add     edx, [BytesPerScanLine]
        mov     ecx, [cur.w]
        rep movsd
        dec     eax
        jnz     @B
 
;draw cursor
        mov     ebx, [cur_saved_base]
        mov     eax, [_dy]
        shl     eax, 5
        add     eax, [_dx]
 
        mov     esi, [hcursor]
        mov     esi, [esi+CURSOR.base]
        lea     edx, [esi+eax*4]
.row:
        mov     ecx, [cur.w]
        mov     esi, edx
        mov     edi, ebx
        add     edx, 32*4
        add     ebx, [BytesPerScanLine]
.pix:
        lodsd
        test    eax, 0xFF000000
        jz      @F
        mov     [edi], eax
@@:
        add     edi, 4
        dec     ecx
        jnz     .pix
 
        dec     [h]
        jnz     .row
        ret
endp
 
 
align 4
get_display:
        mov     eax, _display
        ret
 
align 4
init_display:
 
        xor     eax, eax
        mov     edi, _display
 
        mov     [edi+display_t.init_cursor], eax
        mov     [edi+display_t.select_cursor], eax
        mov     [edi+display_t.show_cursor], eax
        mov     [edi+display_t.move_cursor], eax
        mov     [edi+display_t.restore_cursor], eax
 
        lea     ecx, [edi+display_t.cr_list.next]
        mov     [edi+display_t.cr_list.next], ecx
        mov     [edi+display_t.cr_list.prev], ecx
 
        cmp     [SCR_MODE], word 0x13
        jbe     .fail
 
        test    word [SCR_MODE], 0x4000
        jz      .fail
 
        mov     ebx, restore_32
        mov     ecx, move_cursor_32
        movzx   eax, byte [ScreenBPP]
        cmp     eax, 32
        je      @F
 
        mov     ebx, restore_24
        mov     ecx, move_cursor_24
        cmp     eax, 24
        jne     .fail
@@:
        mov     [_display.select_cursor], select_cursor
        mov     [_display.move_cursor], ecx
        mov     [_display.restore_cursor], ebx
 
        stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
        mov     [def_cursor], eax
        ret
.fail:
        xor     eax, eax
        mov     [_display.select_cursor], eax
        mov     [_display.move_cursor], eax
        ret
 
 
 
 
 
 
 
 
 
 
align 4
def_arrow:
  file 'arrow.cur'
>
>
>
>

Rev 1316	Rev 2288
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. 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: 1316 $	8	$Revision: 2288 $
9		9
10		10
11	LOAD_FROM_FILE equ 0	11	LOAD_FROM_FILE equ 0
12	LOAD_FROM_MEM equ 1	12	LOAD_FROM_MEM equ 1
13	LOAD_INDIRECT equ 2	13	LOAD_INDIRECT equ 2
14	LOAD_SYSTEM equ 3	14	LOAD_SYSTEM equ 3
15		15
16	struc BITMAPINFOHEADER {	16	struc BITMAPINFOHEADER {
17	.biSize dd ? ; DWORD	17	.biSize dd ? ; DWORD
18	.biWidth dd ? ; LONG	18	.biWidth dd ? ; LONG
19	.biHeight dd ? ; LONG	19	.biHeight dd ? ; LONG
20	.biPlanes dw ? ; WORD	20	.biPlanes dw ? ; WORD
21	.biBitCount dw ? ; WORD	21	.biBitCount dw ? ; WORD
22	.biCompression dd ? ; DWORD	22	.biCompression dd ? ; DWORD
23	.biSizeImage dd ? ; DWORD	23	.biSizeImage dd ? ; DWORD
24	.biXPelsPerMeter dd ? ; LONG	24	.biXPelsPerMeter dd ? ; LONG
25	.biYPelsPerMeter dd ? ; LONG	25	.biYPelsPerMeter dd ? ; LONG
26	.biClrUsed dd ? ; DWORD	26	.biClrUsed dd ? ; DWORD
27	.biClrImportant dd ? ; DWORD	27	.biClrImportant dd ? ; DWORD
28	}	28	}
29		29
30	virtual at 0	30	virtual at 0
31	BI BITMAPINFOHEADER	31	BI BITMAPINFOHEADER
32	end virtual	32	end virtual
33		33
34	align 4	34	align 4
35	proc init_cursor stdcall, dst:dword, src:dword	35	proc init_cursor stdcall, dst:dword, src:dword
36	locals	36	locals
37	rBase dd ?	37	rBase dd ?
38	pQuad dd ?	38	pQuad dd ?
39	pBits dd ?	39	pBits dd ?
40	pAnd dd ?	40	pAnd dd ?
41	width dd ?	41	width dd ?
42	height dd ?	42	height dd ?
43	counter dd ?	43	counter dd ?
44	endl	44	endl
45		45
46	mov esi, [src]	46	mov esi, [src]
47	add esi,[esi+18]	47	add esi, [esi+18]
48	mov eax,esi	48	mov eax, esi
49		49
50	cmp [esi+BI.biBitCount], 24	50	cmp [esi+BI.biBitCount], 24
51	je .img_24	51	je .img_24
52	cmp [esi+BI.biBitCount], 8	52	cmp [esi+BI.biBitCount], 8
53	je .img_8	53	je .img_8
54	cmp [esi+BI.biBitCount], 4	54	cmp [esi+BI.biBitCount], 4
55	je .img_4	55	je .img_4
56		56
57	.img_2:	57	.img_2:
58	add eax, [esi]	58	add eax, [esi]
59	mov [pQuad],eax	59	mov [pQuad], eax
60	add eax,8	60	add eax, 8
61	mov [pBits],eax	61	mov [pBits], eax
62	add eax, 128	62	add eax, 128
63	mov [pAnd],eax	63	mov [pAnd], eax
64	mov eax,[esi+4]	64	mov eax, [esi+4]
65	mov [width],eax	65	mov [width], eax
66	mov ebx,[esi+8]	66	mov ebx, [esi+8]
67	shr ebx,1	67	shr ebx, 1
68	mov [height],ebx	68	mov [height], ebx
69		69
70	mov edi, [dst]	70	mov edi, [dst]
71	add edi, 32314	71	add edi, 32314
72	mov [rBase],edi	72	mov [rBase], edi
73		73
74	mov esi,[pQuad]	74	mov esi, [pQuad]
75	.l21:	75	.l21:
76	mov ebx, [pBits]	76	mov ebx, [pBits]
77	mov ebx, [ebx]	77	mov ebx, [ebx]
78	bswap ebx	78	bswap ebx
79	mov eax, [pAnd]	79	mov eax, [pAnd]
80	mov eax, [eax]	80	mov eax, [eax]
81	bswap eax	81	bswap eax
82	mov [counter], 32	82	mov [counter], 32
83	@@:	83	@@:
84	xor edx, edx	84	xor edx, edx
85	shl eax,1	85	shl eax, 1
86	setc dl	86	setc dl
87	dec edx	87	dec edx
88		88
89	xor ecx, ecx	89	xor ecx, ecx
90	shl ebx,1	90	shl ebx, 1
91	setc cl	91	setc cl
92	mov ecx, [esi+ecx*4]	92	mov ecx, [esi+ecx*4]
93	and ecx, edx	93	and ecx, edx
94	and edx, 0xFF000000	94	and edx, 0xFF000000
95	or edx, ecx	95	or edx, ecx
96	mov [edi], edx	96	mov [edi], edx
97		97
98	add edi, 4	98	add edi, 4
99	dec [counter]	99	dec [counter]
100	jnz @B	100	jnz @B
101		101
102	add [pBits], 4	102	add [pBits], 4
103	add [pAnd], 4	103	add [pAnd], 4
104	mov edi,[rBase]	104	mov edi, [rBase]
105	sub edi,128	105	sub edi, 128
106	mov [rBase],edi	106	mov [rBase], edi
107	sub [height],1	107	sub [height], 1
108	jnz .l21	108	jnz .l21
109	ret	109	ret
110		110
111	.img_4:	111	.img_4:
112	add eax, [esi]	112	add eax, [esi]
113	mov [pQuad],eax	113	mov [pQuad], eax
114	add eax,64	114	add eax, 64
115	mov [pBits],eax	115	mov [pBits], eax
116	add eax, 0x200	116	add eax, 0x200
117	mov [pAnd],eax	117	mov [pAnd], eax
118	mov eax,[esi+4]	118	mov eax, [esi+4]
119	mov [width],eax	119	mov [width], eax
120	mov ebx,[esi+8]	120	mov ebx, [esi+8]
121	shr ebx,1	121	shr ebx, 1
122	mov [height],ebx	122	mov [height], ebx
123		123
124	mov edi, [dst]	124	mov edi, [dst]
125	add edi, 32314	125	add edi, 32314
126	mov [rBase],edi	126	mov [rBase], edi
127		127
128	mov esi,[pQuad]	128	mov esi, [pQuad]
129	mov ebx, [pBits]	129	mov ebx, [pBits]
130	.l4:	130	.l4:
131	mov eax, [pAnd]	131	mov eax, [pAnd]
132	mov eax, [eax]	132	mov eax, [eax]
133	bswap eax	133	bswap eax
134	mov [counter], 16	134	mov [counter], 16
135	@@:	135	@@:
136	xor edx, edx	136	xor edx, edx
137	shl eax,1	137	shl eax, 1
138	setc dl	138	setc dl
139	dec edx	139	dec edx
140		140
141	movzx ecx, byte [ebx]	141	movzx ecx, byte [ebx]
142	and cl, 0xF0	142	and cl, 0xF0
143	shr ecx, 2	143	shr ecx, 2
144	mov ecx, [esi+ecx]	144	mov ecx, [esi+ecx]
145	and ecx, edx	145	and ecx, edx
146	and edx, 0xFF000000	146	and edx, 0xFF000000
147	or edx, ecx	147	or edx, ecx
148	mov [edi], edx	148	mov [edi], edx
149		149
150	xor edx, edx	150	xor edx, edx
151	shl eax,1	151	shl eax, 1
152	setc dl	152	setc dl
153	dec edx	153	dec edx
154		154
155	movzx ecx, byte [ebx]	155	movzx ecx, byte [ebx]
156	and cl, 0x0F	156	and cl, 0x0F
157	mov ecx, [esi+ecx*4]	157	mov ecx, [esi+ecx*4]
158	and ecx, edx	158	and ecx, edx
159	and edx, 0xFF000000	159	and edx, 0xFF000000
160	or edx, ecx	160	or edx, ecx
161	mov [edi+4], edx	161	mov [edi+4], edx
162		162
163	inc ebx	163	inc ebx
164	add edi, 8	164	add edi, 8
165	dec [counter]	165	dec [counter]
166	jnz @B	166	jnz @B
167		167
168	add [pAnd], 4	168	add [pAnd], 4
169	mov edi,[rBase]	169	mov edi, [rBase]
170	sub edi,128	170	sub edi, 128
171	mov [rBase],edi	171	mov [rBase], edi
172	sub [height],1	172	sub [height], 1
173	jnz .l4	173	jnz .l4
174	ret	174	ret
175	.img_8:	175	.img_8:
176	add eax, [esi]	176	add eax, [esi]
177	mov [pQuad],eax	177	mov [pQuad], eax
178	add eax,1024	178	add eax, 1024
179	mov [pBits],eax	179	mov [pBits], eax
180	add eax, 1024	180	add eax, 1024
181	mov [pAnd],eax	181	mov [pAnd], eax
182	mov eax,[esi+4]	182	mov eax, [esi+4]
183	mov [width],eax	183	mov [width], eax
184	mov ebx,[esi+8]	184	mov ebx, [esi+8]
185	shr ebx,1	185	shr ebx, 1
186	mov [height],ebx	186	mov [height], ebx
187		187
188	mov edi, [dst]	188	mov edi, [dst]
189	add edi, 32314	189	add edi, 32314
190	mov [rBase],edi	190	mov [rBase], edi
191		191
192	mov esi,[pQuad]	192	mov esi, [pQuad]
193	mov ebx, [pBits]	193	mov ebx, [pBits]
194	.l81:	194	.l81:
195	mov eax, [pAnd]	195	mov eax, [pAnd]
196	mov eax, [eax]	196	mov eax, [eax]
197	bswap eax	197	bswap eax
198	mov [counter], 32	198	mov [counter], 32
199	@@:	199	@@:
200	xor edx, edx	200	xor edx, edx
201	shl eax,1	201	shl eax, 1
202	setc dl	202	setc dl
203	dec edx	203	dec edx
204		204
205	movzx ecx, byte [ebx]	205	movzx ecx, byte [ebx]
206	mov ecx, [esi+ecx*4]	206	mov ecx, [esi+ecx*4]
207	and ecx, edx	207	and ecx, edx
208	and edx, 0xFF000000	208	and edx, 0xFF000000
209	or edx, ecx	209	or edx, ecx
210	mov [edi], edx	210	mov [edi], edx
211		211
212	inc ebx	212	inc ebx
213	add edi, 4	213	add edi, 4
214	dec [counter]	214	dec [counter]
215	jnz @B	215	jnz @B
216		216
217	add [pAnd], 4	217	add [pAnd], 4
218	mov edi,[rBase]	218	mov edi, [rBase]
219	sub edi,128	219	sub edi, 128
220	mov [rBase],edi	220	mov [rBase], edi
221	sub [height],1	221	sub [height], 1
222	jnz .l81	222	jnz .l81
223	ret	223	ret
224	.img_24:	224	.img_24:
225	add eax, [esi]	225	add eax, [esi]
226	mov [pQuad],eax	226	mov [pQuad], eax
227	add eax, 0xC00	227	add eax, 0xC00
228	mov [pAnd],eax	228	mov [pAnd], eax
229	mov eax,[esi+BI.biWidth]	229	mov eax, [esi+BI.biWidth]
230	mov [width],eax	230	mov [width], eax
231	mov ebx,[esi+BI.biHeight]	231	mov ebx, [esi+BI.biHeight]
232	shr ebx,1	232	shr ebx, 1
233	mov [height],ebx	233	mov [height], ebx
234		234
235	mov edi, [dst]	235	mov edi, [dst]
236	add edi, 32314	236	add edi, 32314
237	mov [rBase],edi	237	mov [rBase], edi
238		238
239	mov esi,[pAnd]	239	mov esi, [pAnd]
240	mov ebx, [pQuad]	240	mov ebx, [pQuad]
241	.row_24:	241	.row_24:
242	mov eax, [esi]	242	mov eax, [esi]
243	bswap eax	243	bswap eax
244	mov [counter], 32	244	mov [counter], 32
245	@@:	245	@@:
246	xor edx, edx	246	xor edx, edx
247	shl eax,1	247	shl eax, 1
248	setc dl	248	setc dl
249	dec edx	249	dec edx
250		250
251	mov ecx, [ebx]	251	mov ecx, [ebx]
252	and ecx, 0x00FFFFFF	252	and ecx, 0x00FFFFFF
253	and ecx, edx	253	and ecx, edx
254	and edx, 0xFF000000	254	and edx, 0xFF000000
255	or edx, ecx	255	or edx, ecx
256	mov [edi], edx	256	mov [edi], edx
257	add ebx, 3	257	add ebx, 3
258	add edi, 4	258	add edi, 4
259	dec [counter]	259	dec [counter]
260	jnz @B	260	jnz @B
261		261
262	add esi, 4	262	add esi, 4
263	mov edi,[rBase]	263	mov edi, [rBase]
264	sub edi,128	264	sub edi, 128
265	mov [rBase],edi	265	mov [rBase], edi
266	sub [height],1	266	sub [height], 1
267	jnz .row_24	267	jnz .row_24
268	ret	268	ret
269	endp	269	endp
270		270
271	align 4	271	align 4
272	proc set_cursor stdcall, hcursor:dword	272	proc set_cursor stdcall, hcursor:dword
273	mov eax, [hcursor]	273	mov eax, [hcursor]
274	cmp [eax+CURSOR.magic], 'CURS'	274	cmp [eax+CURSOR.magic], 'CURS'
275	jne .fail	275	jne .fail
276	; cmp [eax+CURSOR.size], CURSOR_SIZE	276	; cmp [eax+CURSOR.size], CURSOR_SIZE
277	; jne .fail	277	; jne .fail
278	mov ebx, [current_slot]	278	mov ebx, [current_slot]
279	xchg eax, [ebx+APPDATA.cursor]	279	xchg eax, [ebx+APPDATA.cursor]
280	ret	280	ret
281	.fail:	281	.fail:
282	mov eax, [def_cursor]	282	mov eax, [def_cursor]
283	mov ebx, [current_slot]	283	mov ebx, [current_slot]
284	xchg eax, [ebx+APPDATA.cursor]	284	xchg eax, [ebx+APPDATA.cursor]
285	ret	285	ret
286	endp	286	endp
287		287
288	; param	288	; param
289	; eax= pid	289	; eax= pid
290	; ebx= src	290	; ebx= src
291	; ecx= flags	291	; ecx= flags
292		292
293	create_cursor:	293	create_cursor:
294	.src equ esp	294	.src equ esp
295	.flags equ esp+4	295	.flags equ esp+4
296	.hcursor equ esp+8	296	.hcursor equ esp+8
297		297
298	sub esp, 4 ;space for .hcursor	298	sub esp, 4 ;space for .hcursor
299	push ecx	299	push ecx
300	push ebx	300	push ebx
301		301
302	mov ebx, eax	302	mov ebx, eax
303	mov eax, CURSOR.sizeof	303	mov eax, CURSOR.sizeof
304	call create_kernel_object	304	call create_kernel_object
305	test eax, eax	305	test eax, eax
306	jz .fail	306	jz .fail
307		307
308	mov [.hcursor],eax	308	mov [.hcursor], eax
309		309
310	xor ebx, ebx	310	xor ebx, ebx
311	mov [eax+CURSOR.magic], 'CURS'	311	mov [eax+CURSOR.magic], 'CURS'
312	mov [eax+CURSOR.destroy], destroy_cursor	312	mov [eax+CURSOR.destroy], destroy_cursor
313	mov [eax+CURSOR.hot_x], ebx	313	mov [eax+CURSOR.hot_x], ebx
314	mov [eax+CURSOR.hot_y], ebx	314	mov [eax+CURSOR.hot_y], ebx
315		315
316	stdcall kernel_alloc, 0x1000	316	stdcall kernel_alloc, 0x1000
317	test eax, eax	317	test eax, eax
318	jz .fail	318	jz .fail
319		319
320	mov edi, [.hcursor]	320	mov edi, [.hcursor]
321	mov [edi+CURSOR.base], eax	321	mov [edi+CURSOR.base], eax
322		322
323	mov esi, [.src]	323	mov esi, [.src]
324	mov ebx, [.flags]	324	mov ebx, [.flags]
325	cmp bx, LOAD_INDIRECT	325	cmp bx, LOAD_INDIRECT
326	je .indirect	326	je .indirect
327		327
328	movzx ecx, word [esi+10]	328	movzx ecx, word [esi+10]
329	movzx edx, word [esi+12]	329	movzx edx, word [esi+12]
330	mov [edi+CURSOR.hot_x], ecx	330	mov [edi+CURSOR.hot_x], ecx
331	mov [edi+CURSOR.hot_y], edx	331	mov [edi+CURSOR.hot_y], edx
332		332
333	stdcall init_cursor, eax, esi	333	stdcall init_cursor, eax, esi
334		334
335	mov eax, [.hcursor]	335	mov eax, [.hcursor]
336	lea eax, [eax+CURSOR.list_next]	336	lea eax, [eax+CURSOR.list_next]
337	lea edx, [_display.cr_list.next]	337	lea edx, [_display.cr_list.next]
338		338
339	pushfd	339	pushfd
340	cli	340	cli
341	mov ecx, [edx]	341	mov ecx, [edx]
342		342
343	mov [eax], ecx	343	mov [eax], ecx
344	mov [eax+4], edx	344	mov [eax+4], edx
345		345
346	mov [ecx+4], eax	346	mov [ecx+4], eax
347	mov [edx], eax	347	mov [edx], eax
348	popfd	348	popfd
349		349
350	mov eax, [.hcursor]	350	mov eax, [.hcursor]
351	.check_hw:	351	.check_hw:
352	cmp [_display.init_cursor], 0	352	cmp [_display.init_cursor], 0
353	je .fail	353	je .fail
354		354
355	push eax	355	push eax
356	call [_display.init_cursor]	356	call [_display.init_cursor]
357	add esp, 4	357	add esp, 4
358		358
359	mov eax, [.hcursor]	359	mov eax, [.hcursor]
360	.fail:	360	.fail:
361	add esp, 12	361	add esp, 12
362	ret	362	ret
363	.indirect:	363	.indirect:
364	shr ebx, 16	364	shr ebx, 16
365	movzx ecx, bh	365	movzx ecx, bh
366	movzx edx, bl	366	movzx edx, bl
367	mov [eax+CURSOR.hot_x], ecx	367	mov [eax+CURSOR.hot_x], ecx
368	mov [eax+CURSOR.hot_y], edx	368	mov [eax+CURSOR.hot_y], edx
369		369
370	xchg edi, eax	370	xchg edi, eax
371	mov ecx, 1024	371	mov ecx, 1024
372	cld	372	cld
373	rep movsd	373	rep movsd
374	jmp .check_hw	374	jmp .check_hw
375		375
376	align 4	376	align 4
377	proc load_cursor stdcall, src:dword, flags:dword	377	proc load_cursor stdcall, src:dword, flags:dword
378	locals	378	locals
379	handle dd ?	379	handle dd ?
380	endl	380	endl
381		381
382	xor eax, eax	382	xor eax, eax
383	cmp [create_cursor], eax	383	cmp [create_cursor], eax
384	je .fail2	384	je .fail2
385		385
386	mov [handle], eax	386	mov [handle], eax
387	cmp word [flags], LOAD_FROM_FILE	387	cmp word [flags], LOAD_FROM_FILE
388	jne @F	388	jne @F
389		389
390	stdcall load_file, [src]	390	stdcall load_file, [src]
391	test eax, eax	391	test eax, eax
392	jz .fail	392	jz .fail
393	mov [src], eax	393	mov [src], eax
394	@@:	394	@@:
395	push ebx	395	push ebx
396	push esi	396	push esi
397	push edi	397	push edi
398		398
399	mov eax, [CURRENT_TASK]	399	mov eax, [CURRENT_TASK]
400	shl eax, 5	400	shl eax, 5
401	mov eax, [CURRENT_TASK+eax+4]	401	mov eax, [CURRENT_TASK+eax+4]
402	mov ebx, [src]	402	mov ebx, [src]
403	mov ecx, [flags]	403	mov ecx, [flags]
404	call create_cursor ;eax, ebx, ecx	404	call create_cursor ;eax, ebx, ecx
405	mov [handle], eax	405	mov [handle], eax
406		406
407	cmp word [flags], LOAD_FROM_FILE	407	cmp word [flags], LOAD_FROM_FILE
408	jne .exit	408	jne .exit
409	stdcall kernel_free, [src]	409	stdcall kernel_free, [src]
410	.exit:	410	.exit:
411	pop edi	411	pop edi
412	pop esi	412	pop esi
413	pop ebx	413	pop ebx
414	.fail:	414	.fail:
415	mov eax, [handle]	415	mov eax, [handle]
416	.fail2:	416	.fail2:
417	ret	417	ret
418	endp	418	endp
419		419
420	align 4	420	align 4
421	proc delete_cursor stdcall, hcursor:dword	421	proc delete_cursor stdcall, hcursor:dword
422	locals	422	locals
423	hsrv dd ?	423	hsrv dd ?
424	io_code dd ?	424	io_code dd ?
425	input dd ?	425	input dd ?
426	inp_size dd ?	426	inp_size dd ?
427	output dd ?	427	output dd ?
428	out_size dd ?	428	out_size dd ?
429	endl	429	endl
430		430
431	mov esi, [hcursor]	431	mov esi, [hcursor]
432	cmp [esi+CURSOR.magic], 'CURS'	432	cmp [esi+CURSOR.magic], 'CURS'
433	jne .fail	433	jne .fail
434		434
435	mov ebx, [CURRENT_TASK]	435	mov ebx, [CURRENT_TASK]
436	shl ebx, 5	436	shl ebx, 5
437	mov ebx, [CURRENT_TASK+ebx+4]	437	mov ebx, [CURRENT_TASK+ebx+4]
438	cmp ebx, [esi+CURSOR.pid]	438	cmp ebx, [esi+CURSOR.pid]
439	jne .fail	439	jne .fail
440		440
441	mov ebx, [current_slot]	441	mov ebx, [current_slot]
442	cmp esi, [ebx+APPDATA.cursor]	442	cmp esi, [ebx+APPDATA.cursor]
443	jne @F	443	jne @F
444	mov eax, [def_cursor]	444	mov eax, [def_cursor]
445	mov [ebx+APPDATA.cursor], eax	445	mov [ebx+APPDATA.cursor], eax
446	@@:	446	@@:
447	mov eax, [hcursor]	447	mov eax, [hcursor]
448	call [eax+APPOBJ.destroy]	448	call [eax+APPOBJ.destroy]
449	.fail:	449	.fail:
450	ret	450	ret
451	endp	451	endp
452		452
453	; param	453	; param
454	; eax= cursor	454	; eax= cursor
455		455
456	align 4	456	align 4
457	destroy_cursor:	457	destroy_cursor:
458		458
459	push eax	459	push eax
460	stdcall kernel_free, [eax+CURSOR.base]	460	stdcall kernel_free, [eax+CURSOR.base]
461	pop eax	461	pop eax
462		462
463	call destroy_kernel_object	463	call destroy_kernel_object
464	ret	464	ret
465		465
466	align 4	466	align 4
467	select_cursor:	467	select_cursor:
468	mov eax, [esp+4]	468	mov eax, [esp+4]
469	mov [_display.cursor], eax	469	mov [_display.cursor], eax
470	ret 4	470	ret 4
471		471
472	align 4	472	align 4
473	proc restore_24 stdcall, x:dword, y:dword	473	proc restore_24 stdcall, x:dword, y:dword
474		474
475	push ebx	475	push ebx
476		476
477	mov ebx, [cur_saved_base]	477	mov ebx, [cur_saved_base]
478	mov edx, [cur.h]	478	mov edx, [cur.h]
479	test edx, edx	479	test edx, edx
480	jz .ret	480	jz .ret
481		481
482	push esi	482	push esi
483	push edi	483	push edi
484		484
485	mov esi, cur_saved_data	485	mov esi, cur_saved_data
486	mov ecx, [cur.w]	486	mov ecx, [cur.w]
487	lea ecx, [ecx+ecx*2]	487	lea ecx, [ecx+ecx*2]
488	push ecx	488	push ecx
489	@@:	489	@@:
490	mov edi, ebx	490	mov edi, ebx
491	add ebx, [BytesPerScanLine]	491	add ebx, [BytesPerScanLine]
492		492
493	mov ecx, [esp]	493	mov ecx, [esp]
494	rep movsb	494	rep movsb
495	dec edx	495	dec edx
496	jnz @B	496	jnz @B
497		497
498	pop ecx	498	pop ecx
499	pop edi	499	pop edi
500	pop esi	500	pop esi

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/cursors.inc – Rev 1316 → 2288