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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/cursors.inc @ 1316 – Rev 465 → 593