WebSVN – Kolibri OS – Diff – /kernel/trunk/gui/button.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6044 $
 
button.MAX_BUTTONS = 4095
 
struct  SYS_BUTTON
        pslot           dw ?
        id_lo           dw ?
        left            dw ?
        width           dw ?
        top             dw ?
        height          dw ?
        id_hi           dw ?
                        dw ?
ends
 
;---------------------------------------------------------------
syscall_button: ;////////////// system function 8 //////////////
;---------------------------------------------------------------
;? Define/undefine GUI button object
;---------------------------------------------------------------
;; Define button:
;> ebx = pack[16(x), 16(width)]
;> ecx = pack[16(y), 16(height)]
;> edx = pack[8(flags), 24(button identifier)]
;>       flags bits:
;>          7 (31) = 0
;>          6 (30) = don't draw button
;>          5 (29) = don't draw button frame when pressed
;> esi = button color
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
;; Undefine button:
;> edx = pack[8(flags), 24(button identifier)]
;>       flags bits:
;>          7 (31) = 1
;---------------------------------------------------------------
        ; do we actually need to undefine the button?
        test    edx, 0x80000000
        jnz     .remove_button
 
        ; do we have free button slots available?
        mov     edi, [BTN_ADDR]
        mov     eax, [edi]
        cmp     eax, button.MAX_BUTTONS
        jge     .exit
 
        ; does it have positive size? (otherwise it doesn't have sense)
        or      bx, bx
        jle     .exit
        or      cx, cx
        jle     .exit
 
        ; make coordinates clientbox-relative
        push    eax
        mov     eax, [current_slot]
        rol     ebx, 16
        add     bx, word[eax + APPDATA.wnd_clientbox.left]
        rol     ebx, 16
        rol     ecx, 16
        add     cx, word[eax + APPDATA.wnd_clientbox.top]
        rol     ecx, 16
        pop     eax
 
        ; basic checks passed, define the button
        inc     eax
        mov     [edi], ax
        shl     eax, 4
        add     edi, eax
; NOTE: this code doesn't rely on SYS_BUTTON struct,
; please revise it, if you change something.
        mov     ax, [CURRENT_TASK]
        stosw
        mov     ax, dx
        stosw               ; button id number: bits 0-15
        mov     eax, ebx
        rol     eax, 16
        stosd               ; x start | x size
        mov     eax, ecx
        rol     eax, 16
        stosd               ; y start | y size
        mov     eax, edx
        shr     eax, 16
        stosw               ; button id number: bits 16-31
 
        ; do we also need to draw the button?
        test    edx, 0x40000000
        jnz     .exit
 
        and     esi, 0xFFFFFF
        xor     edi, edi
        push    ebx ecx esi
        dec     cx
        dec     cx
        cmp     [buttontype], 1
        jnz     .draw
        cmp     cx, 65
        jnc     .draw
 
        ; calculate gradient data
        mov     eax, esi
        shl     eax, 8
        mov     edx, 3
.calculate:
        rol     eax, 8
        shl     al, 1
        jnc     @f
        neg     al
        jnz     @f
        mov     al, 64
@@:
        cmp     al, 65
        jc      @f
        mov     al, 64
@@:
        div     cl
        shl     ax, 8
        dec     edx
        jnz     .calculate
        mov     dl, cl
        dec     edx
        shr     edx, 1
        shr     eax, 8
        mov     edi, eax
        mul     edx
        add     esi, eax
 
.draw:  ; calculate window-relative coordinates
        movzx   ebp, cx
        dec     ebp
        shr     ebx, 16
        shr     ecx, 16
        mov     eax, [TASK_BASE]
        add     ebx, [eax - twdw + WDATA.box.left]
        add     ecx, [eax - twdw + WDATA.box.top]
        mov     eax, ebx
        inc     eax
        mov     edx, ebx
        add     dx, [esp+8]
        dec     edx
        mov     ebx, ecx
        mov     ecx, esi
        shr     ecx, 1
        and     cx, 7F7Fh
        push    esi
        mov     esi, edi
        xor     edi, edi
        call    hline   ; top border
        inc     ebx
        or      ecx, 808080h
        call    hline   ; top light line
        pop     ecx
        inc     ebx
.next_line:
        call    hline   ; button body
        inc     ebx
        sub     ecx, esi
        dec     ebp
        jnz     .next_line
        shr     ecx, 2
        and     cx, 3F3Fh
        mov     ebp, ecx
        shl     ecx, 1
        add     ecx, ebp
        call    hline   ; bottom dark line
        inc     ebx
        sub     ecx, ebp
        call    hline   ; bottom border
        pop     ecx
        shr     ecx, 1
        inc     edx
        push    edx
        mov     edx, ebx
        sub     bx, [esp+4]
        dec     edx
        inc     ebx
        cmp     [buttontype], 0
        jnz     @f
        dec     edx
        or      ecx, 808080h
        call    vline   ; left light line
        inc     edx
@@:
        and     ecx, 7F7F7Fh
        dec     eax
        call    vline   ; left border
        pop     eax
        call    vline   ; right border
        cmp     [buttontype], 0
        jnz     @f
        mov     ebp, ecx
        shr     ecx, 1
        and     cx, 7F7Fh
        add     ecx, ebp
        dec     eax
        inc     ebx
        call    vline   ; right dark line
@@:
        pop     ecx ebx
.exit:
        ret
 
; FIXME: mutex needed
.remove_button:
        and     edx, 0x00ffffff
        mov     edi, [BTN_ADDR]
        mov     ebx, [edi]
        inc     ebx
        imul    esi, ebx, sizeof.SYS_BUTTON
        add     esi, edi
        xor     ecx, ecx
        add     ecx, -sizeof.SYS_BUTTON
        add     esi, sizeof.SYS_BUTTON
 
.next_button:
        dec     ebx
        jz      .exit
 
        add     ecx, sizeof.SYS_BUTTON
        add     esi, -sizeof.SYS_BUTTON
 
        ; does it belong to our process?
        mov     ax, [CURRENT_TASK]
        cmp     ax, [esi + SYS_BUTTON.pslot]
        jne     .next_button
 
        ; does the identifier match?
        mov     eax, dword[esi + SYS_BUTTON.id_hi - 2]
        mov     ax, [esi + SYS_BUTTON.id_lo]
        and     eax, 0x00ffffff
        cmp     edx, eax
        jne     .next_button
 
        ; okay, undefine it
        push    ebx
        mov     ebx, esi
        lea     eax, [esi + sizeof.SYS_BUTTON]
        call    memmove
        dec     dword[edi]
        add     ecx, -sizeof.SYS_BUTTON
        pop     ebx
        jmp     .next_button
 
;---------------------------------------------------------------
sys_button_activate_handler:
sys_button_deactivate_handler:
;---------------------------------------------------------------
;> eax = pack[8(process slot), 24(button id)]
;> ebx = pack[16(button x coord), 16(button y coord)]
;> cl = mouse button mask this system button was pressed with
;---------------------------------------------------------------
; find system button by specified process slot, id and coordinates
        push    ecx edx esi edi
        mov     edx, eax
        shr     edx, 24
        and     eax, 0x0ffffff
        mov     edi, [BTN_ADDR]
        mov     ecx, [edi]
        imul    esi, ecx, sizeof.SYS_BUTTON
        add     esi, edi
        inc     ecx
        add     esi, sizeof.SYS_BUTTON
.next_button:
        dec     ecx
        jz      .popexit
        add     esi, -sizeof.SYS_BUTTON
 
        ; does it belong to our process?
        cmp     dx, [esi + SYS_BUTTON.pslot]
        jne     .next_button
 
        ; does id match?
        mov     edi, dword[esi + SYS_BUTTON.id_hi - 2]
        mov     di, [esi + SYS_BUTTON.id_lo]
        and     edi, 0x0ffffff
        cmp     eax, edi
        jne     .next_button
 
        ; does coordinates match?
        mov     edi, dword[esi + SYS_BUTTON.left - 2]
        mov     di, [esi + SYS_BUTTON.top]
        cmp     ebx, edi
        jne     .next_button
 
        mov     eax, esi
        pop     edi esi edx ecx
        mov     ebx, dword[eax + SYS_BUTTON.id_hi - 2]
 
        ; display button border on press?
        bt      ebx, 29
        jc      .exit
 
        ; invert system button border
        pushad
        mov     esi, eax
        mov     edi, ebx
        movzx   ecx, [esi + SYS_BUTTON.pslot]
        shl     ecx, 5
        add     ecx, window_data
        mov     eax, dword[esi + SYS_BUTTON.left]
        mov     ebx, dword[esi + SYS_BUTTON.top]
        add     eax, [ecx + WDATA.box.left]
        add     ebx, [ecx + WDATA.box.top]
        mov     ecx, eax
        mov     edx, ebx
        bt      edi, 30
        jc      @f
        inc     ax
        inc     bx
        dec     cx
        dec     dx
@@:
        rol     eax, 16
        rol     ebx, 16
        add     ax, cx
        add     bx, dx
 
 
        mov     esi, 1000000h
        call    draw_rectangle.forced
        popad
.exit:
        ret
.popexit:
        pop     edi esi edx ecx
        ret
 
;---------------------------------------------------------------
sys_button_perform_handler:
;---------------------------------------------------------------
;> eax = pack[8(process slot), 24(button id)]
;> ebx = pack[16(button x coord), 16(button y coord)]
;> cl = mouse button mask this system button was pressed with
;---------------------------------------------------------------
        shl     eax, 8
        mov     al, cl
        movzx   ebx, byte[BTN_COUNT]
        mov     [BTN_BUFF + ebx * 4], eax
        inc     bl
        mov     [BTN_COUNT], bl
        ret

Rev 6035	Rev 6044
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	4	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8		8
9	$Revision: 6035 $	9	$Revision: 6044 $
10		10
11	button.MAX_BUTTONS = 4095	11	button.MAX_BUTTONS = 4095
12		12
13	struct SYS_BUTTON	13	struct SYS_BUTTON
14	pslot dw ?	14	pslot dw ?
15	id_lo dw ?	15	id_lo dw ?
16	left dw ?	16	left dw ?
17	width dw ?	17	width dw ?
18	top dw ?	18	top dw ?
19	height dw ?	19	height dw ?
20	id_hi dw ?	20	id_hi dw ?
21	dw ?	21	dw ?
22	ends	22	ends
23		23
24	;---------------------------------------------------------------	24	;---------------------------------------------------------------
25	syscall_button: ;////////////// system function 8 //////////////	25	syscall_button: ;////////////// system function 8 //////////////
26	;---------------------------------------------------------------	26	;---------------------------------------------------------------
27	;? Define/undefine GUI button object	27	;? Define/undefine GUI button object
28	;---------------------------------------------------------------	28	;---------------------------------------------------------------
29	;; Define button:	29	;; Define button:
30	;> ebx = pack[16(x), 16(width)]	30	;> ebx = pack[16(x), 16(width)]
31	;> ecx = pack[16(y), 16(height)]	31	;> ecx = pack[16(y), 16(height)]
32	;> edx = pack[8(flags), 24(button identifier)]	32	;> edx = pack[8(flags), 24(button identifier)]
33	;> flags bits:	33	;> flags bits:
34	;> 7 (31) = 0	34	;> 7 (31) = 0
35	;> 6 (30) = don't draw button	35	;> 6 (30) = don't draw button
36	;> 5 (29) = don't draw button frame when pressed	36	;> 5 (29) = don't draw button frame when pressed
37	;> esi = button color	37	;> esi = button color
38	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	38	; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
39	;; Undefine button:	39	;; Undefine button:
40	;> edx = pack[8(flags), 24(button identifier)]	40	;> edx = pack[8(flags), 24(button identifier)]
41	;> flags bits:	41	;> flags bits:
42	;> 7 (31) = 1	42	;> 7 (31) = 1
43	;---------------------------------------------------------------	43	;---------------------------------------------------------------
44	; do we actually need to undefine the button?	44	; do we actually need to undefine the button?
45	test edx, 0x80000000	45	test edx, 0x80000000
46	jnz .remove_button	46	jnz .remove_button
47		47
48	; do we have free button slots available?	48	; do we have free button slots available?
49	mov edi, [BTN_ADDR]	49	mov edi, [BTN_ADDR]
50	mov eax, [edi]	50	mov eax, [edi]
51	cmp eax, button.MAX_BUTTONS	51	cmp eax, button.MAX_BUTTONS
52	jge .exit	52	jge .exit
53		53
54	; does it have positive size? (otherwise it doesn't have sense)	54	; does it have positive size? (otherwise it doesn't have sense)
55	or bx, bx	55	or bx, bx
56	jle .exit	56	jle .exit
57	or cx, cx	57	or cx, cx
58	jle .exit	58	jle .exit
59		59
60	; make coordinates clientbox-relative	60	; make coordinates clientbox-relative
61	push eax	61	push eax
62	mov eax, [current_slot]	62	mov eax, [current_slot]
63	rol ebx, 16	63	rol ebx, 16
64	add bx, word[eax + APPDATA.wnd_clientbox.left]	64	add bx, word[eax + APPDATA.wnd_clientbox.left]
65	rol ebx, 16	65	rol ebx, 16
66	rol ecx, 16	66	rol ecx, 16
67	add cx, word[eax + APPDATA.wnd_clientbox.top]	67	add cx, word[eax + APPDATA.wnd_clientbox.top]
68	rol ecx, 16	68	rol ecx, 16
69	pop eax	69	pop eax
70		70
71	; basic checks passed, define the button	71	; basic checks passed, define the button
72	inc eax	72	inc eax
73	mov [edi], ax	73	mov [edi], ax
74	shl eax, 4	74	shl eax, 4
75	add edi, eax	75	add edi, eax
76	; NOTE: this code doesn't rely on SYS_BUTTON struct,	76	; NOTE: this code doesn't rely on SYS_BUTTON struct,
77	; please revise it, if you change something.	77	; please revise it, if you change something.
78	mov ax, [CURRENT_TASK]	78	mov ax, [CURRENT_TASK]
79	stosw	79	stosw
80	mov ax, dx	80	mov ax, dx
81	stosw ; button id number: bits 0-15	81	stosw ; button id number: bits 0-15
82	mov eax, ebx	82	mov eax, ebx
83	rol eax, 16	83	rol eax, 16
84	stosd ; x start \| x size	84	stosd ; x start \| x size
85	mov eax, ecx	85	mov eax, ecx
86	rol eax, 16	86	rol eax, 16
87	stosd ; y start \| y size	87	stosd ; y start \| y size
88	mov eax, edx	88	mov eax, edx
89	shr eax, 16	89	shr eax, 16
90	stosw ; button id number: bits 16-31	90	stosw ; button id number: bits 16-31
91		91
92	; do we also need to draw the button?	92	; do we also need to draw the button?
93	test edx, 0x40000000	93	test edx, 0x40000000
94	jnz .exit	94	jnz .exit
95		95
96	and esi, 0xFFFFFF	96	and esi, 0xFFFFFF
97	xor edi, edi	97	xor edi, edi
98	push ebx ecx esi	98	push ebx ecx esi
99	dec cx	99	dec cx
100	dec cx	100	dec cx
101	cmp [buttontype], 1	101	cmp [buttontype], 1
102	jnz .draw	102	jnz .draw
103	cmp cx, 65	103	cmp cx, 65
104	jnc .draw	104	jnc .draw
105		105
106	; calculate gradient data	106	; calculate gradient data
107	mov eax, esi	107	mov eax, esi
108	shl eax, 8	108	shl eax, 8
109	mov edx, 3	109	mov edx, 3
110	.calculate:	110	.calculate:
111	rol eax, 8	111	rol eax, 8
112	shl al, 1	112	shl al, 1
113	jnc @f	113	jnc @f
114	neg al	114	neg al
115	jnz @f	115	jnz @f
116	mov al, 64	116	mov al, 64
117	@@:	117	@@:
118	cmp al, 65	118	cmp al, 65
119	jc @f	119	jc @f
120	mov al, 64	120	mov al, 64
121	@@:	121	@@:
122	div cl	122	div cl
123	shl ax, 8	123	shl ax, 8
124	dec edx	124	dec edx
125	jnz .calculate	125	jnz .calculate
126	mov dl, cl	126	mov dl, cl
127	dec edx	127	dec edx
128	shr edx, 1	128	shr edx, 1
129	shr eax, 8	129	shr eax, 8
130	mov edi, eax	130	mov edi, eax
131	mul edx	131	mul edx
132	add esi, eax	132	add esi, eax
133		133
134	.draw: ; calculate window-relative coordinates	134	.draw: ; calculate window-relative coordinates
135	movzx ebp, cx	135	movzx ebp, cx
136	dec ebp	136	dec ebp
137	shr ebx, 16	137	shr ebx, 16
138	shr ecx, 16	138	shr ecx, 16
139	mov eax, [TASK_BASE]	139	mov eax, [TASK_BASE]
140	add ebx, [eax - twdw + WDATA.box.left]	140	add ebx, [eax - twdw + WDATA.box.left]
141	add ecx, [eax - twdw + WDATA.box.top]	141	add ecx, [eax - twdw + WDATA.box.top]
142	mov eax, ebx	142	mov eax, ebx
143	inc eax	143	inc eax
144	mov edx, ebx	144	mov edx, ebx
145	add dx, [esp+8]	145	add dx, [esp+8]
146	dec edx	146	dec edx
147	mov ebx, ecx	147	mov ebx, ecx
148	mov ecx, esi	148	mov ecx, esi
149	shr ecx, 1	149	shr ecx, 1
150	and cx, 7F7Fh	150	and cx, 7F7Fh
151	push esi	151	push esi
152	mov esi, edi	152	mov esi, edi
153	xor edi, edi	153	xor edi, edi
154	call hline ; top border	154	call hline ; top border
155	inc ebx	155	inc ebx
156	or ecx, 808080h	156	or ecx, 808080h
157	call hline ; top light line	157	call hline ; top light line
158	pop ecx	158	pop ecx
159	inc ebx	159	inc ebx
160	.next_line:	160	.next_line:
161	call hline ; button body	161	call hline ; button body
162	inc ebx	162	inc ebx
163	sub ecx, esi	163	sub ecx, esi
164	dec ebp	164	dec ebp
165	jnz .next_line	165	jnz .next_line
166	shr ecx, 2	166	shr ecx, 2
167	and cx, 3F3Fh	167	and cx, 3F3Fh
168	mov ebp, ecx	168	mov ebp, ecx
169	shl ecx, 1	169	shl ecx, 1
170	add ecx, ebp	170	add ecx, ebp
171	call hline ; bottom dark line	171	call hline ; bottom dark line
172	inc ebx	172	inc ebx
173	sub ecx, ebp	173	sub ecx, ebp
174	call hline ; bottom border	174	call hline ; bottom border
175	pop ecx	175	pop ecx
176	shr ecx, 1	176	shr ecx, 1
177	inc edx	177	inc edx
178	push edx	178	push edx
179	mov edx, ebx	179	mov edx, ebx
180	sub bx, [esp+4]	180	sub bx, [esp+4]
181	dec edx	181	dec edx
182	inc ebx	182	inc ebx
183	cmp [buttontype], 0	183	cmp [buttontype], 0
184	jnz @f	184	jnz @f
185	dec edx	185	dec edx
186	or ecx, 808080h	186	or ecx, 808080h
187	call vline ; left light line	187	call vline ; left light line
188	inc edx	188	inc edx
189	@@:	189	@@:
190	and ecx, 7F7F7Fh	190	and ecx, 7F7F7Fh
191	dec eax	191	dec eax
192	call vline ; left border	192	call vline ; left border
193	pop eax	193	pop eax
194	call vline ; right border	194	call vline ; right border
195	cmp [buttontype], 0	195	cmp [buttontype], 0
196	jnz @f	196	jnz @f
197	mov ebp, ecx	197	mov ebp, ecx
198	shr ecx, 1	198	shr ecx, 1
199	and cx, 7F7Fh	199	and cx, 7F7Fh
200	add ecx, ebp	200	add ecx, ebp
201	dec eax	201	dec eax
202	inc ebx	202	inc ebx
203	call vline ; right dark line	203	call vline ; right dark line
204	@@:	204	@@:
205	pop ecx ebx	205	pop ecx ebx
206	.exit:	206	.exit:
207	ret	207	ret
208		208
209	; FIXME: mutex needed	209	; FIXME: mutex needed
210	.remove_button:	210	.remove_button:
211	and edx, 0x00ffffff	211	and edx, 0x00ffffff
212	mov edi, [BTN_ADDR]	212	mov edi, [BTN_ADDR]
213	mov ebx, [edi]	213	mov ebx, [edi]
214	inc ebx	214	inc ebx
215	imul esi, ebx, sizeof.SYS_BUTTON	215	imul esi, ebx, sizeof.SYS_BUTTON
216	add esi, edi	216	add esi, edi
217	xor ecx, ecx	217	xor ecx, ecx
218	add ecx, -sizeof.SYS_BUTTON	218	add ecx, -sizeof.SYS_BUTTON
219	add esi, sizeof.SYS_BUTTON	219	add esi, sizeof.SYS_BUTTON
220		220
221	.next_button:	221	.next_button:
222	dec ebx	222	dec ebx
223	jz .exit	223	jz .exit
224		224
225	add ecx, sizeof.SYS_BUTTON	225	add ecx, sizeof.SYS_BUTTON
226	add esi, -sizeof.SYS_BUTTON	226	add esi, -sizeof.SYS_BUTTON
227		227
228	; does it belong to our process?	228	; does it belong to our process?
229	mov ax, [CURRENT_TASK]	229	mov ax, [CURRENT_TASK]
230	cmp ax, [esi + SYS_BUTTON.pslot]	230	cmp ax, [esi + SYS_BUTTON.pslot]
231	jne .next_button	231	jne .next_button
232		232
233	; does the identifier match?	233	; does the identifier match?
234	mov eax, dword[esi + SYS_BUTTON.id_hi - 2]	234	mov eax, dword[esi + SYS_BUTTON.id_hi - 2]
235	mov ax, [esi + SYS_BUTTON.id_lo]	235	mov ax, [esi + SYS_BUTTON.id_lo]
236	and eax, 0x00ffffff	236	and eax, 0x00ffffff
237	cmp edx, eax	237	cmp edx, eax
238	jne .next_button	238	jne .next_button
239		239
240	; okay, undefine it	240	; okay, undefine it
241	push ebx	241	push ebx
242	mov ebx, esi	242	mov ebx, esi
243	lea eax, [esi + sizeof.SYS_BUTTON]	243	lea eax, [esi + sizeof.SYS_BUTTON]
244	call memmove	244	call memmove
245	dec dword[edi]	245	dec dword[edi]
246	add ecx, -sizeof.SYS_BUTTON	246	add ecx, -sizeof.SYS_BUTTON
247	pop ebx	247	pop ebx
248	jmp .next_button	248	jmp .next_button
249		249
250	;---------------------------------------------------------------	250	;---------------------------------------------------------------
251	sys_button_activate_handler:	251	sys_button_activate_handler:
252	sys_button_deactivate_handler:	252	sys_button_deactivate_handler:
253	;---------------------------------------------------------------	253	;---------------------------------------------------------------
254	;> eax = pack[8(process slot), 24(button id)]	254	;> eax = pack[8(process slot), 24(button id)]
255	;> ebx = pack[16(button x coord), 16(button y coord)]	255	;> ebx = pack[16(button x coord), 16(button y coord)]
256	;> cl = mouse button mask this system button was pressed with	256	;> cl = mouse button mask this system button was pressed with
257	;---------------------------------------------------------------	257	;---------------------------------------------------------------
258	; find system button by specified process slot, id and coordinates	258	; find system button by specified process slot, id and coordinates
259	push ecx edx esi edi	259	push ecx edx esi edi
260	mov edx, eax	260	mov edx, eax
261	shr edx, 24	261	shr edx, 24
262	and eax, 0x0ffffff	262	and eax, 0x0ffffff
263	mov edi, [BTN_ADDR]	263	mov edi, [BTN_ADDR]
264	mov ecx, [edi]	264	mov ecx, [edi]
265	imul esi, ecx, sizeof.SYS_BUTTON	265	imul esi, ecx, sizeof.SYS_BUTTON
266	add esi, edi	266	add esi, edi
267	inc ecx	267	inc ecx
268	add esi, sizeof.SYS_BUTTON	268	add esi, sizeof.SYS_BUTTON
269	.next_button:	269	.next_button:
270	dec ecx	270	dec ecx
271	jz .popexit	271	jz .popexit
272	add esi, -sizeof.SYS_BUTTON	272	add esi, -sizeof.SYS_BUTTON
273		273
274	; does it belong to our process?	274	; does it belong to our process?
275	cmp dx, [esi + SYS_BUTTON.pslot]	275	cmp dx, [esi + SYS_BUTTON.pslot]
276	jne .next_button	276	jne .next_button
277		277
278	; does id match?	278	; does id match?
279	mov edi, dword[esi + SYS_BUTTON.id_hi - 2]	279	mov edi, dword[esi + SYS_BUTTON.id_hi - 2]
280	mov di, [esi + SYS_BUTTON.id_lo]	280	mov di, [esi + SYS_BUTTON.id_lo]
281	and edi, 0x0ffffff	281	and edi, 0x0ffffff
282	cmp eax, edi	282	cmp eax, edi
283	jne .next_button	283	jne .next_button
284		284
285	; does coordinates match?	285	; does coordinates match?
286	mov edi, dword[esi + SYS_BUTTON.left - 2]	286	mov edi, dword[esi + SYS_BUTTON.left - 2]
287	mov di, [esi + SYS_BUTTON.top]	287	mov di, [esi + SYS_BUTTON.top]
288	cmp ebx, edi	288	cmp ebx, edi
289	jne .next_button	289	jne .next_button
290		290
291	mov eax, esi	291	mov eax, esi
292	pop edi esi edx ecx	292	pop edi esi edx ecx
293	mov ebx, dword[eax + SYS_BUTTON.id_hi - 2]	293	mov ebx, dword[eax + SYS_BUTTON.id_hi - 2]
294		294
295	; display button border on press?	295	; display button border on press?
296	test ebx, 0x20000000	296	bt ebx, 29
297	jnz .exit	297	jc .exit
298		298
299	; invert system button border	299	; invert system button border
300	pushad	300	pushad
301	mov esi, eax	301	mov esi, eax
-		302	mov edi, ebx
302	movzx ecx, [esi + SYS_BUTTON.pslot]	303	movzx ecx, [esi + SYS_BUTTON.pslot]
303	shl ecx, 5	304	shl ecx, 5
304	add ecx, window_data	305	add ecx, window_data
305	mov eax, dword[esi + SYS_BUTTON.left]	306	mov eax, dword[esi + SYS_BUTTON.left]
306	mov ebx, dword[esi + SYS_BUTTON.top]	307	mov ebx, dword[esi + SYS_BUTTON.top]
307	add eax, [ecx + WDATA.box.left]	308	add eax, [ecx + WDATA.box.left]
308	add ebx, [ecx + WDATA.box.top]	309	add ebx, [ecx + WDATA.box.top]
309	mov ecx, eax	310	mov ecx, eax
310	mov edx, ebx	311	mov edx, ebx
-		312	bt edi, 30
-		313	jc @f
311	inc ax	314	inc ax
312	inc bx	315	inc bx
-		316	dec cx
-		317	dec dx
-		318	@@:
313	rol eax, 16	319	rol eax, 16
314	rol ebx, 16	320	rol ebx, 16
315	add ax, cx	321	add ax, cx
316	add bx, dx	322	add bx, dx
317	dec ax	-
318	dec bx	-
319	mov esi, 1000000h	323	mov esi, 1000000h
320	call draw_rectangle.forced	324	call draw_rectangle.forced
321	popad	325	popad
322	.exit:	326	.exit:
323	ret	327	ret
324	.popexit:	328	.popexit:
325	pop edi esi edx ecx	329	pop edi esi edx ecx
326	ret	330	ret
327		331
328	;---------------------------------------------------------------	332	;---------------------------------------------------------------
329	sys_button_perform_handler:	333	sys_button_perform_handler:
330	;---------------------------------------------------------------	334	;---------------------------------------------------------------
331	;> eax = pack[8(process slot), 24(button id)]	335	;> eax = pack[8(process slot), 24(button id)]
332	;> ebx = pack[16(button x coord), 16(button y coord)]	336	;> ebx = pack[16(button x coord), 16(button y coord)]
333	;> cl = mouse button mask this system button was pressed with	337	;> cl = mouse button mask this system button was pressed with
334	;---------------------------------------------------------------	338	;---------------------------------------------------------------
335	shl eax, 8	339	shl eax, 8
336	mov al, cl	340	mov al, cl
337	movzx ebx, byte[BTN_COUNT]	341	movzx ebx, byte[BTN_COUNT]
338	mov [BTN_BUFF + ebx * 4], eax	342	mov [BTN_BUFF + ebx * 4], eax
339	inc bl	343	inc bl
340	mov [BTN_COUNT], bl	344	mov [BTN_COUNT], bl
341	ret	345	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/button.inc – Rev 6035 → 6044