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: 673 $
 
 
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 .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]
           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
select_cursor:
 
           ret 4
 
align 4
proc init_cursors
 
           cmp [SCR_MODE],word 0x13
           jbe .fail
 
           test word [SCR_MODE], 0x4000
           jz .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 [select_hw_cursor], select_cursor
           mov dword [set_hw_cursor], cursor_32
           mov dword [hw_restore], restore_32
           ret
@@:
           mov dword [select_hw_cursor], select_cursor
           mov dword [set_hw_cursor], cursor_24
           mov dword [hw_restore], restore_24
           ret
.fail:
           xor eax, eax
           mov dword [select_hw_cursor], 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]
           test edx, edx
           jz  .ret
 
           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:
           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]
           test edx, edx
           jz  .ret
 
           mov esi, cur_saved_data
@@:
           mov ecx, [cur_saved_w]
           rep movsd
           add edi, ebx
           dec edx
           jnz @B
.ret:
           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 662	Rev 673
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. 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: 662 $	8	$Revision: 673 $
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 vesa_init_cursor stdcall, dst:dword, src:dword	35	proc vesa_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	vesa_cursor:	293	vesa_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_SIZE	303	mov eax, CURSOR_SIZE
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 vesa_init_cursor, eax, esi	333	stdcall vesa_init_cursor, eax, esi
334	mov eax, [.hcursor]	334	mov eax, [.hcursor]
335	.fail:	335	.fail:
336	add esp, 12	336	add esp, 12
337	ret	337	ret
338	.indirect:	338	.indirect:
339	shr ebx, 16	339	shr ebx, 16
340	movzx ecx, bh	340	movzx ecx, bh
341	movzx edx, bl	341	movzx edx, bl
342	mov [eax+CURSOR.hot_x], ecx	342	mov [eax+CURSOR.hot_x], ecx
343	mov [eax+CURSOR.hot_y], edx	343	mov [eax+CURSOR.hot_y], edx
344		344
345	xchg edi, eax	345	xchg edi, eax
346	mov ecx, 1024	346	mov ecx, 1024
347	cld	347	cld
348	rep movsd	348	rep movsd
349	add esp, 12	349	add esp, 12
350	ret	350	ret
351		351
352	align 4	352	align 4
353	proc load_cursor stdcall, src:dword, flags:dword	353	proc load_cursor stdcall, src:dword, flags:dword
354	locals	354	locals
355	handle dd ?	355	handle dd ?
356	endl	356	endl
357		357
358	xor eax, eax	358	xor eax, eax
359	mov [handle], eax	359	mov [handle], eax
360	cmp word [flags], LOAD_FROM_FILE	360	cmp word [flags], LOAD_FROM_FILE
361	jne @F	361	jne @F
362		362
363	stdcall load_file, [src]	363	stdcall load_file, [src]
364	test eax, eax	364	test eax, eax
365	jz .fail	365	jz .fail
366	mov [src], eax	366	mov [src], eax
367	@@:	367	@@:
368	push ebx	368	push ebx
369	push esi	369	push esi
370	push edi	370	push edi
371		371
372	mov eax, [CURRENT_TASK]	372	mov eax, [CURRENT_TASK]
373	shl eax, 5	373	shl eax, 5
374	mov eax, [CURRENT_TASK+eax+4]	374	mov eax, [CURRENT_TASK+eax+4]
375	mov ebx, [src]	375	mov ebx, [src]
376	mov ecx, [flags]	376	mov ecx, [flags]
377	call [create_cursor] ;eax, ebx, ecx	377	call [create_cursor] ;eax, ebx, ecx
378	mov [handle], eax	378	mov [handle], eax
379		379
380	cmp word [flags], LOAD_FROM_FILE	380	cmp word [flags], LOAD_FROM_FILE
381	jne .exit	381	jne .exit
382	stdcall kernel_free, [src]	382	stdcall kernel_free, [src]
383	.exit:	383	.exit:
384	pop edi	384	pop edi
385	pop esi	385	pop esi
386	pop ebx	386	pop ebx
387	.fail:	387	.fail:
388	mov eax, [handle]	388	mov eax, [handle]
389	ret	389	ret
390	endp	390	endp
391		391
392	align 4	392	align 4
393	proc delete_cursor stdcall, hcursor:dword	393	proc delete_cursor stdcall, hcursor:dword
394	locals	394	locals
395	hsrv dd ?	395	hsrv dd ?
396	io_code dd ?	396	io_code dd ?
397	input dd ?	397	input dd ?
398	inp_size dd ?	398	inp_size dd ?
399	output dd ?	399	output dd ?
400	out_size dd ?	400	out_size dd ?
401	endl	401	endl
402		402
403	mov esi, [hcursor]	403	mov esi, [hcursor]
404	cmp [esi+CURSOR.magic], 'CURS'	404	cmp [esi+CURSOR.magic], 'CURS'
405	jne .fail	405	jne .fail
406	; cmp [esi+CURSOR.size], CURSOR_SIZE	406	; cmp [esi+CURSOR.size], CURSOR_SIZE
407	; jne .fail	407	; jne .fail
408		408
409	mov ebx, [CURRENT_TASK]	409	mov ebx, [CURRENT_TASK]
410	shl ebx, 5	410	shl ebx, 5
411	mov ebx, [CURRENT_TASK+ebx+4]	411	mov ebx, [CURRENT_TASK+ebx+4]
412	cmp ebx, [esi+CURSOR.pid]	412	cmp ebx, [esi+CURSOR.pid]
413	jne .fail	413	jne .fail
414		414
415	mov ebx, [current_slot]	415	mov ebx, [current_slot]
416	cmp esi, [ebx+APPDATA.cursor]	416	cmp esi, [ebx+APPDATA.cursor]
417	jne @F	417	jne @F
418	mov eax, [def_cursor]	418	mov eax, [def_cursor]
419	mov [ebx+APPDATA.cursor], eax	419	mov [ebx+APPDATA.cursor], eax
420	@@:	420	@@:
421	mov eax, [hcursor]	421	mov eax, [hcursor]
422	call [eax+APPOBJ.destroy]	422	call [eax+APPOBJ.destroy]
423	.fail:	423	.fail:
424	ret	424	ret
425	endp	425	endp
426		426
427	; param	427	; param
428	; eax= cursor	428	; eax= cursor
429		429
430	align 4	430	align 4
431	destroy_cursor:	431	destroy_cursor:
432		432
433	push eax	433	push eax
434	stdcall kernel_free, [eax+CURSOR.base]	434	stdcall kernel_free, [eax+CURSOR.base]
435	pop eax	435	pop eax
436		436
437	call destroy_kernel_object	437	call destroy_kernel_object
438	ret	438	ret
439		439
440	align 4	440	align 4
441	select_cursor:	441	select_cursor:
442		442
443	ret 4	443	ret 4
444		444
445	align 4	445	align 4
446	proc init_cursors	446	proc init_cursors
-		447
447	cmp [SCR_MODE],word 0x13	448	cmp [SCR_MODE],word 0x13
448	jbe .fail	449	jbe .fail
-		450
-		451	test word [SCR_MODE], 0x4000
-		452	jz .fail
449		453
450	movzx eax, byte [ScreenBPP]	454	movzx eax, byte [ScreenBPP]
451	mov ebx, [BytesPerScanLine]	455	mov ebx, [BytesPerScanLine]
452	cmp eax, 32	456	cmp eax, 32
453	jne @F	457	jne @F
454	sub ebx, 128	458	sub ebx, 128
455	jmp .init	459	jmp .init
456	@@:	460	@@:
457	cmp eax, 24	461	cmp eax, 24
458	jne .fail	462	jne .fail
459	sub ebx, 96	463	sub ebx, 96
460	.init:	464	.init:
461	mov [cur_def_interl], ebx	465	mov [cur_def_interl], ebx
462		466
463	stdcall load_driver, szHwMouse	467	stdcall load_driver, szHwMouse
464	mov [hw_cursor], eax	468	mov [hw_cursor], eax
465	test eax, eax	469	test eax, eax
466	jz .sw_mouse	470	jz .sw_mouse
467		471
468	stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM	472	stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
469	mov [def_cursor], eax	473	mov [def_cursor], eax
470	ret	474	ret
471	.sw_mouse:	475	.sw_mouse:
472	mov [create_cursor], vesa_cursor	476	mov [create_cursor], vesa_cursor
473		477
474	stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM	478	stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
475	mov [def_cursor], eax	479	mov [def_cursor], eax
476		480
477	mov ecx, [ScreenWidth]	481	mov ecx, [ScreenWidth]
478	mov edx, [ScreenHeight]	482	mov edx, [ScreenHeight]
479	inc ecx	483	inc ecx
480	inc edx	484	inc edx
481	mov [scr_width], ecx	485	mov [scr_width], ecx
482	mov [scr_height], edx	486	mov [scr_height], edx
483		487
484	movzx ebx, byte [ScreenBPP]	488	movzx ebx, byte [ScreenBPP]
485	cmp ebx, 32	489	cmp ebx, 32
486	jne @F	490	jne @F
487		491
488		492
489	mov dword [select_hw_cursor], select_cursor	493	mov dword [select_hw_cursor], select_cursor
490	mov dword [set_hw_cursor], cursor_32	494	mov dword [set_hw_cursor], cursor_32
491	mov dword [hw_restore], restore_32	495	mov dword [hw_restore], restore_32
492	ret	496	ret
493	@@:	497	@@:
494	mov dword [select_hw_cursor], select_cursor	498	mov dword [select_hw_cursor], select_cursor
495	mov dword [set_hw_cursor], cursor_24	499	mov dword [set_hw_cursor], cursor_24
496	mov dword [hw_restore], restore_24	500	mov dword [hw_restore], restore_24

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/cursors.inc – Rev 662 → 673