WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/video/cursors.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2971 $
 
 
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
 
           mov edi, eax
           mov ecx, 0x1000
           mov edx, PG_SW
           call @mem_alloc@8
           test eax, eax
           mov [edi+CURSOR.base], eax
           jz .fail
 
           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
           cmp [create_cursor], eax
           je .fail2
 
           mov [handle], eax
           cmp word [flags], LOAD_FROM_FILE
           jne @F
 
           stdcall load_file, [src]
           test eax, eax
           mov [src], eax
           jz .fail
@@:
           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
 
           mov ecx, [src]
           call @mem_free@4
.exit:
           pop edi
           pop esi
           pop ebx
.fail:
           mov eax, [handle]
.fail2:
           ret
endp
 
align 4
proc delete_cursor stdcall, hcursor:dword
           locals
             hsrv       dd ?
             io_code    dd ?
             input      dd ?
             inp_size   dd ?
             output     dd ?
             out_size   dd ?
           endl
 
           mov esi, [hcursor]
           cmp [esi+CURSOR.magic], 'CURS'
           jne .fail
;           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
           mov ecx, [eax+CURSOR.base]
           call @mem_free@4
           pop eax
 
           call destroy_kernel_object
           ret
 
align 4
select_cursor:
 
           ret 4
 
align 4
proc init_cursors
 
           cmp [scr_mode], 0x13
           jbe .fail
 
           test [scr_mode], 0x4000
           jz .fail
 
           mov eax, [ScreenBPP]
           mov ebx, [BytesPerScanLine]
           cmp eax, 32
           jne @F
           sub ebx, 128
           jmp .init
@@:
           cmp eax, 24
           jne .fail
           sub ebx, 96
.init:
 
        ;   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 ebx, [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
 
           mov ebx, [cur_saved_base]
           mov edx, [cur.h]
           test edx, edx
           jz  .ret
 
           mov esi, cur_saved_data
@@:
           mov edi, ebx
           add ebx, [BytesPerScanLine]
 
           mov ecx, [cur.w]
           lea ecx, [ecx+ecx*2]
           rep movsb
           dec edx
           jnz @B
.ret:
           ret
endp
 
align 4
proc restore_32 stdcall, x:dword, y:dword
 
           mov ebx, [cur_saved_base]
           mov edx, [cur.h]
           test edx, edx
           jz  .ret
 
           mov esi, cur_saved_data
@@:
           mov edi, ebx
           add ebx, [BytesPerScanLine]
 
           mov ecx, [cur.w]
           rep movsd
           dec edx
           jnz @B
.ret:
           ret
endp
 
align 4
proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword
           locals
             h      dd ?
             _dx     dd ?
             _dy     dd ?
           endl
 
           mov esi, [hcursor]
           mov ecx, [x]
           mov eax, [y]
           mov ebx, [BytesPerScanLine]
 
           xor edx, edx
           sub ecx, [esi+CURSOR.hot_x]
           lea ebx, [ecx+32-1]
           mov [x], ecx
           sets dl
           dec edx
           and ecx, edx       ;clip x to 0<=x
           mov [cur.left], ecx
           mov edi, ecx
           sub edi, [x]
           mov [_dx], edi
 
           xor edx, edx
           sub eax, [esi+CURSOR.hot_y]
           lea edi, [eax+32-1]
           mov [y], eax
           sets dl
           dec edx
           and eax, edx       ;clip y to 0<=y
           mov [cur.top], eax
           mov edx, eax
           sub edx, [y]
           mov [_dy], edx
 
           mul [BytesPerScanLine]
           lea edx, [LFB_BASE+ecx*3]
           add edx, eax
           mov [cur_saved_base],edx
 
           cmp ebx, [Screen_Max_X]
           jbe @F
           mov ebx, [Screen_Max_X]
@@:
           cmp edi, [Screen_Max_Y]
           jbe @F
           mov edi, [Screen_Max_Y]
@@:
           mov [cur.right],  ebx
           mov [cur.bottom], edi
 
           sub ebx, [x]
           sub edi, [y]
           inc ebx
           inc edi
 
           mov [cur.w], ebx
           mov [cur.h], edi
           mov [h], edi
 
           mov eax, edi
           mov edi, cur_saved_data
@@:
           mov esi, edx
           add edx, [BytesPerScanLine]
           mov ecx, [cur.w]
           lea ecx, [ecx+ecx*2]
           rep movsb
           dec eax
           jnz @B
 
;draw cursor
           mov ebx, [cur_saved_base]
           mov eax, [_dy]
           shl eax, 5
           add eax, [_dx]
 
           mov esi, [hcursor]
           mov esi, [esi+CURSOR.base]
           lea edx, [esi+eax*4]
.row:
           mov ecx, [cur.w]
           mov esi, edx
           mov edi, ebx
           add edx, 32*4
           add ebx, [BytesPerScanLine]
.pix:
           lodsd
           test eax, 0xFF000000
           jz @F
 
           mov [edi], ax
           shr eax, 16
           mov [edi+2], al
@@:
           add edi, 3
           dec ecx
           jnz .pix
 
           dec [h]
           jnz .row
           ret
endp
 
 
align 4
proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword
           locals
             h      dd ?
             _dx     dd ?
             _dy     dd ?
           endl
 
           mov esi, [hcursor]
           mov ecx, [x]
           mov eax, [y]
 
           xor edx, edx
           sub ecx, [esi+CURSOR.hot_x]
           lea ebx, [ecx+32-1]
           mov [x], ecx
           sets dl
           dec edx
           and ecx, edx       ;clip x to 0<=x
           mov [cur.left], ecx
           mov edi, ecx
           sub edi, [x]
           mov [_dx], edi
 
           xor edx, edx
           sub eax, [esi+CURSOR.hot_y]
           lea edi, [eax+32-1]
           mov [y], eax
           sets dl
           dec edx
           and eax, edx       ;clip y to 0<=y
           mov [cur.top], eax
           mov edx, eax
           sub edx, [y]
           mov [_dy], edx
 
           mul [BytesPerScanLine]
           lea edx, [LFB_BASE+eax+ecx*4]
           mov [cur_saved_base],edx
 
           cmp ebx, [Screen_Max_X]
           jbe @F
           mov ebx, [Screen_Max_X]
@@:
           cmp edi, [Screen_Max_Y]
           jbe @F
           mov edi, [Screen_Max_Y]
@@:
           mov [cur.right],  ebx
           mov [cur.bottom], edi
 
           sub ebx, [x]
           sub edi, [y]
           inc ebx
           inc edi
 
           mov [cur.w], ebx
           mov [cur.h], edi
           mov [h], edi
 
           mov eax, edi
           mov edi, cur_saved_data
@@:
           mov esi, edx
           add edx, [BytesPerScanLine]
           mov ecx, [cur.w]
           rep movsd
           dec eax
           jnz @B
 
;draw cursor
           mov ebx, [cur_saved_base]
           mov eax, [_dy]
           shl eax, 5
           add eax, [_dx]
 
           mov esi, [hcursor]
           mov esi, [esi+CURSOR.base]
           lea edx, [esi+eax*4]
.row:
           mov ecx, [cur.w]
           mov esi, edx
           mov edi, ebx
           add edx, 32*4
           add ebx, [BytesPerScanLine]
.pix:
           lodsd
           test eax, 0xFF000000
           jz @F
           mov [edi], eax
@@:
           add edi, 4
           dec ecx
           jnz .pix
 
           dec [h]
           jnz .row
           ret
endp
 
 
align 4
def_arrow:
  file 'arrow.cur'
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/video/cursors.inc – Rev 996 → 2971