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


$Revision: 473 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa      ;;
;; Distributed under terms of the GNU General Public License    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
init_events:
           stdcall kernel_alloc, 512*EVENT_SIZE
           mov [events], eax
           xor eax, eax
           mov [event_uid], eax
           not eax
           mov edi, event_map
           mov [event_start], edi
           mov ecx, 64/4
           cld
           rep stosd
           mov [event_end], edi
           ret
 
align 4
proc alloc_event
 
           pushfd
           cli
           mov ebx, [event_start]
           mov ecx, [event_end]
.l1:
           bsf eax,[ebx]
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           popfd
           xor eax,eax
           ret
.found:
           btr [ebx], eax
           mov [event_start],ebx
           inc [event_uid]
 
           sub ebx, event_map
           lea eax,[eax+ebx*8]
 
           lea ebx, [eax+eax*4]
           shl eax,5
           lea eax,[eax+ebx*4]   ;eax*=52 (EVENT_SIZE)
           add eax, [events]
           mov ebx, [event_uid]
           popfd
           ret
endp
 
align 4
free_event:
           sub eax, [events]
           mov ecx, EVENT_SIZE
           mov ebx, event_map
           cdq
           div ecx
 
           pushfd
           cli
           bts [ebx], eax
           shr eax, 3
           and eax, not 3
           add eax, ebx
           cmp [event_start], eax
           ja @f
           popfd
           ret
@@:
           mov [event_start], eax
           popfd
           ret
 
EVENT_WATCHED    equ 0x10000000
EVENT_SIGNALED   equ 0x20000000
MANUAL_RESET     equ 0x40000000
MANUAL_DESTROY   equ 0x80000000
 
 
; param
;  eax= event data
;  ebx= flags
;
; retval
;  eax= event
;  edx= id
 
create_event:
           .flags  equ  esp+4
           .data   equ  esp
 
           push ebx
           push eax
 
           call alloc_event
           test eax, eax
           jz .fail
 
           mov [eax+APPOBJ.magic], 'EVNT'
           mov [eax+APPOBJ.destroy], destroy_event.internal
           mov [eax+EVENT.id], ebx
 
           mov ebx, [CURRENT_TASK]
           shl ebx, 5
           mov ebx, [CURRENT_TASK+ebx+4]
           mov [eax+APPOBJ.pid], ebx
           mov edx, [.flags]
           mov [eax+EVENT.state], edx
 
           mov esi, [.data]
           test esi, esi
           jz @F
           lea edi, [eax+EVENT.code]
           mov ecx, 6
           cld
           rep movsd
@@:
           mov ecx, [current_slot]
           add ecx, APP_OBJ_OFFSET
 
           pushfd
           cli
           mov edx, [ecx+APPOBJ.fd]
           mov [eax+APPOBJ.fd], edx
           mov [eax+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], eax
           mov [edx+APPOBJ.bk], eax
           popfd
           mov edx, [eax+EVENT.id]
.fail:
           add esp, 8
           ret
 
restore .flags
restore .data
 
; param
;  eax= event
;  ebx= id
 
destroy_event:
 
           cmp [eax+APPOBJ.magic], 'EVNT'
           jne .fail
           cmp [eax+EVENT.id], ebx
           jne .fail
.internal:
           mov ebx, [eax+APPOBJ.fd]
           mov ecx, [eax+APPOBJ.bk]
           mov [ebx+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], ebx
.force:
           xor edx, edx             ;clear common header
           mov [eax], edx
           mov [eax+4], edx
           mov [eax+8], edx
           mov [eax+12], edx
           mov [eax+16], edx
 
           call free_event          ;release object memory
.fail:
           ret
 
align 4
proc send_event stdcall pid:dword, event:dword
           locals
             slot     dd ?
           endl
 
           mov eax, [pid]
           call pid_to_slot
           test eax, eax
           jz .fail
 
           shl eax, 8
           cmp [SLOT_BASE+eax+APPDATA.ev_count], 32
           ja .fail
 
           mov [slot], eax
 
           call alloc_event
           test eax, eax
           jz .fail
 
           lea edi, [eax+EVENT.code]
           mov ecx, 6
           mov esi, [event]
           cld
           rep movsd
 
           mov ecx, [slot]
           add ecx, SLOT_BASE+APP_EV_OFFSET
 
           mov [eax+APPOBJ.magic], 'EVNT'
           mov [eax+APPOBJ.destroy], destroy_event
           mov ebx, [pid]
           mov [eax+APPOBJ.pid], ebx
           mov [eax+EVENT.state], EVENT_SIGNALED
 
           pushfd
           cli                         ;insert event into
           mov edx, [ecx+APPOBJ.fd]    ;events list
           mov [eax+APPOBJ.fd], edx    ;and set events flag
           mov [eax+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], eax
           mov [edx+APPOBJ.bk], eax
           inc [ecx+APPDATA.ev_count-APP_EV_OFFSET]
           or  [ecx+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED
           popfd
.fail:
           ret
endp
 
; timeout ignored
 
align 4
proc get_event_ex stdcall, p_ev:dword, timeout:dword
 
.wait:
           mov edx,[current_slot]
;           cmp [SLOT_BASE+edx+APPDATA.ev_count], 0
;           je .switch
 
           add edx, APP_EV_OFFSET
 
           mov eax, [edx+APPOBJ.fd]
           cmp eax, edx
           je .switch
 
           lea esi, [eax+EVENT.code]
           mov edi, [p_ev]                ;copy event data
           mov ecx, 6
           cld
           rep movsd
 
           and dword [edi-24], 0xFF00FFFF ;clear priority field
                                         ;
           test [eax+EVENT.state], MANUAL_RESET
           jnz .done
 
           pushfd
           cli                         ;remove event from events
           mov ebx, [eax+APPOBJ.fd]    ;list (reset event)
           mov ecx, [eax+APPOBJ.bk]    ;and clear events flag
           mov [ebx+APPOBJ.bk], ecx    ;if no active events
           mov [ecx+APPOBJ.fd], ebx
 
           and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
 
           dec [edx+APPDATA.ev_count-APP_EV_OFFSET]
           jnz @F
           and [edx+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED
@@:
           popfd
 
           test [eax+EVENT.state], MANUAL_DESTROY
           jz .destroy
 
           add edx, (APP_OBJ_OFFSET-APP_EV_OFFSET)
 
           pushfd
           cli
           mov ebx, [edx+APPOBJ.fd]  ;insert event into
           mov [eax+APPOBJ.fd], ebx  ;objects list
           mov [eax+APPOBJ.bk], edx
           mov [edx+APPOBJ.fd], eax
           mov [ebx+APPOBJ.bk], eax
           popfd
.done:
           ret
 
.destroy:
           call destroy_event.force
           ret
.switch:
           mov eax, [TASK_BASE]
           mov [eax+TASKDATA.state], byte 5
	   call change_task
	   jmp .wait
endp
 
; param
;  eax= event
;  ebx= id
 
align 4
wait_event:
           .event equ esp
           push eax
.wait:
           cmp [eax+APPOBJ.magic], 'EVNT'
           jne .done
           cmp [eax+EVENT.id], ebx
           jne .done
 
           test [eax+EVENT.state], EVENT_SIGNALED
           jz .switch
 
           test [eax+EVENT.state], MANUAL_RESET
           jnz .done
 
           mov edx,[current_slot]
 
           pushfd
           cli                         ;remove event from events
           mov ebx, [eax+APPOBJ.fd]    ;list (reset event)
           mov ecx, [eax+APPOBJ.bk]    ;and clear events flag
           mov [ebx+APPOBJ.bk], ecx    ;if no active events
           mov [ecx+APPOBJ.fd], ebx
           dec [edx+APPDATA.ev_count]
           jnz @F
           and [edx+APPDATA.event_mask], not EVENT_EXTENDED
@@:
           and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
           popfd
 
           test [eax+EVENT.state], MANUAL_DESTROY
           jz .destroy
 
           add edx, APP_OBJ_OFFSET
 
           pushfd
           cli
           mov ecx, [edx+APPOBJ.fd]  ;insert event into
           mov [eax+APPOBJ.fd], ecx  ;objects list
           mov [eax+APPOBJ.bk], edx
           mov [edx+APPOBJ.fd], eax
           mov [ecx+APPOBJ.bk], eax
           popfd
.done:
           add esp, 4
           ret
.destroy:
           call destroy_event.force
           add esp, 4
           ret
.switch:
           or [eax+EVENT.state], EVENT_WATCHED
           mov eax, [TASK_BASE]
           mov [eax+TASKDATA.state], byte 5
	   call change_task
           mov eax, [.event]
	   jmp .wait
restore .event
 
; param
;  eax= event
;  ebx= id
;  ecx= flags
;  edx= event data
 
raise_event:
           .event equ esp
           push eax
 
           cmp [eax+APPOBJ.magic], 'EVNT'
           jne .fail
           cmp [eax+EVENT.id], ebx
           jne .fail
 
           mov eax, [eax+APPOBJ.pid]
           call pid_to_slot
           test eax, eax
           jz .fail
 
           mov esi, edx
           test esi, esi
           mov edx, [.event]
           jz @F
 
           push ecx
           lea edi, [edx+EVENT.code]
           mov ecx, 6
           cld
           rep movsd
           pop ecx
@@:
           test [edx+EVENT.state], EVENT_SIGNALED
           jnz .done
 
           test ecx, EVENT_WATCHED
           jz @F
           test [edx+EVENT.state], EVENT_WATCHED
           jz .done
@@:
           shl eax, 8
           add eax, SLOT_BASE+APP_EV_OFFSET
 
           pushfd
           cli
           mov ebx, [edx+APPOBJ.fd]
           mov ecx, [edx+APPOBJ.bk]
           mov [ebx+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], ebx
 
           mov ecx, [eax+APPOBJ.fd]
           mov [edx+APPOBJ.fd], ecx
           mov [edx+APPOBJ.bk], eax
           mov [eax+APPOBJ.fd], edx
           mov [ecx+APPOBJ.bk], edx
           or [edx+EVENT.state], EVENT_SIGNALED
 
           inc [eax+APPDATA.ev_count-APP_EV_OFFSET]
           or  [eax+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED
           popfd
.fail:
.done:
           add esp, 4
           ret
restore .event
 
; param
;  eax= event
;  ebx= id
align 4
clear_event:
           .event equ esp
           push eax
 
           cmp [eax+APPOBJ.magic], 'EVNT'
           jne .fail
           cmp [eax+EVENT.id], ebx
           jne .fail
 
           mov eax, [eax+APPOBJ.pid]
           call pid_to_slot
           test eax, eax
           jz .fail
 
           shl eax, 8
           add eax, SLOT_BASE+APP_EV_OFFSET
           mov edx, [.event]
           pushfd
           cli                         ;remove event from events
           mov ebx, [edx+APPOBJ.fd]    ;list (reset event)
           mov ecx, [edx+APPOBJ.bk]    ;and clear events flag
           mov [ebx+APPOBJ.bk], ecx    ;if no active events
           mov [ecx+APPOBJ.fd], ebx
 
           and [edx+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
 
           dec [eax+APPDATA.ev_count-APP_EV_OFFSET]
           jnz @F
           and [eax+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED
@@:
           add eax, (APP_OBJ_OFFSET-APP_EV_OFFSET)
 
           mov ecx, [eax+APPOBJ.fd]  ;insert event into
           mov [edx+APPOBJ.fd], ecx  ;objects list
           mov [edx+APPOBJ.bk], eax
           mov [eax+APPOBJ.fd], edx
           mov [ecx+APPOBJ.bk], edx
           popfd
.fail:
.done:
           add esp, 4
           ret
restore .event
 
sys_getevent:
 
     call   get_event_for_app
     mov    [esp+36],eax
     ret
 
 
align 4
sys_wait_event_timeout:
 
     mov   ebx,[timer_ticks]
     add   ebx,eax
     cmp   ebx,[timer_ticks]
     jna   .swfet2
.swfet1:
     call  get_event_for_app
     test  eax,eax
     jne   .eventoccur_time
     call  change_task
     cmp   ebx,[timer_ticks]
     jg    .swfet1
.swfet2:
     xor   eax,eax
.eventoccur_time:
     mov   [esp+36],eax
     ret
 
 
align 4
 
sys_waitforevent:
 
     call  get_event_for_app
     test  eax,eax
     jne   eventoccur
   newwait:
 
     mov   eax, [TASK_BASE]
     mov   [eax+TASKDATA.state], byte 5
     call  change_task
 
     mov eax, [event_sched]
 
   eventoccur:
     mov   [esp+36],eax
     ret
 
get_event_for_app:
 
     pushad
 
     mov   edi,[TASK_BASE]              ; WINDOW REDRAW
     test  [edi+TASKDATA.event_mask],dword 1
     jz    no_eventoccur1
     ;mov   edi,[TASK_BASE]
     cmp   [edi-twdw+WDATA.fl_redraw],byte 0
     je    no_eventoccur1
     popad
     mov   eax,1
     ret
   no_eventoccur1:
 
     ;mov   edi,[TASK_BASE]              ; KEY IN BUFFER
     test  [edi+TASKDATA.event_mask],dword 2
     jz    no_eventoccur2
     mov   ecx, [CURRENT_TASK]
     movzx edx,word [WIN_STACK+ecx*2]
     mov   eax, [TASK_COUNT]
     cmp   eax,edx
     jne   no_eventoccur2x
     cmp   [KEY_COUNT],byte 0
     je    no_eventoccur2x
   eventoccur2:
     popad
     mov   eax,2
     ret
   no_eventoccur2x:
        mov     eax, hotkey_buffer
@@:
        cmp     [eax], ecx
        jz      eventoccur2
        add     eax, 8
        cmp     eax, hotkey_buffer+120*8
        jb      @b
   no_eventoccur2:
 
     ;mov   edi,[TASK_BASE]              ; BUTTON IN BUFFER
     test  [edi+TASKDATA.event_mask],dword 4
     jz    no_eventoccur3
     cmp   [BTN_COUNT],byte 0
     je    no_eventoccur3
     mov   ecx, [CURRENT_TASK]
     movzx edx, word [WIN_STACK+ecx*2]
     mov   eax, [TASK_COUNT]
     cmp   eax,edx
     jnz   no_eventoccur3
     popad
     mov   eax,[BTN_BUFF]
     cmp   eax,65535
     je    no_event_1
     mov   eax,3
     ret
 
    no_event_1:
     mov   [window_minimize],1
     mov   [BTN_COUNT],byte 0
     xor   eax, eax
     ret
 
no_eventoccur3:
 
     ;mov   edi,[TASK_BASE]              ; mouse event
     mov eax, [CURRENT_TASK]
     shl eax, 8
     add eax, SLOT_BASE
     test  [edi+TASKDATA.event_mask],dword 00100000b
     jz    no_mouse_event
 
 
 
     test  [eax+APPDATA.event_mask],dword 00100000b
     jz    no_mouse_event
     and   [eax+APPDATA.event_mask],dword (not 00100000b)
     popad
     mov   eax,6
     ret
no_mouse_event:
 
     ;mov   edi,[TASK_BASE]              ; DESKTOP BACKGROUND REDRAW
     test  [edi+TASKDATA.event_mask], 16
     jz    no_eventoccur5
;     cmp   [REDRAW_BACKGROUND],byte 2
;     jnz   no_eventoccur5
     test  [eax+APPDATA.event_mask], 16
     jz    no_eventoccur5
     and   [eax+APPDATA.event_mask], not 16
 
     popad
     mov   eax,5
     ret
no_eventoccur5:
 
     ;mov   edi,[TASK_BASE]              ; IPC
     test  [edi+TASKDATA.event_mask],dword 01000000b
     jz    no_ipc
 
 
     test  [eax+APPDATA.event_mask],dword 01000000b
     jz    no_ipc
     and   [eax+APPDATA.event_mask],dword 0xffffffff-01000000b
     popad
     mov   eax,7
     ret
no_ipc:
 
     ;mov   edi,[TASK_BASE]              ; STACK
     test  [edi+TASKDATA.event_mask],dword 10000000b
     jz    no_stack_event
 
 
     test  [eax+APPDATA.event_mask],dword 10000000b
     jz    no_stack_event
     and   [eax+APPDATA.event_mask],dword 0xffffffff-10000000b
     popad
     mov   eax,8
     ret
no_stack_event:
 
     test  byte [edi+TASKDATA.event_mask+1], 1		; DEBUG
     jz    .test_IRQ
 
 
     test  byte [eax+APPDATA.event_mask+1], byte 1
     jz    .test_IRQ
     and   byte [eax+APPDATA.event_mask+1], not 1
     popad
     mov   eax, 9
     ret
 
;.test_ext:
;     mov   eax, [CURRENT_TASK]
;     shl   eax, 8
;     test  dword [eax+SLOT_BASE+APPDATA.event_mask], EVENT_EXTENDED
;     jz .test_IRQ
;     popad
;     mov eax, 10
;     ret
 
.test_IRQ:
     cmp   dword [edi+TASKDATA.event_mask], 0xFFFF
     jbe   no_events
 
     mov   esi,IRQ_SAVE              ; IRQ'S AND DATA
     mov   ebx,0x00010000
     xor   ecx, ecx
   irq_event_test:
     mov   edi,[TASK_BASE]
     test  [edi+TASKDATA.event_mask],ebx
     jz    no_irq_event
     mov   edi,ecx
     shl   edi,2
     add   edi,irq_owner
     mov   edx,[edi]
     mov   eax,[TASK_BASE]
     mov   eax,[eax+TASKDATA.pid]
     cmp   edx,eax
     jne   no_irq_event
     cmp   [esi],dword 0
     jz    no_irq_event
     mov   eax,ecx
     add   eax,16
     mov   [esp+28],eax
     popad
     ret
    no_irq_event:
     add   esi,0x1000
     shl   ebx,1
     inc   ecx
     cmp   ecx,16
     jb    irq_event_test
 
   no_events:
     popad
     xor   eax, eax
     ret

Rev 465	Rev 473
1	$Revision: 465 $	1	$Revision: 473 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;; ;;	3	;; ;;
4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
5	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;	5	;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
6	;; Distributed under terms of the GNU General Public License ;;	6	;; Distributed under terms of the GNU General Public License ;;
7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8		8
9	align 4	9	align 4
10	init_events:	10	init_events:
11	stdcall kernel_alloc, 512*EVENT_SIZE	11	stdcall kernel_alloc, 512*EVENT_SIZE
12	mov [events], eax	12	mov [events], eax
13	xor eax, eax	13	xor eax, eax
14	mov [event_uid], eax	14	mov [event_uid], eax
15	not eax	15	not eax
16	mov edi, event_map	16	mov edi, event_map
17	mov [event_start], edi	17	mov [event_start], edi
18	mov ecx, 64/4	18	mov ecx, 64/4
19	cld	19	cld
20	rep stosd	20	rep stosd
21	mov [event_end], edi	21	mov [event_end], edi
22	ret	22	ret
23		23
24	align 4	24	align 4
25	proc alloc_event	25	proc alloc_event
26		26
27	pushfd	27	pushfd
28	cli	28	cli
29	mov ebx, [event_start]	29	mov ebx, [event_start]
30	mov ecx, [event_end]	30	mov ecx, [event_end]
31	.l1:	31	.l1:
32	bsf eax,[ebx]	32	bsf eax,[ebx]
33	jnz .found	33	jnz .found
34	add ebx,4	34	add ebx,4
35	cmp ebx, ecx	35	cmp ebx, ecx
36	jb .l1	36	jb .l1
37	popfd	37	popfd
38	xor eax,eax	38	xor eax,eax
39	ret	39	ret
40	.found:	40	.found:
41	btr [ebx], eax	41	btr [ebx], eax
42	mov [event_start],ebx	42	mov [event_start],ebx
43	inc [event_uid]	43	inc [event_uid]
44		44
45	sub ebx, event_map	45	sub ebx, event_map
46	lea eax,[eax+ebx*8]	46	lea eax,[eax+ebx*8]
47		47
48	lea ebx, [eax+eax*4]	48	lea ebx, [eax+eax*4]
49	shl eax,5	49	shl eax,5
50	lea eax,[eax+ebx4] ;eax=52 (EVENT_SIZE)	50	lea eax,[eax+ebx4] ;eax=52 (EVENT_SIZE)
51	add eax, [events]	51	add eax, [events]
52	mov ebx, [event_uid]	52	mov ebx, [event_uid]
53	popfd	53	popfd
54	ret	54	ret
55	endp	55	endp
56		56
57	align 4	57	align 4
58	free_event:	58	free_event:
59	sub eax, [events]	59	sub eax, [events]
60	mov ecx, EVENT_SIZE	60	mov ecx, EVENT_SIZE
61	mov ebx, event_map	61	mov ebx, event_map
62	cdq	62	cdq
63	div ecx	63	div ecx
64		64
65	pushfd	65	pushfd
66	cli	66	cli
67	bts [ebx], eax	67	bts [ebx], eax
68	shr eax, 3	68	shr eax, 3
69	and eax, not 3	69	and eax, not 3
70	add eax, ebx	70	add eax, ebx
71	cmp [event_start], eax	71	cmp [event_start], eax
72	ja @f	72	ja @f
73	popfd	73	popfd
74	ret	74	ret
75	@@:	75	@@:
76	mov [event_start], eax	76	mov [event_start], eax
77	popfd	77	popfd
78	ret	78	ret
79		79
80	EVENT_WATCHED equ 0x10000000	80	EVENT_WATCHED equ 0x10000000
81	EVENT_SIGNALED equ 0x20000000	81	EVENT_SIGNALED equ 0x20000000
82	MANUAL_RESET equ 0x40000000	82	MANUAL_RESET equ 0x40000000
83	MANUAL_DESTROY equ 0x80000000	83	MANUAL_DESTROY equ 0x80000000
84		84
85		85
86	; param	86	; param
87	; eax= event data	87	; eax= event data
88	; ebx= flags	88	; ebx= flags
89	;	89	;
90	; retval	90	; retval
91	; eax= event	91	; eax= event
92	; edx= id	92	; edx= id
93		93
94	create_event:	94	create_event:
95	.flags equ esp+4	95	.flags equ esp+4
96	.data equ esp	96	.data equ esp
97		97
98	push ebx	98	push ebx
99	push eax	99	push eax
100		100
101	call alloc_event	101	call alloc_event
102	test eax, eax	102	test eax, eax
103	jz .fail	103	jz .fail
104		104
105	mov [eax+APPOBJ.magic], 'EVNT'	105	mov [eax+APPOBJ.magic], 'EVNT'
106	mov [eax+APPOBJ.destroy], destroy_event.internal	106	mov [eax+APPOBJ.destroy], destroy_event.internal
107	mov [eax+EVENT.id], ebx	107	mov [eax+EVENT.id], ebx
108		108
109	mov ebx, [CURRENT_TASK]	109	mov ebx, [CURRENT_TASK]
110	shl ebx, 5	110	shl ebx, 5
111	mov ebx, [CURRENT_TASK+ebx+4]	111	mov ebx, [CURRENT_TASK+ebx+4]
112	mov [eax+APPOBJ.pid], ebx	112	mov [eax+APPOBJ.pid], ebx
113	mov edx, [.flags]	113	mov edx, [.flags]
114	mov [eax+EVENT.state], edx	114	mov [eax+EVENT.state], edx
115		115
116	mov esi, [.data]	116	mov esi, [.data]
117	test esi, esi	117	test esi, esi
118	jz @F	118	jz @F
119	lea edi, [eax+EVENT.code]	119	lea edi, [eax+EVENT.code]
120	mov ecx, 6	120	mov ecx, 6
121	cld	121	cld
122	rep movsd	122	rep movsd
123	@@:	123	@@:
124	mov ecx, [current_slot]	124	mov ecx, [current_slot]
125	add ecx, APP_OBJ_OFFSET	125	add ecx, APP_OBJ_OFFSET
126		126
127	pushfd	127	pushfd
128	cli	128	cli
129	mov edx, [ecx+APPOBJ.fd]	129	mov edx, [ecx+APPOBJ.fd]
130	mov [eax+APPOBJ.fd], edx	130	mov [eax+APPOBJ.fd], edx
131	mov [eax+APPOBJ.bk], ecx	131	mov [eax+APPOBJ.bk], ecx
132	mov [ecx+APPOBJ.fd], eax	132	mov [ecx+APPOBJ.fd], eax
133	mov [edx+APPOBJ.bk], eax	133	mov [edx+APPOBJ.bk], eax
134	popfd	134	popfd
135	mov edx, [eax+EVENT.id]	135	mov edx, [eax+EVENT.id]
136	.fail:	136	.fail:
137	add esp, 8	137	add esp, 8
138	ret	138	ret
139		139
140	restore .flags	140	restore .flags
141	restore .data	141	restore .data
142		142
143	; param	143	; param
144	; eax= event	144	; eax= event
145	; ebx= id	145	; ebx= id
146		146
147	destroy_event:	147	destroy_event:
148		148
149	cmp [eax+APPOBJ.magic], 'EVNT'	149	cmp [eax+APPOBJ.magic], 'EVNT'
150	jne .fail	150	jne .fail
151	cmp [eax+EVENT.id], ebx	151	cmp [eax+EVENT.id], ebx
152	jne .fail	152	jne .fail
153	.internal:	153	.internal:
154	mov ebx, [eax+APPOBJ.fd]	154	mov ebx, [eax+APPOBJ.fd]
155	mov ecx, [eax+APPOBJ.bk]	155	mov ecx, [eax+APPOBJ.bk]
156	mov [ebx+APPOBJ.bk], ecx	156	mov [ebx+APPOBJ.bk], ecx
157	mov [ecx+APPOBJ.fd], ebx	157	mov [ecx+APPOBJ.fd], ebx
158	.force:	158	.force:
159	xor edx, edx ;clear common header	159	xor edx, edx ;clear common header
160	mov [eax], edx	160	mov [eax], edx
161	mov [eax+4], edx	161	mov [eax+4], edx
162	mov [eax+8], edx	162	mov [eax+8], edx
163	mov [eax+12], edx	163	mov [eax+12], edx
164	mov [eax+16], edx	164	mov [eax+16], edx
165		165
166	call free_event ;release object memory	166	call free_event ;release object memory
167	.fail:	167	.fail:
168	ret	168	ret
169		169
170	align 4	170	align 4
171	proc send_event stdcall pid:dword, event:dword	171	proc send_event stdcall pid:dword, event:dword
172	locals	172	locals
173	slot dd ?	173	slot dd ?
174	endl	174	endl
175		175
176	mov eax, [pid]	176	mov eax, [pid]
177	call pid_to_slot	177	call pid_to_slot
178	test eax, eax	178	test eax, eax
179	jz .fail	179	jz .fail
180		180
181	shl eax, 8	181	shl eax, 8
182	cmp [SLOT_BASE+eax+APPDATA.ev_count], 32	182	cmp [SLOT_BASE+eax+APPDATA.ev_count], 32
183	ja .fail	183	ja .fail
184		184
185	mov [slot], eax	185	mov [slot], eax
186		186
187	call alloc_event	187	call alloc_event
188	test eax, eax	188	test eax, eax
189	jz .fail	189	jz .fail
190		190
191	lea edi, [eax+EVENT.code]	191	lea edi, [eax+EVENT.code]
192	mov ecx, 6	192	mov ecx, 6
193	mov esi, [event]	193	mov esi, [event]
194	cld	194	cld
195	rep movsd	195	rep movsd
196		196
197	mov ecx, [slot]	197	mov ecx, [slot]
198	add ecx, SLOT_BASE+APP_EV_OFFSET	198	add ecx, SLOT_BASE+APP_EV_OFFSET
199		199
200	mov [eax+APPOBJ.magic], 'EVNT'	200	mov [eax+APPOBJ.magic], 'EVNT'
201	mov [eax+APPOBJ.destroy], destroy_event	201	mov [eax+APPOBJ.destroy], destroy_event
202	mov ebx, [pid]	202	mov ebx, [pid]
203	mov [eax+APPOBJ.pid], ebx	203	mov [eax+APPOBJ.pid], ebx
204	mov [eax+EVENT.state], EVENT_SIGNALED	204	mov [eax+EVENT.state], EVENT_SIGNALED
205		205
206	pushfd	206	pushfd
207	cli ;insert event into	207	cli ;insert event into
208	mov edx, [ecx+APPOBJ.fd] ;events list	208	mov edx, [ecx+APPOBJ.fd] ;events list
209	mov [eax+APPOBJ.fd], edx ;and set events flag	209	mov [eax+APPOBJ.fd], edx ;and set events flag
210	mov [eax+APPOBJ.bk], ecx	210	mov [eax+APPOBJ.bk], ecx
211	mov [ecx+APPOBJ.fd], eax	211	mov [ecx+APPOBJ.fd], eax
212	mov [edx+APPOBJ.bk], eax	212	mov [edx+APPOBJ.bk], eax
213	inc [ecx+APPDATA.ev_count-APP_EV_OFFSET]	213	inc [ecx+APPDATA.ev_count-APP_EV_OFFSET]
214	or [ecx+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED	214	or [ecx+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED
215	popfd	215	popfd
216	.fail:	216	.fail:
217	ret	217	ret
218	endp	218	endp
219		219
220	; timeout ignored	220	; timeout ignored
221		221
222	align 4	222	align 4
223	proc get_event_ex stdcall, p_ev:dword, timeout:dword	223	proc get_event_ex stdcall, p_ev:dword, timeout:dword
224		224
225	.wait:	225	.wait:
226	mov edx,[current_slot]	226	mov edx,[current_slot]
227	; cmp [SLOT_BASE+edx+APPDATA.ev_count], 0	227	; cmp [SLOT_BASE+edx+APPDATA.ev_count], 0
228	; je .switch	228	; je .switch
229		229
230	add edx, APP_EV_OFFSET	230	add edx, APP_EV_OFFSET
231		231
232	mov eax, [edx+APPOBJ.fd]	232	mov eax, [edx+APPOBJ.fd]
233	cmp eax, edx	233	cmp eax, edx
234	je .switch	234	je .switch
235		235
236	lea esi, [eax+EVENT.code]	236	lea esi, [eax+EVENT.code]
237	mov edi, [p_ev] ;copy event data	237	mov edi, [p_ev] ;copy event data
238	mov ecx, 6	238	mov ecx, 6
239	cld	239	cld
240	rep movsd	240	rep movsd
241		241
242	and dword [edi-24], 0xFF00FFFF ;clear priority field	242	and dword [edi-24], 0xFF00FFFF ;clear priority field
243	;	243	;
244	test [eax+EVENT.state], MANUAL_RESET	244	test [eax+EVENT.state], MANUAL_RESET
245	jnz .done	245	jnz .done
246		246
247	pushfd	247	pushfd
248	cli ;remove event from events	248	cli ;remove event from events
249	mov ebx, [eax+APPOBJ.fd] ;list (reset event)	249	mov ebx, [eax+APPOBJ.fd] ;list (reset event)
250	mov ecx, [eax+APPOBJ.bk] ;and clear events flag	250	mov ecx, [eax+APPOBJ.bk] ;and clear events flag
251	mov [ebx+APPOBJ.bk], ecx ;if no active events	251	mov [ebx+APPOBJ.bk], ecx ;if no active events
252	mov [ecx+APPOBJ.fd], ebx	252	mov [ecx+APPOBJ.fd], ebx
253		253
254	and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)	254	and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
255		255
256	dec [edx+APPDATA.ev_count-APP_EV_OFFSET]	256	dec [edx+APPDATA.ev_count-APP_EV_OFFSET]
257	jnz @F	257	jnz @F
258	and [edx+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED	258	and [edx+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED
259	@@:	259	@@:
260	popfd	260	popfd
261		261
262	test [eax+EVENT.state], MANUAL_DESTROY	262	test [eax+EVENT.state], MANUAL_DESTROY
263	jz .destroy	263	jz .destroy
264		264
265	add edx, (APP_OBJ_OFFSET-APP_EV_OFFSET)	265	add edx, (APP_OBJ_OFFSET-APP_EV_OFFSET)
266		266
267	pushfd	267	pushfd
268	cli	268	cli
269	mov ebx, [edx+APPOBJ.fd] ;insert event into	269	mov ebx, [edx+APPOBJ.fd] ;insert event into
270	mov [eax+APPOBJ.fd], ebx ;objects list	270	mov [eax+APPOBJ.fd], ebx ;objects list
271	mov [eax+APPOBJ.bk], edx	271	mov [eax+APPOBJ.bk], edx
272	mov [edx+APPOBJ.fd], eax	272	mov [edx+APPOBJ.fd], eax
273	mov [ebx+APPOBJ.bk], eax	273	mov [ebx+APPOBJ.bk], eax
274	popfd	274	popfd
275	.done:	275	.done:
276	ret	276	ret
277		277
278	.destroy:	278	.destroy:
279	call destroy_event.force	279	call destroy_event.force
280	ret	280	ret
281	.switch:	281	.switch:
282	mov eax, [TASK_BASE]	282	mov eax, [TASK_BASE]
283	mov [eax+TASKDATA.state], byte 5	283	mov [eax+TASKDATA.state], byte 5
284	call change_task	284	call change_task
285	jmp .wait	285	jmp .wait
286	endp	286	endp
287		287
288	; param	288	; param
289	; eax= event	289	; eax= event
290	; ebx= id	290	; ebx= id
291		291
292	align 4	292	align 4
293	wait_event:	293	wait_event:
294	.event equ esp	294	.event equ esp
295	push eax	295	push eax
296	.wait:	296	.wait:
297	cmp [eax+APPOBJ.magic], 'EVNT'	297	cmp [eax+APPOBJ.magic], 'EVNT'
298	jne .done	298	jne .done
299	cmp [eax+EVENT.id], ebx	299	cmp [eax+EVENT.id], ebx
300	jne .done	300	jne .done
301		301
302	test [eax+EVENT.state], EVENT_SIGNALED	302	test [eax+EVENT.state], EVENT_SIGNALED
303	jz .switch	303	jz .switch
304		304
305	test [eax+EVENT.state], MANUAL_RESET	305	test [eax+EVENT.state], MANUAL_RESET
306	jnz .done	306	jnz .done
307		307
308	mov edx,[current_slot]	308	mov edx,[current_slot]
309		309
310	pushfd	310	pushfd
311	cli ;remove event from events	311	cli ;remove event from events
312	mov ebx, [eax+APPOBJ.fd] ;list (reset event)	312	mov ebx, [eax+APPOBJ.fd] ;list (reset event)
313	mov ecx, [eax+APPOBJ.bk] ;and clear events flag	313	mov ecx, [eax+APPOBJ.bk] ;and clear events flag
314	mov [ebx+APPOBJ.bk], ecx ;if no active events	314	mov [ebx+APPOBJ.bk], ecx ;if no active events
315	mov [ecx+APPOBJ.fd], ebx	315	mov [ecx+APPOBJ.fd], ebx
316	dec [edx+APPDATA.ev_count]	316	dec [edx+APPDATA.ev_count]
317	jnz @F	317	jnz @F
318	and [edx+APPDATA.event_mask], not EVENT_EXTENDED	318	and [edx+APPDATA.event_mask], not EVENT_EXTENDED
319	@@:	319	@@:
320	and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)	320	and [eax+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
321	popfd	321	popfd
322		322
323	test [eax+EVENT.state], MANUAL_DESTROY	323	test [eax+EVENT.state], MANUAL_DESTROY
324	jz .destroy	324	jz .destroy
325		325
326	add edx, APP_OBJ_OFFSET	326	add edx, APP_OBJ_OFFSET
327		327
328	pushfd	328	pushfd
329	cli	329	cli
330	mov ecx, [edx+APPOBJ.fd] ;insert event into	330	mov ecx, [edx+APPOBJ.fd] ;insert event into
331	mov [eax+APPOBJ.fd], ecx ;objects list	331	mov [eax+APPOBJ.fd], ecx ;objects list
332	mov [eax+APPOBJ.bk], edx	332	mov [eax+APPOBJ.bk], edx
333	mov [edx+APPOBJ.fd], eax	333	mov [edx+APPOBJ.fd], eax
334	mov [ecx+APPOBJ.bk], eax	334	mov [ecx+APPOBJ.bk], eax
335	popfd	335	popfd
336	.done:	336	.done:
337	add esp, 4	337	add esp, 4
338	ret	338	ret
339	.destroy:	339	.destroy:
340	call destroy_event.force	340	call destroy_event.force
341	add esp, 4	341	add esp, 4
342	ret	342	ret
343	.switch:	343	.switch:
344	or [eax+EVENT.state], EVENT_WATCHED	344	or [eax+EVENT.state], EVENT_WATCHED
345	mov eax, [TASK_BASE]	345	mov eax, [TASK_BASE]
346	mov [eax+TASKDATA.state], byte 5	346	mov [eax+TASKDATA.state], byte 5
347	call change_task	347	call change_task
348	mov eax, [.event]	348	mov eax, [.event]
349	jmp .wait	349	jmp .wait
350	restore .event	350	restore .event
351		351
352	; param	352	; param
353	; eax= event	353	; eax= event
354	; ebx= id	354	; ebx= id
355	; ecx= flags	355	; ecx= flags
356	; edx= event data	356	; edx= event data
357		357
358	raise_event:	358	raise_event:
359	.event equ esp	359	.event equ esp
360	push eax	360	push eax
361		361
362	cmp [eax+APPOBJ.magic], 'EVNT'	362	cmp [eax+APPOBJ.magic], 'EVNT'
363	jne .fail	363	jne .fail
364	cmp [eax+EVENT.id], ebx	364	cmp [eax+EVENT.id], ebx
365	jne .fail	365	jne .fail
366		366
367	mov eax, [eax+APPOBJ.pid]	367	mov eax, [eax+APPOBJ.pid]
368	call pid_to_slot	368	call pid_to_slot
369	test eax, eax	369	test eax, eax
370	jz .fail	370	jz .fail
371		371
372	mov esi, edx	372	mov esi, edx
373	test esi, esi	373	test esi, esi
374	mov edx, [.event]	374	mov edx, [.event]
375	jz @F	375	jz @F
376		376
377	push ecx	377	push ecx
378	lea edi, [edx+EVENT.code]	378	lea edi, [edx+EVENT.code]
379	mov ecx, 6	379	mov ecx, 6
380	cld	380	cld
381	rep movsd	381	rep movsd
382	pop ecx	382	pop ecx
383	@@:	383	@@:
384	test [edx+EVENT.state], EVENT_SIGNALED	384	test [edx+EVENT.state], EVENT_SIGNALED
385	jnz .done	385	jnz .done
386		386
387	test ecx, EVENT_WATCHED	387	test ecx, EVENT_WATCHED
388	jz @F	388	jz @F
389	test [edx+EVENT.state], EVENT_WATCHED	389	test [edx+EVENT.state], EVENT_WATCHED
390	jz .done	390	jz .done
391	@@:	391	@@:
392	shl eax, 8	392	shl eax, 8
393	add eax, SLOT_BASE+APP_EV_OFFSET	393	add eax, SLOT_BASE+APP_EV_OFFSET
394		394
395	pushfd	395	pushfd
396	cli	396	cli
397	mov ebx, [edx+APPOBJ.fd]	397	mov ebx, [edx+APPOBJ.fd]
398	mov ecx, [edx+APPOBJ.bk]	398	mov ecx, [edx+APPOBJ.bk]
399	mov [ebx+APPOBJ.bk], ecx	399	mov [ebx+APPOBJ.bk], ecx
400	mov [ecx+APPOBJ.fd], ebx	400	mov [ecx+APPOBJ.fd], ebx
401		401
402	mov ecx, [eax+APPOBJ.fd]	402	mov ecx, [eax+APPOBJ.fd]
403	mov [edx+APPOBJ.fd], ecx	403	mov [edx+APPOBJ.fd], ecx
404	mov [edx+APPOBJ.bk], eax	404	mov [edx+APPOBJ.bk], eax
405	mov [eax+APPOBJ.fd], edx	405	mov [eax+APPOBJ.fd], edx
406	mov [ecx+APPOBJ.bk], edx	406	mov [ecx+APPOBJ.bk], edx
407	or [edx+EVENT.state], EVENT_SIGNALED	407	or [edx+EVENT.state], EVENT_SIGNALED
408		408
409	inc [eax+APPDATA.ev_count-APP_EV_OFFSET]	409	inc [eax+APPDATA.ev_count-APP_EV_OFFSET]
410	or [eax+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED	410	or [eax+APPDATA.event_mask-APP_EV_OFFSET], EVENT_EXTENDED
411	popfd	411	popfd
412	.fail:	412	.fail:
413	.done:	413	.done:
414	add esp, 4	414	add esp, 4
415	ret	415	ret
416	restore .event	416	restore .event
417		417
418	; param	418	; param
419	; eax= event	419	; eax= event
420	; ebx= id	420	; ebx= id
421	align 4	421	align 4
422	clear_event:	422	clear_event:
423	.event equ esp	423	.event equ esp
424	push eax	424	push eax
425		425
426	cmp [eax+APPOBJ.magic], 'EVNT'	426	cmp [eax+APPOBJ.magic], 'EVNT'
427	jne .fail	427	jne .fail
428	cmp [eax+EVENT.id], ebx	428	cmp [eax+EVENT.id], ebx
429	jne .fail	429	jne .fail
430		430
431	mov eax, [eax+APPOBJ.pid]	431	mov eax, [eax+APPOBJ.pid]
432	call pid_to_slot	432	call pid_to_slot
433	test eax, eax	433	test eax, eax
434	jz .fail	434	jz .fail
435		435
436	shl eax, 8	436	shl eax, 8
437	add eax, SLOT_BASE+APP_EV_OFFSET	437	add eax, SLOT_BASE+APP_EV_OFFSET
438	mov edx, [.event]	438	mov edx, [.event]
439	pushfd	439	pushfd
440	cli ;remove event from events	440	cli ;remove event from events
441	mov ebx, [edx+APPOBJ.fd] ;list (reset event)	441	mov ebx, [edx+APPOBJ.fd] ;list (reset event)
442	mov ecx, [edx+APPOBJ.bk] ;and clear events flag	442	mov ecx, [edx+APPOBJ.bk] ;and clear events flag
443	mov [ebx+APPOBJ.bk], ecx ;if no active events	443	mov [ebx+APPOBJ.bk], ecx ;if no active events
444	mov [ecx+APPOBJ.fd], ebx	444	mov [ecx+APPOBJ.fd], ebx
445		445
446	and [edx+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)	446	and [edx+EVENT.state], not (EVENT_SIGNALED+EVENT_WATCHED)
447		447
448	dec [eax+APPDATA.ev_count-APP_EV_OFFSET]	448	dec [eax+APPDATA.ev_count-APP_EV_OFFSET]
449	jnz @F	449	jnz @F
450	and [eax+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED	450	and [eax+APPDATA.event_mask-APP_EV_OFFSET], not EVENT_EXTENDED
451	@@:	451	@@:
452	add eax, (APP_OBJ_OFFSET-APP_EV_OFFSET)	452	add eax, (APP_OBJ_OFFSET-APP_EV_OFFSET)
453		453
454	mov ecx, [eax+APPOBJ.fd] ;insert event into	454	mov ecx, [eax+APPOBJ.fd] ;insert event into
455	mov [edx+APPOBJ.fd], ecx ;objects list	455	mov [edx+APPOBJ.fd], ecx ;objects list
456	mov [edx+APPOBJ.bk], eax	456	mov [edx+APPOBJ.bk], eax
457	mov [eax+APPOBJ.fd], edx	457	mov [eax+APPOBJ.fd], edx
458	mov [ecx+APPOBJ.bk], edx	458	mov [ecx+APPOBJ.bk], edx
459	popfd	459	popfd
460	.fail:	460	.fail:
461	.done:	461	.done:
462	add esp, 4	462	add esp, 4
463	ret	463	ret
464	restore .event	464	restore .event
465		465
466	sys_getevent:	466	sys_getevent:
467		467
468	call get_event_for_app	468	call get_event_for_app
469	mov [esp+36],eax	469	mov [esp+36],eax
470	ret	470	ret
471		471
472		472
473	align 4	473	align 4
474	sys_wait_event_timeout:	474	sys_wait_event_timeout:
475		475
476	mov ebx,[timer_ticks]	476	mov ebx,[timer_ticks]
477	add ebx,eax	477	add ebx,eax
478	cmp ebx,[timer_ticks]	478	cmp ebx,[timer_ticks]
479	jna .swfet2	479	jna .swfet2
480	.swfet1:	480	.swfet1:
481	call get_event_for_app	481	call get_event_for_app
482	test eax,eax	482	test eax,eax
483	jne .eventoccur_time	483	jne .eventoccur_time
484	call change_task	484	call change_task
485	cmp ebx,[timer_ticks]	485	cmp ebx,[timer_ticks]
486	jg .swfet1	486	jg .swfet1
487	.swfet2:	487	.swfet2:
488	xor eax,eax	488	xor eax,eax
489	.eventoccur_time:	489	.eventoccur_time:
490	mov [esp+36],eax	490	mov [esp+36],eax
491	ret	491	ret
492		492
493		493
494	align 4	494	align 4
495		495
496	sys_waitforevent:	496	sys_waitforevent:
497		497
498	call get_event_for_app	498	call get_event_for_app
499	test eax,eax	499	test eax,eax
500	jne eventoccur	500	jne eventoccur

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/event.inc – Rev 465 → 473