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


$Revision: 465 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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 vesa_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
 
vesa_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_SIZE
           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 vesa_init_cursor, eax, esi
           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
           add esp, 12
           ret
 
align 4
proc load_cursor stdcall, src:dword, flags:dword
           locals
             handle  dd ?
           endl
 
           xor eax, eax
           mov [handle], eax
           cmp word [flags], LOAD_FROM_FILE
           jne @F
 
           stdcall load_file, [src]
           test eax, eax
           jz .exit
           mov [src], eax
@@:
           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
.fail:
           cmp word [flags], LOAD_FROM_FILE
           jne .exit
           stdcall kernel_free, [src]
.exit:
           mov eax, [handle]
           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
;           cmp [esi+CURSOR.size], CURSOR_SIZE
;           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
proc init_cursors
           cmp [SCR_MODE],word 0x13
           jbe .fail
 
           movzx eax, byte [ScreenBPP]
           mov ebx, [BytesPerScanLine]
           cmp eax, 32
           jne @F
           sub ebx, 128
           jmp .init
@@:
           cmp eax, 24
           jne .fail
           sub ebx, 96
.init:
           mov [cur_def_interl], ebx
 
           stdcall load_driver, szHwMouse
           mov [hw_cursor], eax
           test eax, eax
           jz .sw_mouse
 
           stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
           mov [def_cursor], eax
           ret
.sw_mouse:
           mov [create_cursor], vesa_cursor
 
           stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
           mov [def_cursor], eax
 
           mov ecx, [ScreenWidth]
           mov edx, [ScreenHeight]
           inc ecx
           inc edx
           mov [scr_width], ecx
           mov [scr_height], edx
 
           movzx ebx, byte [ScreenBPP]
           cmp ebx, 32
           jne @F
 
           mov dword [set_hw_cursor], cursor_32
           mov dword [hw_restore], restore_32
           ret
@@:
           mov dword [set_hw_cursor], cursor_24
           mov dword [hw_restore], restore_24
           ret
.fail:
           xor eax, eax
           mov dword [set_hw_cursor], eax
           mov dword [hw_restore], eax
           ret
endp
 
align 4
proc restore_24 stdcall, x:dword, y:dword
           locals
             w  dd ?
           endl
 
           mov edi, [cur_saved_base]
           mov edx, [cur_saved_h]
           mov ebx, [cur_saved_interl]
 
           mov esi, cur_saved_data
@@:
           mov ecx, [cur_saved_w]
           lea ecx, [ecx+ecx*2]
           rep movsb
           add edi, ebx
           dec edx
           jnz @B
           ret
endp
 
align 4
proc restore_32 stdcall, x:dword, y:dword
           locals
             w  dd ?
           endl
 
           mov edi, [cur_saved_base]
           mov edx, [cur_saved_h]
           mov ebx, [cur_saved_interl]
 
           mov esi, cur_saved_data
@@:
           mov ecx, [cur_saved_w]
           rep movsd
           add edi, ebx
           dec edx
           jnz @B
           ret
endp
 
align 4
proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword
           locals
             w      dd ?
             h      dd ?
             st     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]
           mov [x], ecx
           sets dl
           dec edx
           and ecx, edx       ;clip x to 0<=x
           mov edi, ecx
           sub edi, [x]
           mov [_dx], edi
 
           xor edx, edx
           sub eax, [esi+CURSOR.hot_y]
           mov [y], eax
           sets dl
           dec edx
           and eax, edx       ;clip y to 0<=y
           mov edi, eax
           sub edi, [y]
           mov [_dy], edi
 
           mul ebx
           lea esi, [ecx+ecx*2]
           add esi, [LFBAddress]
           add esi, eax
           mov [cur_saved_base],esi
 
           mov edi, [scr_width]
           mov edx, [scr_height]
           mov eax, 32
 
           sub edi, ecx
           cmp edi, eax
           jng @F
           mov edi, eax
@@:
           sub edi, [_dx]
 
           sub edx, [y]
           cmp edx, eax
           jng @F
           mov edx, eax
@@:
           sub edx, [_dy]
 
           mov [w], edi
           mov [h], edx
           mov [cur_saved_w], edi
           mov [cur_saved_h], edx
 
           sub eax, edi
           shl eax, 2       ;lea eax, [eax+eax*2]
           lea edi, [edi+edi*2]
           sub ebx, edi
           mov [cur_saved_interl], ebx
 
           mov edi, cur_saved_data
@@:
           mov ecx, [w]
           lea ecx, [ecx+ecx*2]
           rep movsb
           add esi, ebx
           dec edx
           jnz @B
 
;draw cursor
           mov edx, eax
           mov edi, [cur_saved_base]
           mov eax, [_dy]
           shl eax, 5
           add eax, [_dx]
           shl eax, 2
 
           mov esi, [hcursor]
           mov esi, [esi+CURSOR.base]
           add esi, eax
.row:
           mov ecx, [w]
.pix:
           lodsd
           test eax, 0xFF000000
           jz @F
 
           mov word [edi], ax
           shr eax, 16
           mov [edi+2],al
@@:
           add edi, 3
           dec ecx
           jnz .pix
 
           add esi, edx
           add edi, ebx
           dec [h]
           jnz .row
           ret
endp
 
align 4
proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword
           locals
             w      dd ?
             h      dd ?
             st     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]
           mov [x], ecx
           sets dl
           dec edx
           and ecx, edx       ;clip x to 0<=x
           mov edi, ecx
           sub edi, [x]
           mov [_dx], edi
 
           xor edx, edx
           sub eax, [esi+CURSOR.hot_y]
           mov [y], eax
           sets dl
           dec edx
           and eax, edx       ;clip y to 0<=y
           mov edi, eax
           sub edi, [y]
           mov [_dy], edi
 
           mul ebx
           lea esi, [eax+ecx*4]
           add esi, [LFBAddress]
           mov [cur_saved_base],esi
 
           mov edi, [scr_width]
           mov edx, [scr_height]
           mov eax, 32
 
           sub edi, ecx
           cmp edi, eax
           jng @F
           mov edi, eax
@@:
           sub edi, [_dx]
 
           sub edx, [y]
           cmp edx, eax
           jng @F
           mov edx, eax
@@:
           sub edx, [_dy]
 
           mov [w], edi
           mov [h], edx
           mov [cur_saved_w], edi
           mov [cur_saved_h], edx
 
           sub eax, edi
           shl eax, 2
           shl edi, 2
           sub ebx, edi
           mov [cur_saved_interl], ebx
 
           mov edi, cur_saved_data
@@:
           mov ecx, [w]
           rep movsd
           add esi, ebx
           dec edx
           jnz @B
 
;draw cursor
           mov edx, eax
           mov edi, [cur_saved_base]
           mov eax, [_dy]
           shl eax, 5
           add eax, [_dx]
           shl eax, 2
 
           mov esi, [hcursor]
           mov esi, [esi+CURSOR.base]
           add esi, eax
.row:
           mov ecx, [w]
.pix:
           lodsd
           test eax, 0xFF000000
           jz @F
           mov [edi], eax
@@:
           add edi, 4
           dec ecx
           jnz .pix
           add esi, edx
           add edi, ebx
           dec [h]
           jnz .row
           ret
endp
 
align 4
def_arrow:
  file 'arrow.cur'
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/cursors.inc – Rev 425 → 465