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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; 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    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1391 $
 
uglobal
align 4
  event_start   dd ?
  event_end     dd ?
  event_uid     dd 0
endg
EV_SPACE   = 512
FreeEvents = event_start-EVENT.fd    ; "âèðòóàëüíûé" event, èñïîëüçóþòñÿ òîëüêî ïîëÿ:
                                     ;  FreeEvents.fd=event_start è FreeEvents.bk=event_end
align 4
init_events:                                       ;; used from kernel.asm
        stdcall kernel_alloc,EV_SPACE*EVENT.size
        or      eax,eax
        jz      .fail
      ; eax - current event, ebx - previos event below
        mov     ecx,EV_SPACE         ; current - in allocated space
        mov     ebx,FreeEvents       ; previos - íà÷àëî ñïèñêà
        push    ebx                  ; îíî æå è êîíåö ïîòîì áóäåò
  @@:   mov     [ebx+EVENT.fd],eax
        mov     [eax+EVENT.bk],ebx
        mov     ebx,eax              ; previos <- current
        add     eax,EVENT.size       ; new current
        loop    @b
        pop     eax                  ; âîò îíî êîíöîì è ñòàëî
        mov     [ebx+EVENT.fd],eax
        mov     [eax+EVENT.bk],ebx
.fail:  ret
 
EVENT_WATCHED    equ 0x10000000 ;áèò 28
EVENT_SIGNALED   equ 0x20000000 ;áèò 29
MANUAL_RESET     equ 0x40000000 ;áèò 30
MANUAL_DESTROY   equ 0x80000000 ;áèò 31
 
align 4
create_event:                                      ;; EXPORT use
;info:
;   Ïåðåíîñèì EVENT èç ñïèñêà FreeEvents â ñïèñîê ObjList òåêóùåãî ñëîòà
;   EVENT.state óñòàíàâëèâàåì èç ecx, EVENT.code êîñâåííî èç esi (åñëè esi<>0)
;param:
;   esi - event data
;   ecx - flags
;retval:
;   eax - event (=0 => fail)
;   edx - uid
;scratched: ebx,ecx,esi,edi
        mov     ebx,[current_slot]
        add     ebx,APP_OBJ_OFFSET
        mov     edx,[TASK_BASE]
        mov     edx,[edx+TASKDATA.pid]
        pushfd
        cli
 
set_event:                                         ;; INTERNAL use !!! don't use for Call
;info:
;   Áåðåì íîâûé event èç FreeEvents, çàïîëíÿåì åãî ïîëÿ, êàê óêàçàíî â ecx,edx,esi
;   è óñòàíàâëèâàåì â ñïèñîê, óêàçàííûé â ebx.
;   Âîçâðàùàåì ñàì event (â eax), è åãî uid (â edx)
;param:
;   ebx - start-chain "virtual" event for entry new event Right of him
;   ecx - flags      (copied to EVENT.state)
;   edx - pid        (copied to EVENT.pid)
;   esi - event data (copied to EVENT.code indirect, =0 => skip)
;retval:
;   eax - event (=0 => fail)
;   edx - uid
;scratched: ebx,ecx,esi,edi
        mov     eax,FreeEvents
        cmp     eax,[eax+EVENT.fd]
        jne     @f  ; not empty ???
        pushad
        call    init_events
        popad
        jz      RemoveEventTo.break ; POPF+RET
  @@:   mov     eax,[eax+EVENT.fd]
        mov     [eax+EVENT.magic],'EVNT'
        mov     [eax+EVENT.destroy],destroy_event.internal
        mov     [eax+EVENT.state],ecx
        mov     [eax+EVENT.pid],edx
        inc     [event_uid]
        Mov     [eax+EVENT.id],edx,[event_uid]
        or      esi,esi
        jz      RemoveEventTo
        lea     edi,[eax+EVENT.code]
        mov     ecx,EVENT.codesize/4
        cld
        rep     movsd
 
RemoveEventTo:                                     ;; INTERNAL use !!! don't use for Call
;param:
;   eax - óêàçàòåëü íà event, ÊÎÒÎÐÛÉ âñòàâëÿåì
;   ebx - óêàçàòåëü íà event, ÏÎÑËÅ êîòîðîãî âñòàâëÿåì
;scratched: ebx,ecx
        mov     ecx,eax              ; ecx=eax=Self,      ebx=NewLeft
        xchg    ecx,[ebx+EVENT.fd]   ; NewLeft.fd=Self,   ecx=NewRight
        cmp     eax,ecx              ; ñòîï, ñåáå äóìàþ...
        je      .break               ; - à íå äóðàê ëè ÿ?
        mov     [ecx+EVENT.bk],eax   ; NewRight.bk=Self
        xchg    ebx,[eax+EVENT.bk]   ; Self.bk=NewLeft,   ebx=OldLeft
        xchg    ecx,[eax+EVENT.fd]   ; Self.fd=NewRight,  ecx=OldRight
        mov     [ebx+EVENT.fd],ecx   ; OldLeft.fd=OldRight
        mov     [ecx+EVENT.bk],ebx   ; OldRight.bk=OldLeft
.break: popfd
        ret
 
align 4
NotDummyTest:                                      ;; INTERNAL use (not returned for fail !!!)
        pop     edi
        call    DummyTest ; not returned for fail !!!
        mov     ebx,eax
        mov     eax,[ebx+EVENT.pid]
        push    edi
.small: ; êðèâî êàê-òî...
        pop     edi
        pushfd
        cli
        call    pid_to_slot ; saved all registers (eax - retval)
        shl     eax,8
        jz      RemoveEventTo.break ; POPF+RET
        jmp     edi ; øòàòíûé âîçâðàò
 
align 4
raise_event:                                       ;; EXPORT use
;info:
;   Óñòàíàâëèâàåì äàííûå EVENT.code
;   Åñëè òàì ôëàã EVENT_SIGNALED óæå àêòèâåí - áîëüøå íè÷åãî
;   Èíà÷å: ýòîò ôëàã âçâîäèòñÿ, çà èñêëþ÷åíèåì ñëó÷àÿ íàëè÷èÿ ôëàãà EVENT_WATCHED â edx
;   Â ýòîì ñëó÷àå EVENT_SIGNALED âçâîäèòñÿ ëèøü ïðè íàëè÷èå EVENT_WATCHED â ñàìîì ñîáûòèè
;param:
;   eax - event
;   ebx - uid (for Dummy testing)
;   edx - flags
;   esi - event data (=0 => skip)
;scratched: ebx,ecx,esi,edi
        call    NotDummyTest ; not returned for fail !!!
        or      esi,esi
        jz      @f
        lea     edi,[ebx+EVENT.code]
        mov     ecx,EVENT.codesize/4
        cld
        rep     movsd
  @@:
        test    byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24
        jnz     RemoveEventTo.break  ; POPF+RET
        bt      edx, 28 ;EVENT_WATCHED
        jnc     @f
        test    byte[ebx+EVENT.state+3], EVENT_WATCHED  shr 24
        jz      RemoveEventTo.break  ; POPF+RET
  @@:
        or      byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24
        add     eax,SLOT_BASE+APP_EV_OFFSET
        xchg    eax,ebx
        jmp     RemoveEventTo
 
align 4
clear_event:                                       ;; EXPORT use
;info:
;
;param:
;   eax - event
;   ebx - uid (for Dummy testing)
;scratched: ebx,ecx
        call    NotDummyTest ; not returned for fail !!!
        add     eax,SLOT_BASE+APP_OBJ_OFFSET
        and     byte[ebx+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)
        xchg    eax,ebx
        jmp     RemoveEventTo
 
align 4
send_event:                                        ;; EXPORT use
;info:
;   Ñîçäàåò íîâûé EVENT (âûòàñêèâàåò èç ñïèñêà FreeEvents) â ñïèñêå EventList
;   öåëåâîãî ñëîòà (eax=pid), ñ äàííûìè èç esi êîñâåííî, è state=EVENT_SIGNALED
;param:
;   eax - slots pid, to sending new event
;   esi - pointer to sending data (in code field of new event)
;retval:
;   eax - event (=0 => fail)
;   edx - uid
;warning:
;   may be used as CDECL with such prefix...
;       mov     esi,[esp+8]
;       mov     eax,[esp+4]
;   but not as STDCALL :(
;scratched: ebx,ecx,esi,edi
        mov     edx,eax
        call    NotDummyTest.small ; not returned for fail !!!
        lea     ebx,[eax+SLOT_BASE+APP_EV_OFFSET]
        mov     ecx,EVENT_SIGNALED
        jmp     set_event
 
align 4
DummyTest:                                         ;; INTERNAL use (not returned for fail !!!)
;param:
;   eax - event
;   ebx - uid (for Dummy testing)
        cmp     [eax+EVENT.magic],'EVNT'
        jne     @f
        cmp     [eax+EVENT.id],ebx
        je      .ret
  @@:   pop     eax
        xor     eax,eax
.ret:   ret
 
 
align 4
Wait_events:
        or      ebx,-1 ; infinite timeout
Wait_events_ex:
;info:
;   Îæèäàíèå "àáñòðàêòíîãî" ñîáûòèÿ ÷åðåç ïåðåâîä ñëîòà â 5-þ ïîçèöèþ.
;   Àáñòðàêòíîñòü çàêëþ÷åíà â òîì, ÷òî ôàêò ñîáûòèÿ îïðåäåëÿåòñÿ ôóíêöèåé APPDATA.wait_test,
;   êîòîðàÿ çàäàåòñÿ êëèåíòîì è ìîæåò áûòü ôàêòè÷åñêè ëþáîé.
;   Ýòî ïîçâîëÿåò shed-ó íàäåæíî îïðåäåëèòü ôàêò ñîáûòèÿ, è íå ñîâåðøàòü "õîëîñòûõ" ïåðåêëþ÷åíèé,
;   ïðåäíàçíà÷åííûõ äëÿ ðàçáîðîê òèïà "ñâîé/÷óæîé" âíóòðè çàäà÷è.
;param:
;   edx - wait_test, êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ (àäðåñ êîäà)
;   ecx - wait_param, äîïîëíèòåëüíûé ïàðàìåòð, âîçìîæíî íåîáõîäèìûé äëÿ [wait_test]
;   ebx - wait_timeout
;retval:
;   eax - ðåçóëüòàò âûçîâà [wait_test] (=0 => timeout)
;scratched: esi
        mov     esi,[current_slot]
        mov     [esi+APPDATA.wait_param],ecx
        pushad
        mov     ebx,esi;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........
        pushfd  ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò
        cli     ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed
        call    edx
        popfd
        mov     [esp+28],eax
        popad
        or      eax,eax
        jnz     @f   ;RET
        mov     [esi+APPDATA.wait_test],edx
        mov     [esi+APPDATA.wait_timeout],ebx
        Mov     [esi+APPDATA.wait_begin],eax,[timer_ticks]
        mov     eax,[TASK_BASE]
        mov     [eax+TASKDATA.state], 5
        call    change_task
        mov     eax,[esi+APPDATA.wait_param]
  @@:   ret
 
align 4
wait_event:                                        ;; EXPORT use
;info:
;   Îæèäàíèå ôëàãà EVENT_SIGNALED â ñîâåðøåííî êîíêðåòíîì Event
;   (óñòàíàâëèâàåìîãî, íàäî ïîëàãàòü, ÷åðåç raise_event)
;   Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî
;   Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,
;   è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,
;   à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)
;param:
;   eax - event
;   ebx - uid (for Dummy testing)
;scratched: ecx,edx,esi
        call    DummyTest
        mov     ecx,eax              ; wait_param
        mov     edx, get_event_alone ; wait_test
        call    Wait_events          ; timeout ignored
        jmp     wait_finish
 
align 4
get_event_ex:                                      ;; f68:14
;info:
;   Îæèäàíèå ëþáîãî ñîáûòèÿ â î÷åðåäè EventList òåêóùåãî ñëîòà
;   Äàííûå ñîáûòèÿ code - êîïèðóþòñÿ â ïàìÿòü ïðèëîæåíèÿ (êîñâåííî ïî edi)
;   Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî
;   Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,
;   è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,
;   à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)
;param:
;   edi - àäðåñ â êîäå ïðèëîæåíèÿ äëÿ êîïèðîâàíèÿ äàííûõ èç EVENT.code
;retval:
;   eax - ñîáñòâåííî EVENT (áóäåì íàçûâàòü ýòî åãî õýíäëîì)
;scratched: ebx,ecx,edx,esi,edi
        mov     edx, get_event_queue ; wait_test
        call    Wait_events          ; timeout ignored
        lea     esi,[eax+EVENT.code]
        mov     ecx,EVENT.codesize/4
        cld
        rep     movsd
        mov     [edi-EVENT.codesize+2],cl ;clear priority field
wait_finish:
        test    byte[eax+EVENT.state+3], MANUAL_RESET shr 24
        jnz     get_event_queue.ret  ; RET
        and     byte[eax+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)
        test    byte[eax+EVENT.state+3], MANUAL_DESTROY shr 24
        jz      destroy_event.internal
        mov     ebx,[current_slot]
        add     ebx,APP_OBJ_OFFSET
        pushfd
        cli
        jmp     RemoveEventTo
 
align 4
destroy_event:                                     ;; EXPORT use
;info:
;   Ïåðåíîñèì EVENT â ñïèñîê FreeEvents, ÷èñòèì ïîëÿ magic,destroy,pid,id
;param:
;   eax - event
;   ebx - uid (for Dummy testing)
;retval:
;   eax - àäðåñ îáúåêòà EVENT (=0 => fail)
;scratched: ebx,ecx
        call    DummyTest ; not returned for fail !!!
.internal:
        xor     ecx,ecx   ; clear common header
        pushfd
        cli
        mov     [eax+EVENT.magic],ecx
        mov     [eax+EVENT.destroy],ecx
        mov     [eax+EVENT.pid],ecx
        mov     [eax+EVENT.id],ecx
        mov     ebx,FreeEvents
        jmp     RemoveEventTo
 
align 4
get_event_queue:
;info:
;   êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ get_event_ex
;warning:
;  -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
;  -may be assumed, that interrupt are disabled
;  -it is not restriction for scratched registers
;param:
;   ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
;retval:
;   eax - àäðåñ îáúåêòà EVENT (=0 => fail)
        add     ebx,APP_EV_OFFSET
        mov     eax,[ebx+APPOBJ.bk]  ; âûáèðàåì ñ êîíöà, ïî ïðèíöèïó FIFO
        cmp     eax,ebx  ; empty ???
        je      get_event_alone.ret0
.ret:   ret
 
align 4
get_event_alone:
;info:
;   êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ wait_event
;warning:
;  -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
;  -may be assumed, that interrupt are disabled
;  -it is not restriction for scratched registers
;param:
;   ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
;retval:
;   eax - àäðåñ îáúåêòà EVENT (=0 => fail)
        mov     eax,[ebx+APPDATA.wait_param]
        test    byte[eax+EVENT.state+3], EVENT_SIGNALED shr 24
        jnz     .ret
        or      byte[eax+EVENT.state+3], EVENT_WATCHED shr 24
.ret0:  xor     eax,eax ; NO event!!!
.ret:   ret
 
align 4
sys_sendwindowmsg:                                 ;; f72
        dec     ebx
        jnz     .ret ;subfunction==1 ?
       ;pushfd  ;à íàôèãà?
        cli
        sub     ecx,2
        je      .sendkey
        dec     ecx
        jnz     .retf
.sendbtn:
        cmp     byte[BTN_COUNT],1
        jae     .result ;overflow
        inc     byte[BTN_COUNT]
        shl     edx, 8
        mov     [BTN_BUFF],edx
        jmp     .result
.sendkey:
        movzx   eax,byte[KEY_COUNT]
        cmp     al,120
        jae     .result ;overflow
        inc     byte[KEY_COUNT]
        mov     [KEY_COUNT+1+eax],dl
.result:
        setae   byte[esp+32] ;ñ÷èòàåì, ÷òî èñõîäíî: dword[esp+32]==72
.retf: ;popfd
.ret:   ret
 
align 4
sys_getevent:                                      ;; f11
        mov     ebx,[current_slot] ;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........
        pushfd  ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò
        cli     ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed
        call    get_event_for_app
        popfd
        mov     [esp+32],eax
        ret
 
align 4
sys_waitforevent:                                  ;; f10
        or      ebx,-1 ; infinite timeout
sys_wait_event_timeout:                            ;; f23
        mov     edx,get_event_for_app ; wait_test
        call    Wait_events_ex        ; ebx - timeout
        mov     [esp+32],eax
        ret
 
align 4
get_event_for_app:                                 ;; used from f10,f11,f23
;info:
;   êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ ïðèëîæåíèé (f10,f23)
;warning:
;  -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
;  -may be assumed, that interrupt are disabled
;  -it is not restriction for scratched registers
;param:
;   ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
;retval:
;   eax - íîìåð ñîáûòèÿ (=0 => no events)
        movzx   edi,bh                ; bh  is assumed as [CURRENT_TASK]
        shl     edi,5
        add     edi,CURRENT_TASK      ; edi is assumed as [TASK_BASE]
        mov     ecx,[edi+TASKDATA.event_mask]
.loop: ; ïîêà íå èñ÷åðïàåì âñå áèòû ìàñêè
        bsr     eax,ecx        ; íàõîäèì íåíóëåâîé áèò ìàñêè (31 -> 0)
        jz      .no_events     ; èñ÷åðïàëè âñå áèòû ìàñêè, íî íè÷åãî íå íàøëè ???
        btr     ecx,eax        ; ñáðàñûâàåì ïðîâåðÿåìûé áèò ìàñêè
       ; ïåðåõîäèì íà îáðàáîò÷èê ýòîãî (eax) áèòà
        cmp     eax,16
        jae     .IRQ           ; eax=[16..31]=retvals, events irq0..irq15
        cmp     eax,9
        jae     .loop          ; eax=[9..15], ignored
        cmp     eax,3
        je      .loop          ; eax=3, ignored
        ja      .FlagAutoReset ; eax=[4..8], retvals=eax+1
        cmp     eax,1
        jae     .BtKy          ; eax=[1,2],  retvals=eax+1
.WndRedraw:                    ; eax=0, retval WndRedraw=1
        cmp     [edi-twdw+WDATA.fl_redraw],al ;al==0
        jne     .result
        jmp     .loop
  .no_events:
        xor     eax,eax
        ret
.IRQ:
;TODO: ñäåëàòü òàê æå, êàê è äëÿ FlagAutoReset (BgrRedraw,Mouse,IPC,Stack,Debug)
        mov     edx,[irq_owner+eax*4-64] ; eax==16+irq
        cmp     edx,[edi+TASKDATA.pid]
        jne     .loop
        mov     edx,eax
        shl     edx,12
        cmp     dword[IRQ_SAVE+edx-0x10000],0 ; edx==(16+irq)*0x1000
        je      .loop          ; empty ???
        ret     ; retval = eax
.FlagAutoReset: ; retvals: BgrRedraw=5, Mouse=6, IPC=7, Stack=8, Debug=9
        btr     [ebx+APPDATA.event_mask],eax
        jnc     .loop
  .result:      ; retval = eax+1
        inc     eax
        ret
  .BtKy:
        movzx   edx,bh
        movzx   edx, word[WIN_STACK+edx*2]
        je      .Keys          ; eax=1, retval Keys=2
.Buttons:                      ; eax=2, retval Buttons=3
        cmp     byte[BTN_COUNT],0
        je      .loop          ; empty ???
        cmp     edx,[TASK_COUNT]
        jne     .loop          ; not Top ???
        mov     edx, [BTN_BUFF]
        shr     edx, 8
        cmp     edx, 0xFFFF    ;-ID for Minimize-Button of Form
        jne     .result
        mov     [window_minimize],1
        dec     byte[BTN_COUNT]
        jmp     .loop
.Keys:    ; eax==1
        cmp     edx,[TASK_COUNT]
        jne     @f             ; not Top ???
        cmp     [KEY_COUNT],al ; al==1
        jae     .result        ; not empty ???
  @@:   mov     edx, hotkey_buffer
  @@:   cmp     [edx],bh       ; bh - slot for testing
        je      .result
        add     edx,8
        cmp     edx, hotkey_buffer+120*8
        jb      @b
        jmp     .loop
;end.

Rev 1067	Rev 1391
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4	;; 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	$Revision: 1067 $	8	$Revision: 1391 $
9		9
10	uglobal	10	uglobal
11	align 4	11	align 4
12	event_start dd ?	12	event_start dd ?
13	event_end dd ?	13	event_end dd ?
14	event_uid dd 0	14	event_uid dd 0
15	endg	15	endg
16	EV_SPACE = 512	16	EV_SPACE = 512
17	FreeEvents = event_start-EVENT.fd ; "âèðòóàëüíûé" event, èñïîëüçóþòñÿ òîëüêî ïîëÿ:	17	FreeEvents = event_start-EVENT.fd ; "âèðòóàëüíûé" event, èñïîëüçóþòñÿ òîëüêî ïîëÿ:
18	; FreeEvents.fd=event_start è FreeEvents.bk=event_end	18	; FreeEvents.fd=event_start è FreeEvents.bk=event_end
19	align 4	19	align 4
20	init_events: ;; used from kernel.asm	20	init_events: ;; used from kernel.asm
21	stdcall kernel_alloc,EV_SPACE*EVENT.size	21	stdcall kernel_alloc,EV_SPACE*EVENT.size
22	or eax,eax	22	or eax,eax
23	jz .fail	23	jz .fail
24	; eax - current event, ebx - previos event below	24	; eax - current event, ebx - previos event below
25	mov ecx,EV_SPACE ; current - in allocated space	25	mov ecx,EV_SPACE ; current - in allocated space
26	mov ebx,FreeEvents ; previos - íà÷àëî ñïèñêà	26	mov ebx,FreeEvents ; previos - íà÷àëî ñïèñêà
27	push ebx ; îíî æå è êîíåö ïîòîì áóäåò	27	push ebx ; îíî æå è êîíåö ïîòîì áóäåò
28	@@: mov [ebx+EVENT.fd],eax	28	@@: mov [ebx+EVENT.fd],eax
29	mov [eax+EVENT.bk],ebx	29	mov [eax+EVENT.bk],ebx
30	mov ebx,eax ; previos <- current	30	mov ebx,eax ; previos <- current
31	add eax,EVENT.size ; new current	31	add eax,EVENT.size ; new current
32	loop @b	32	loop @b
33	pop eax ; âîò îíî êîíöîì è ñòàëî	33	pop eax ; âîò îíî êîíöîì è ñòàëî
34	mov [ebx+EVENT.fd],eax	34	mov [ebx+EVENT.fd],eax
35	mov [eax+EVENT.bk],ebx	35	mov [eax+EVENT.bk],ebx
36	.fail: ret	36	.fail: ret
37		37
38	EVENT_WATCHED equ 0x10000000 ;áèò 28	38	EVENT_WATCHED equ 0x10000000 ;áèò 28
39	EVENT_SIGNALED equ 0x20000000 ;áèò 29	39	EVENT_SIGNALED equ 0x20000000 ;áèò 29
40	MANUAL_RESET equ 0x40000000 ;áèò 30	40	MANUAL_RESET equ 0x40000000 ;áèò 30
41	MANUAL_DESTROY equ 0x80000000 ;áèò 31	41	MANUAL_DESTROY equ 0x80000000 ;áèò 31
42		42
43	align 4	43	align 4
44	create_event: ;; EXPORT use	44	create_event: ;; EXPORT use
45	;info:	45	;info:
46	; Ïåðåíîñèì EVENT èç ñïèñêà FreeEvents â ñïèñîê ObjList òåêóùåãî ñëîòà	46	; Ïåðåíîñèì EVENT èç ñïèñêà FreeEvents â ñïèñîê ObjList òåêóùåãî ñëîòà
47	; EVENT.state óñòàíàâëèâàåì èç ecx, EVENT.code êîñâåííî èç esi (åñëè esi<>0)	47	; EVENT.state óñòàíàâëèâàåì èç ecx, EVENT.code êîñâåííî èç esi (åñëè esi<>0)
48	;param:	48	;param:
49	; esi - event data	49	; esi - event data
50	; ecx - flags	50	; ecx - flags
51	;retval:	51	;retval:
52	; eax - event (=0 => fail)	52	; eax - event (=0 => fail)
53	; edx - uid	53	; edx - uid
54	;scratched: ebx,ecx,esi,edi	54	;scratched: ebx,ecx,esi,edi
55	mov ebx,[current_slot]	55	mov ebx,[current_slot]
56	add ebx,APP_OBJ_OFFSET	56	add ebx,APP_OBJ_OFFSET
57	mov edx,[TASK_BASE]	57	mov edx,[TASK_BASE]
58	mov edx,[edx+TASKDATA.pid]	58	mov edx,[edx+TASKDATA.pid]
59	pushfd	59	pushfd
60	cli	60	cli
61		61
62	set_event: ;; INTERNAL use !!! don't use for Call	62	set_event: ;; INTERNAL use !!! don't use for Call
63	;info:	63	;info:
64	; Áåðåì íîâûé event èç FreeEvents, çàïîëíÿåì åãî ïîëÿ, êàê óêàçàíî â ecx,edx,esi	64	; Áåðåì íîâûé event èç FreeEvents, çàïîëíÿåì åãî ïîëÿ, êàê óêàçàíî â ecx,edx,esi
65	; è óñòàíàâëèâàåì â ñïèñîê, óêàçàííûé â ebx.	65	; è óñòàíàâëèâàåì â ñïèñîê, óêàçàííûé â ebx.
66	; Âîçâðàùàåì ñàì event (â eax), è åãî uid (â edx)	66	; Âîçâðàùàåì ñàì event (â eax), è åãî uid (â edx)
67	;param:	67	;param:
68	; ebx - start-chain "virtual" event for entry new event Right of him	68	; ebx - start-chain "virtual" event for entry new event Right of him
69	; ecx - flags (copied to EVENT.state)	69	; ecx - flags (copied to EVENT.state)
70	; edx - pid (copied to EVENT.pid)	70	; edx - pid (copied to EVENT.pid)
71	; esi - event data (copied to EVENT.code indirect, =0 => skip)	71	; esi - event data (copied to EVENT.code indirect, =0 => skip)
72	;retval:	72	;retval:
73	; eax - event (=0 => fail)	73	; eax - event (=0 => fail)
74	; edx - uid	74	; edx - uid
75	;scratched: ebx,ecx,esi,edi	75	;scratched: ebx,ecx,esi,edi
76	mov eax,FreeEvents	76	mov eax,FreeEvents
77	cmp eax,[eax+EVENT.fd]	77	cmp eax,[eax+EVENT.fd]
78	jne @f ; not empty ???	78	jne @f ; not empty ???
79	pushad	79	pushad
80	call init_events	80	call init_events
81	popad	81	popad
82	jz RemoveEventTo.break ; POPF+RET	82	jz RemoveEventTo.break ; POPF+RET
83	@@: mov eax,[eax+EVENT.fd]	83	@@: mov eax,[eax+EVENT.fd]
84	mov [eax+EVENT.magic],'EVNT'	84	mov [eax+EVENT.magic],'EVNT'
85	mov [eax+EVENT.destroy],destroy_event.internal	85	mov [eax+EVENT.destroy],destroy_event.internal
86	mov [eax+EVENT.state],ecx	86	mov [eax+EVENT.state],ecx
87	mov [eax+EVENT.pid],edx	87	mov [eax+EVENT.pid],edx
88	inc [event_uid]	88	inc [event_uid]
89	Mov [eax+EVENT.id],edx,[event_uid]	89	Mov [eax+EVENT.id],edx,[event_uid]
90	or esi,esi	90	or esi,esi
91	jz RemoveEventTo	91	jz RemoveEventTo
92	lea edi,[eax+EVENT.code]	92	lea edi,[eax+EVENT.code]
93	mov ecx,EVENT.codesize/4	93	mov ecx,EVENT.codesize/4
94	cld	94	cld
95	rep movsd	95	rep movsd
96		96
97	RemoveEventTo: ;; INTERNAL use !!! don't use for Call	97	RemoveEventTo: ;; INTERNAL use !!! don't use for Call
98	;param:	98	;param:
99	; eax - óêàçàòåëü íà event, ÊÎÒÎÐÛÉ âñòàâëÿåì	99	; eax - óêàçàòåëü íà event, ÊÎÒÎÐÛÉ âñòàâëÿåì
100	; ebx - óêàçàòåëü íà event, ÏÎÑËÅ êîòîðîãî âñòàâëÿåì	100	; ebx - óêàçàòåëü íà event, ÏÎÑËÅ êîòîðîãî âñòàâëÿåì
101	;scratched: ebx,ecx	101	;scratched: ebx,ecx
102	mov ecx,eax ; ecx=eax=Self, ebx=NewLeft	102	mov ecx,eax ; ecx=eax=Self, ebx=NewLeft
103	xchg ecx,[ebx+EVENT.fd] ; NewLeft.fd=Self, ecx=NewRight	103	xchg ecx,[ebx+EVENT.fd] ; NewLeft.fd=Self, ecx=NewRight
104	cmp eax,ecx ; ñòîï, ñåáå äóìàþ...	104	cmp eax,ecx ; ñòîï, ñåáå äóìàþ...
105	je .break ; - à íå äóðàê ëè ÿ?	105	je .break ; - à íå äóðàê ëè ÿ?
106	mov [ecx+EVENT.bk],eax ; NewRight.bk=Self	106	mov [ecx+EVENT.bk],eax ; NewRight.bk=Self
107	xchg ebx,[eax+EVENT.bk] ; Self.bk=NewLeft, ebx=OldLeft	107	xchg ebx,[eax+EVENT.bk] ; Self.bk=NewLeft, ebx=OldLeft
108	xchg ecx,[eax+EVENT.fd] ; Self.fd=NewRight, ecx=OldRight	108	xchg ecx,[eax+EVENT.fd] ; Self.fd=NewRight, ecx=OldRight
109	mov [ebx+EVENT.fd],ecx ; OldLeft.fd=OldRight	109	mov [ebx+EVENT.fd],ecx ; OldLeft.fd=OldRight
110	mov [ecx+EVENT.bk],ebx ; OldRight.bk=OldLeft	110	mov [ecx+EVENT.bk],ebx ; OldRight.bk=OldLeft
111	.break: popfd	111	.break: popfd
112	ret	112	ret
113		113
114	align 4	114	align 4
115	NotDummyTest: ;; INTERNAL use (not returned for fail !!!)	115	NotDummyTest: ;; INTERNAL use (not returned for fail !!!)
116	pop edi	116	pop edi
117	call DummyTest ; not returned for fail !!!	117	call DummyTest ; not returned for fail !!!
118	mov ebx,eax	118	mov ebx,eax
119	mov eax,[ebx+EVENT.pid]	119	mov eax,[ebx+EVENT.pid]
120	push edi	120	push edi
121	.small: ; êðèâî êàê-òî...	121	.small: ; êðèâî êàê-òî...
122	pop edi	122	pop edi
123	pushfd	123	pushfd
124	cli	124	cli
125	call pid_to_slot ; saved all registers (eax - retval)	125	call pid_to_slot ; saved all registers (eax - retval)
126	shl eax,8	126	shl eax,8
127	jz RemoveEventTo.break ; POPF+RET	127	jz RemoveEventTo.break ; POPF+RET
128	jmp edi ; øòàòíûé âîçâðàò	128	jmp edi ; øòàòíûé âîçâðàò
129		129
130	align 4	130	align 4
131	raise_event: ;; EXPORT use	131	raise_event: ;; EXPORT use
132	;info:	132	;info:
133	; Óñòàíàâëèâàåì äàííûå EVENT.code	133	; Óñòàíàâëèâàåì äàííûå EVENT.code
134	; Åñëè òàì ôëàã EVENT_SIGNALED óæå àêòèâåí - áîëüøå íè÷åãî	134	; Åñëè òàì ôëàã EVENT_SIGNALED óæå àêòèâåí - áîëüøå íè÷åãî
135	; Èíà÷å: ýòîò ôëàã âçâîäèòñÿ, çà èñêëþ÷åíèåì ñëó÷àÿ íàëè÷èÿ ôëàãà EVENT_WATCHED â edx	135	; Èíà÷å: ýòîò ôëàã âçâîäèòñÿ, çà èñêëþ÷åíèåì ñëó÷àÿ íàëè÷èÿ ôëàãà EVENT_WATCHED â edx
136	; Â ýòîì ñëó÷àå EVENT_SIGNALED âçâîäèòñÿ ëèøü ïðè íàëè÷èå EVENT_WATCHED â ñàìîì ñîáûòèè	136	; Â ýòîì ñëó÷àå EVENT_SIGNALED âçâîäèòñÿ ëèøü ïðè íàëè÷èå EVENT_WATCHED â ñàìîì ñîáûòèè
137	;param:	137	;param:
138	; eax - event	138	; eax - event
139	; ebx - uid (for Dummy testing)	139	; ebx - uid (for Dummy testing)
140	; edx - flags	140	; edx - flags
141	; esi - event data (=0 => skip)	141	; esi - event data (=0 => skip)
142	;scratched: ebx,ecx,esi,edi	142	;scratched: ebx,ecx,esi,edi
143	call NotDummyTest ; not returned for fail !!!	143	call NotDummyTest ; not returned for fail !!!
144	or esi,esi	144	or esi,esi
145	jz @f	145	jz @f
146	lea edi,[ebx+EVENT.code]	146	lea edi,[ebx+EVENT.code]
147	mov ecx,EVENT.codesize/4	147	mov ecx,EVENT.codesize/4
148	cld	148	cld
149	rep movsd	149	rep movsd
150	@@:	150	@@:
151	test byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24	151	test byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24
152	jnz RemoveEventTo.break ; POPF+RET	152	jnz RemoveEventTo.break ; POPF+RET
153	bt edx, 28 ;EVENT_WATCHED	153	bt edx, 28 ;EVENT_WATCHED
154	jnc @f	154	jnc @f
155	test byte[ebx+EVENT.state+3], EVENT_WATCHED shr 24	155	test byte[ebx+EVENT.state+3], EVENT_WATCHED shr 24
156	jz RemoveEventTo.break ; POPF+RET	156	jz RemoveEventTo.break ; POPF+RET
157	@@:	157	@@:
158	or byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24	158	or byte[ebx+EVENT.state+3], EVENT_SIGNALED shr 24
159	add eax,SLOT_BASE+APP_EV_OFFSET	159	add eax,SLOT_BASE+APP_EV_OFFSET
160	xchg eax,ebx	160	xchg eax,ebx
161	jmp RemoveEventTo	161	jmp RemoveEventTo
162		162
163	align 4	163	align 4
164	clear_event: ;; EXPORT use	164	clear_event: ;; EXPORT use
165	;info:	165	;info:
166	;	166	;
167	;param:	167	;param:
168	; eax - event	168	; eax - event
169	; ebx - uid (for Dummy testing)	169	; ebx - uid (for Dummy testing)
170	;scratched: ebx,ecx	170	;scratched: ebx,ecx
171	call NotDummyTest ; not returned for fail !!!	171	call NotDummyTest ; not returned for fail !!!
172	add eax,SLOT_BASE+APP_OBJ_OFFSET	172	add eax,SLOT_BASE+APP_OBJ_OFFSET
173	and byte[ebx+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)	173	and byte[ebx+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)
174	xchg eax,ebx	174	xchg eax,ebx
175	jmp RemoveEventTo	175	jmp RemoveEventTo
176		176
177	align 4	177	align 4
178	send_event: ;; EXPORT use	178	send_event: ;; EXPORT use
179	;info:	179	;info:
180	; Ñîçäàåò íîâûé EVENT (âûòàñêèâàåò èç ñïèñêà FreeEvents) â ñïèñêå EventList	180	; Ñîçäàåò íîâûé EVENT (âûòàñêèâàåò èç ñïèñêà FreeEvents) â ñïèñêå EventList
181	; öåëåâîãî ñëîòà (eax=pid), ñ äàííûìè èç esi êîñâåííî, è state=EVENT_SIGNALED	181	; öåëåâîãî ñëîòà (eax=pid), ñ äàííûìè èç esi êîñâåííî, è state=EVENT_SIGNALED
182	;param:	182	;param:
183	; eax - slots pid, to sending new event	183	; eax - slots pid, to sending new event
184	; esi - pointer to sending data (in code field of new event)	184	; esi - pointer to sending data (in code field of new event)
185	;retval:	185	;retval:
186	; eax - event (=0 => fail)	186	; eax - event (=0 => fail)
187	; edx - uid	187	; edx - uid
188	;warning:	188	;warning:
189	; may be used as CDECL with such prefix...	189	; may be used as CDECL with such prefix...
190	; mov esi,[esp+8]	190	; mov esi,[esp+8]
191	; mov eax,[esp+4]	191	; mov eax,[esp+4]
192	; but not as STDCALL :(	192	; but not as STDCALL :(
193	;scratched: ebx,ecx,esi,edi	193	;scratched: ebx,ecx,esi,edi
194	mov edx,eax	194	mov edx,eax
195	call NotDummyTest.small ; not returned for fail !!!	195	call NotDummyTest.small ; not returned for fail !!!
196	lea ebx,[eax+SLOT_BASE+APP_EV_OFFSET]	196	lea ebx,[eax+SLOT_BASE+APP_EV_OFFSET]
197	mov ecx,EVENT_SIGNALED	197	mov ecx,EVENT_SIGNALED
198	jmp set_event	198	jmp set_event
199		199
200	align 4	200	align 4
201	DummyTest: ;; INTERNAL use (not returned for fail !!!)	201	DummyTest: ;; INTERNAL use (not returned for fail !!!)
202	;param:	202	;param:
203	; eax - event	203	; eax - event
204	; ebx - uid (for Dummy testing)	204	; ebx - uid (for Dummy testing)
205	cmp [eax+EVENT.magic],'EVNT'	205	cmp [eax+EVENT.magic],'EVNT'
206	jne @f	206	jne @f
207	cmp [eax+EVENT.id],ebx	207	cmp [eax+EVENT.id],ebx
208	je .ret	208	je .ret
209	@@: pop eax	209	@@: pop eax
210	xor eax,eax	210	xor eax,eax
211	.ret: ret	211	.ret: ret
212		212
213		213
214	align 4	214	align 4
215	Wait_events:	215	Wait_events:
216	or ebx,-1 ; infinite timeout	216	or ebx,-1 ; infinite timeout
217	Wait_events_ex:	217	Wait_events_ex:
218	;info:	218	;info:
219	; Îæèäàíèå "àáñòðàêòíîãî" ñîáûòèÿ ÷åðåç ïåðåâîä ñëîòà â 5-þ ïîçèöèþ.	219	; Îæèäàíèå "àáñòðàêòíîãî" ñîáûòèÿ ÷åðåç ïåðåâîä ñëîòà â 5-þ ïîçèöèþ.
220	; Àáñòðàêòíîñòü çàêëþ÷åíà â òîì, ÷òî ôàêò ñîáûòèÿ îïðåäåëÿåòñÿ ôóíêöèåé APPDATA.wait_test,	220	; Àáñòðàêòíîñòü çàêëþ÷åíà â òîì, ÷òî ôàêò ñîáûòèÿ îïðåäåëÿåòñÿ ôóíêöèåé APPDATA.wait_test,
221	; êîòîðàÿ çàäàåòñÿ êëèåíòîì è ìîæåò áûòü ôàêòè÷åñêè ëþáîé.	221	; êîòîðàÿ çàäàåòñÿ êëèåíòîì è ìîæåò áûòü ôàêòè÷åñêè ëþáîé.
222	; Ýòî ïîçâîëÿåò shed-ó íàäåæíî îïðåäåëèòü ôàêò ñîáûòèÿ, è íå ñîâåðøàòü "õîëîñòûõ" ïåðåêëþ÷åíèé,	222	; Ýòî ïîçâîëÿåò shed-ó íàäåæíî îïðåäåëèòü ôàêò ñîáûòèÿ, è íå ñîâåðøàòü "õîëîñòûõ" ïåðåêëþ÷åíèé,
223	; ïðåäíàçíà÷åííûõ äëÿ ðàçáîðîê òèïà "ñâîé/÷óæîé" âíóòðè çàäà÷è.	223	; ïðåäíàçíà÷åííûõ äëÿ ðàçáîðîê òèïà "ñâîé/÷óæîé" âíóòðè çàäà÷è.
224	;param:	224	;param:
225	; edx - wait_test, êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ (àäðåñ êîäà)	225	; edx - wait_test, êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ (àäðåñ êîäà)
226	; ecx - wait_param, äîïîëíèòåëüíûé ïàðàìåòð, âîçìîæíî íåîáõîäèìûé äëÿ [wait_test]	226	; ecx - wait_param, äîïîëíèòåëüíûé ïàðàìåòð, âîçìîæíî íåîáõîäèìûé äëÿ [wait_test]
227	; ebx - wait_timeout	227	; ebx - wait_timeout
228	;retval:	228	;retval:
229	; eax - ðåçóëüòàò âûçîâà [wait_test] (=0 => timeout)	229	; eax - ðåçóëüòàò âûçîâà [wait_test] (=0 => timeout)
230	;scratched: esi	230	;scratched: esi
231	mov esi,[current_slot]	231	mov esi,[current_slot]
232	mov [esi+APPDATA.wait_param],ecx	232	mov [esi+APPDATA.wait_param],ecx
233	pushad	233	pushad
234	mov ebx,esi;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........	234	mov ebx,esi;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........
235	pushfd ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò	235	pushfd ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò
236	cli ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed	236	cli ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed
237	call edx	237	call edx
238	popfd	238	popfd
239	mov [esp+28],eax	239	mov [esp+28],eax
240	popad	240	popad
241	or eax,eax	241	or eax,eax
242	jnz @f ;RET	242	jnz @f ;RET
243	mov [esi+APPDATA.wait_test],edx	243	mov [esi+APPDATA.wait_test],edx
244	mov [esi+APPDATA.wait_timeout],ebx	244	mov [esi+APPDATA.wait_timeout],ebx
245	Mov [esi+APPDATA.wait_begin],eax,[timer_ticks]	245	Mov [esi+APPDATA.wait_begin],eax,[timer_ticks]
246	mov eax,[TASK_BASE]	246	mov eax,[TASK_BASE]
247	mov [eax+TASKDATA.state], 5	247	mov [eax+TASKDATA.state], 5
248	call change_task	248	call change_task
249	mov eax,[esi+APPDATA.wait_param]	249	mov eax,[esi+APPDATA.wait_param]
250	@@: ret	250	@@: ret
251		251
252	align 4	252	align 4
253	wait_event: ;; EXPORT use	253	wait_event: ;; EXPORT use
254	;info:	254	;info:
255	; Îæèäàíèå ôëàãà EVENT_SIGNALED â ñîâåðøåííî êîíêðåòíîì Event	255	; Îæèäàíèå ôëàãà EVENT_SIGNALED â ñîâåðøåííî êîíêðåòíîì Event
256	; (óñòàíàâëèâàåìîãî, íàäî ïîëàãàòü, ÷åðåç raise_event)	256	; (óñòàíàâëèâàåìîãî, íàäî ïîëàãàòü, ÷åðåç raise_event)
257	; Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî	257	; Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî
258	; Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,	258	; Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,
259	; è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,	259	; è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,
260	; à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)	260	; à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)
261	;param:	261	;param:
262	; eax - event	262	; eax - event
263	; ebx - uid (for Dummy testing)	263	; ebx - uid (for Dummy testing)
264	;scratched: ecx,edx,esi	264	;scratched: ecx,edx,esi
265	call DummyTest	265	call DummyTest
266	mov ecx,eax ; wait_param	266	mov ecx,eax ; wait_param
267	mov edx, get_event_alone ; wait_test	267	mov edx, get_event_alone ; wait_test
268	call Wait_events ; timeout ignored	268	call Wait_events ; timeout ignored
269	jmp wait_finish	269	jmp wait_finish
270		270
271	align 4	271	align 4
272	get_event_ex: ;; f68:14	272	get_event_ex: ;; f68:14
273	;info:	273	;info:
274	; Îæèäàíèå ëþáîãî ñîáûòèÿ â î÷åðåäè EventList òåêóùåãî ñëîòà	274	; Îæèäàíèå ëþáîãî ñîáûòèÿ â î÷åðåäè EventList òåêóùåãî ñëîòà
275	; Äàííûå ñîáûòèÿ code - êîïèðóþòñÿ â ïàìÿòü ïðèëîæåíèÿ (êîñâåííî ïî edi)	275	; Äàííûå ñîáûòèÿ code - êîïèðóþòñÿ â ïàìÿòü ïðèëîæåíèÿ (êîñâåííî ïî edi)
276	; Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî	276	; Ïðè àêòèâíîì ôëàãå MANUAL_RESET - áîëüøå íè÷åãî
277	; Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,	277	; Èíà÷å: ôëàãè EVENT_SIGNALED è EVENT_WATCHED ó ïîëó÷åííîãî ñîáûòèÿ ñáðàñûâàþòñÿ,
278	; è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,	278	; è, ïðè àêòèâíîì MANUAL_DESTROY - ïåðåìåùàåòñÿ â ñïèñîê ObjList òåêóùåãî ñëîòà,
279	; à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)	279	; à ïðè íå àêòèâíîì - óíè÷òîæàåòñÿ øòàòíî (destroy_event.internal)
280	;param:	280	;param:
281	; edi - àäðåñ â êîäå ïðèëîæåíèÿ äëÿ êîïèðîâàíèÿ äàííûõ èç EVENT.code	281	; edi - àäðåñ â êîäå ïðèëîæåíèÿ äëÿ êîïèðîâàíèÿ äàííûõ èç EVENT.code
282	;retval:	282	;retval:
283	; eax - ñîáñòâåííî EVENT (áóäåì íàçûâàòü ýòî åãî õýíäëîì)	283	; eax - ñîáñòâåííî EVENT (áóäåì íàçûâàòü ýòî åãî õýíäëîì)
284	;scratched: ebx,ecx,edx,esi,edi	284	;scratched: ebx,ecx,edx,esi,edi
285	mov edx, get_event_queue ; wait_test	285	mov edx, get_event_queue ; wait_test
286	call Wait_events ; timeout ignored	286	call Wait_events ; timeout ignored
287	lea esi,[eax+EVENT.code]	287	lea esi,[eax+EVENT.code]
288	mov ecx,EVENT.codesize/4	288	mov ecx,EVENT.codesize/4
289	cld	289	cld
290	rep movsd	290	rep movsd
291	mov [edi-EVENT.codesize+2],cl ;clear priority field	291	mov [edi-EVENT.codesize+2],cl ;clear priority field
292	wait_finish:	292	wait_finish:
293	test byte[eax+EVENT.state+3], MANUAL_RESET shr 24	293	test byte[eax+EVENT.state+3], MANUAL_RESET shr 24
294	jnz get_event_queue.ret ; RET	294	jnz get_event_queue.ret ; RET
295	and byte[eax+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)	295	and byte[eax+EVENT.state+3], not((EVENT_SIGNALED+EVENT_WATCHED)shr 24)
296	test byte[eax+EVENT.state+3], MANUAL_DESTROY shr 24	296	test byte[eax+EVENT.state+3], MANUAL_DESTROY shr 24
297	jz destroy_event.internal	297	jz destroy_event.internal
298	mov ebx,[current_slot]	298	mov ebx,[current_slot]
299	add ebx,APP_OBJ_OFFSET	299	add ebx,APP_OBJ_OFFSET
300	pushfd	300	pushfd
301	cli	301	cli
302	jmp RemoveEventTo	302	jmp RemoveEventTo
303		303
304	align 4	304	align 4
305	destroy_event: ;; EXPORT use	305	destroy_event: ;; EXPORT use
306	;info:	306	;info:
307	; Ïåðåíîñèì EVENT â ñïèñîê FreeEvents, ÷èñòèì ïîëÿ magic,destroy,pid,id	307	; Ïåðåíîñèì EVENT â ñïèñîê FreeEvents, ÷èñòèì ïîëÿ magic,destroy,pid,id
308	;param:	308	;param:
309	; eax - event	309	; eax - event
310	; ebx - uid (for Dummy testing)	310	; ebx - uid (for Dummy testing)
311	;retval:	311	;retval:
312	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)	312	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)
313	;scratched: ebx,ecx	313	;scratched: ebx,ecx
314	call DummyTest ; not returned for fail !!!	314	call DummyTest ; not returned for fail !!!
315	.internal:	315	.internal:
316	xor ecx,ecx ; clear common header	316	xor ecx,ecx ; clear common header
317	pushfd	317	pushfd
318	cli	318	cli
319	mov [eax+EVENT.magic],ecx	319	mov [eax+EVENT.magic],ecx
320	mov [eax+EVENT.destroy],ecx	320	mov [eax+EVENT.destroy],ecx
321	mov [eax+EVENT.pid],ecx	321	mov [eax+EVENT.pid],ecx
322	mov [eax+EVENT.id],ecx	322	mov [eax+EVENT.id],ecx
323	mov ebx,FreeEvents	323	mov ebx,FreeEvents
324	jmp RemoveEventTo	324	jmp RemoveEventTo
325		325
326	align 4	326	align 4
327	get_event_queue:	327	get_event_queue:
328	;info:	328	;info:
329	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ get_event_ex	329	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ get_event_ex
330	;warning:	330	;warning:
331	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot	331	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
332	; -may be assumed, that interrupt are disabled	332	; -may be assumed, that interrupt are disabled
333	; -it is not restriction for scratched registers	333	; -it is not restriction for scratched registers
334	;param:	334	;param:
335	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ	335	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
336	;retval:	336	;retval:
337	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)	337	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)
338	add ebx,APP_EV_OFFSET	338	add ebx,APP_EV_OFFSET
339	mov eax,[ebx+APPOBJ.bk] ; âûáèðàåì ñ êîíöà, ïî ïðèíöèïó FIFO	339	mov eax,[ebx+APPOBJ.bk] ; âûáèðàåì ñ êîíöà, ïî ïðèíöèïó FIFO
340	cmp eax,ebx ; empty ???	340	cmp eax,ebx ; empty ???
341	je get_event_alone.ret0	341	je get_event_alone.ret0
342	.ret: ret	342	.ret: ret
343		343
344	align 4	344	align 4
345	get_event_alone:	345	get_event_alone:
346	;info:	346	;info:
347	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ wait_event	347	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ wait_event
348	;warning:	348	;warning:
349	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot	349	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
350	; -may be assumed, that interrupt are disabled	350	; -may be assumed, that interrupt are disabled
351	; -it is not restriction for scratched registers	351	; -it is not restriction for scratched registers
352	;param:	352	;param:
353	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ	353	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
354	;retval:	354	;retval:
355	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)	355	; eax - àäðåñ îáúåêòà EVENT (=0 => fail)
356	mov eax,[ebx+APPDATA.wait_param]	356	mov eax,[ebx+APPDATA.wait_param]
357	test byte[eax+EVENT.state+3], EVENT_SIGNALED shr 24	357	test byte[eax+EVENT.state+3], EVENT_SIGNALED shr 24
358	jnz .ret	358	jnz .ret
359	or byte[eax+EVENT.state+3], EVENT_WATCHED shr 24	359	or byte[eax+EVENT.state+3], EVENT_WATCHED shr 24
360	.ret0: xor eax,eax ; NO event!!!	360	.ret0: xor eax,eax ; NO event!!!
361	.ret: ret	361	.ret: ret
362		362
363	align 4	363	align 4
364	sys_sendwindowmsg: ;; f72	364	sys_sendwindowmsg: ;; f72
365	dec ebx	365	dec ebx
366	jnz .ret ;subfunction==1 ?	366	jnz .ret ;subfunction==1 ?
367	;pushfd ;à íàôèãà?	367	;pushfd ;à íàôèãà?
368	cli	368	cli
369	sub ecx,2	369	sub ecx,2
370	je .sendkey	370	je .sendkey
-		371	dec ecx
371	loop .retf	372	jnz .retf
372	.sendbtn:	373	.sendbtn:
373	cmp byte[BTN_COUNT],1	374	cmp byte[BTN_COUNT],1
374	jae .result ;overflow	375	jae .result ;overflow
375	inc byte[BTN_COUNT]	376	inc byte[BTN_COUNT]
-		377	shl edx, 8
376	mov [BTN_BUFF],edx	378	mov [BTN_BUFF],edx
377	jmp .result	379	jmp .result
378	.sendkey:	380	.sendkey:
379	movzx eax,byte[KEY_COUNT]	381	movzx eax,byte[KEY_COUNT]
380	cmp al,120	382	cmp al,120
381	jae .result ;overflow	383	jae .result ;overflow
382	inc byte[KEY_COUNT]	384	inc byte[KEY_COUNT]
383	mov [KEY_COUNT+1+eax],dl	385	mov [KEY_COUNT+1+eax],dl
384	.result:	386	.result:
385	setae byte[esp+32] ;ñ÷èòàåì, ÷òî èñõîäíî: dword[esp+32]==72	387	setae byte[esp+32] ;ñ÷èòàåì, ÷òî èñõîäíî: dword[esp+32]==72
386	.retf: ;popfd	388	.retf: ;popfd
387	.ret: ret	389	.ret: ret
388		390
389	align 4	391	align 4
390	sys_getevent: ;; f11	392	sys_getevent: ;; f11
391	mov ebx,[current_slot] ;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........	393	mov ebx,[current_slot] ;ïîêà ýòî âîïðîñ, ÷åãî êóäû ñóâàòü..........
392	pushfd ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò	394	pushfd ; ýòî ñëåäñòâèå îáùåé êîíöåïöèè: ïóñòü ô-ÿ òåñòèðîâàíèÿ èìååò
393	cli ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed	395	cli ; ïðàâî ðàññ÷èòûâàòü íà çàêðûòûå ïðåðûâàíèÿ, êàê ïðè âûçîâå èç shed
394	call get_event_for_app	396	call get_event_for_app
395	popfd	397	popfd
396	mov [esp+32],eax	398	mov [esp+32],eax
397	ret	399	ret
398		400
399	align 4	401	align 4
400	sys_waitforevent: ;; f10	402	sys_waitforevent: ;; f10
401	or ebx,-1 ; infinite timeout	403	or ebx,-1 ; infinite timeout
402	sys_wait_event_timeout: ;; f23	404	sys_wait_event_timeout: ;; f23
403	mov edx,get_event_for_app ; wait_test	405	mov edx,get_event_for_app ; wait_test
404	call Wait_events_ex ; ebx - timeout	406	call Wait_events_ex ; ebx - timeout
405	mov [esp+32],eax	407	mov [esp+32],eax
406	ret	408	ret
407		409
408	align 4	410	align 4
409	get_event_for_app: ;; used from f10,f11,f23	411	get_event_for_app: ;; used from f10,f11,f23
410	;info:	412	;info:
411	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ ïðèëîæåíèé (f10,f23)	413	; êëèåíòñêàÿ ô-ÿ òåñòèðîâàíèÿ äëÿ ïðèëîæåíèé (f10,f23)
412	;warning:	414	;warning:
413	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot	415	; -don't use [TASK_BASE],[current_slot],[CURRENT_TASK] - it is not for your slot
414	; -may be assumed, that interrupt are disabled	416	; -may be assumed, that interrupt are disabled
415	; -it is not restriction for scratched registers	417	; -it is not restriction for scratched registers
416	;param:	418	;param:
417	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ	419	; ebx - àäðåñ APPDATA ñëîòà òåñòèðîâàíèÿ
418	;retval:	420	;retval:
419	; eax - íîìåð ñîáûòèÿ (=0 => no events)	421	; eax - íîìåð ñîáûòèÿ (=0 => no events)
420	movzx edi,bh ; bh is assumed as [CURRENT_TASK]	422	movzx edi,bh ; bh is assumed as [CURRENT_TASK]
421	shl edi,5	423	shl edi,5
422	add edi,CURRENT_TASK ; edi is assumed as [TASK_BASE]	424	add edi,CURRENT_TASK ; edi is assumed as [TASK_BASE]
423	mov ecx,[edi+TASKDATA.event_mask]	425	mov ecx,[edi+TASKDATA.event_mask]
424	.loop: ; ïîêà íå èñ÷åðïàåì âñå áèòû ìàñêè	426	.loop: ; ïîêà íå èñ÷åðïàåì âñå áèòû ìàñêè
425	bsr eax,ecx ; íàõîäèì íåíóëåâîé áèò ìàñêè (31 -> 0)	427	bsr eax,ecx ; íàõîäèì íåíóëåâîé áèò ìàñêè (31 -> 0)
426	jz .no_events ; èñ÷åðïàëè âñå áèòû ìàñêè, íî íè÷åãî íå íàøëè ???	428	jz .no_events ; èñ÷åðïàëè âñå áèòû ìàñêè, íî íè÷åãî íå íàøëè ???
427	btr ecx,eax ; ñáðàñûâàåì ïðîâåðÿåìûé áèò ìàñêè	429	btr ecx,eax ; ñáðàñûâàåì ïðîâåðÿåìûé áèò ìàñêè
428	; ïåðåõîäèì íà îáðàáîò÷èê ýòîãî (eax) áèòà	430	; ïåðåõîäèì íà îáðàáîò÷èê ýòîãî (eax) áèòà
429	cmp eax,16	431	cmp eax,16
430	jae .IRQ ; eax=[16..31]=retvals, events irq0..irq15	432	jae .IRQ ; eax=[16..31]=retvals, events irq0..irq15
431	cmp eax,9	433	cmp eax,9
432	jae .loop ; eax=[9..15], ignored	434	jae .loop ; eax=[9..15], ignored
433	cmp eax,3	435	cmp eax,3
434	je .loop ; eax=3, ignored	436	je .loop ; eax=3, ignored
435	ja .FlagAutoReset ; eax=[4..8], retvals=eax+1	437	ja .FlagAutoReset ; eax=[4..8], retvals=eax+1
436	cmp eax,1	438	cmp eax,1
437	jae .BtKy ; eax=[1,2], retvals=eax+1	439	jae .BtKy ; eax=[1,2], retvals=eax+1
438	.WndRedraw: ; eax=0, retval WndRedraw=1	440	.WndRedraw: ; eax=0, retval WndRedraw=1
439	cmp [edi-twdw+WDATA.fl_redraw],al ;al==0	441	cmp [edi-twdw+WDATA.fl_redraw],al ;al==0
440	jne .result	442	jne .result
441	jmp .loop	443	jmp .loop
442	.no_events:	444	.no_events:
443	xor eax,eax	445	xor eax,eax
444	ret	446	ret
445	.IRQ:	447	.IRQ:
446	;TODO: ñäåëàòü òàê æå, êàê è äëÿ FlagAutoReset (BgrRedraw,Mouse,IPC,Stack,Debug)	448	;TODO: ñäåëàòü òàê æå, êàê è äëÿ FlagAutoReset (BgrRedraw,Mouse,IPC,Stack,Debug)
447	mov edx,[irq_owner+eax*4-64] ; eax==16+irq	449	mov edx,[irq_owner+eax*4-64] ; eax==16+irq
448	cmp edx,[edi+TASKDATA.pid]	450	cmp edx,[edi+TASKDATA.pid]
449	jne .loop	451	jne .loop
450	mov edx,eax	452	mov edx,eax
451	shl edx,12	453	shl edx,12
452	cmp dword[IRQ_SAVE+edx-0x10000],0 ; edx==(16+irq)*0x1000	454	cmp dword[IRQ_SAVE+edx-0x10000],0 ; edx==(16+irq)*0x1000
453	je .loop ; empty ???	455	je .loop ; empty ???
454	ret ; retval = eax	456	ret ; retval = eax
455	.FlagAutoReset: ; retvals: BgrRedraw=5, Mouse=6, IPC=7, Stack=8, Debug=9	457	.FlagAutoReset: ; retvals: BgrRedraw=5, Mouse=6, IPC=7, Stack=8, Debug=9
456	btr [ebx+APPDATA.event_mask],eax	458	btr [ebx+APPDATA.event_mask],eax
457	jnc .loop	459	jnc .loop
458	.result: ; retval = eax+1	460	.result: ; retval = eax+1
459	inc eax	461	inc eax
460	ret	462	ret
461	.BtKy:	463	.BtKy:
462	movzx edx,bh	464	movzx edx,bh
463	movzx edx, word[WIN_STACK+edx*2]	465	movzx edx, word[WIN_STACK+edx*2]
464	je .Keys ; eax=1, retval Keys=2	466	je .Keys ; eax=1, retval Keys=2
465	.Buttons: ; eax=2, retval Buttons=3	467	.Buttons: ; eax=2, retval Buttons=3
466	cmp byte[BTN_COUNT],0	468	cmp byte[BTN_COUNT],0
467	je .loop ; empty ???	469	je .loop ; empty ???
468	cmp edx,[TASK_COUNT]	470	cmp edx,[TASK_COUNT]
469	jne .loop ; not Top ???	471	jne .loop ; not Top ???
-		472	mov edx, [BTN_BUFF]
-		473	shr edx, 8
470	cmp dword[BTN_BUFF],0xFFFF ;-ID for Minimize-Button of Form	474	cmp edx, 0xFFFF ;-ID for Minimize-Button of Form
471	jne .result	475	jne .result
472	mov [window_minimize],1	476	mov [window_minimize],1
473	dec byte[BTN_COUNT]	477	dec byte[BTN_COUNT]
474	jmp .loop	478	jmp .loop
475	.Keys: ; eax==1	479	.Keys: ; eax==1
476	cmp edx,[TASK_COUNT]	480	cmp edx,[TASK_COUNT]
477	jne @f ; not Top ???	481	jne @f ; not Top ???
478	cmp [KEY_COUNT],al ; al==1	482	cmp [KEY_COUNT],al ; al==1
479	jae .result ; not empty ???	483	jae .result ; not empty ???
480	@@: mov edx, hotkey_buffer	484	@@: mov edx, hotkey_buffer
481	@@: cmp [edx],bh ; bh - slot for testing	485	@@: cmp [edx],bh ; bh - slot for testing
482	je .result	486	je .result
483	add edx,8	487	add edx,8
484	cmp edx, hotkey_buffer+120*8	488	cmp edx, hotkey_buffer+120*8
485	jb @b	489	jb @b
486	jmp .loop	490	jmp .loop
487	;end.	491	;end.

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/event.inc – Rev 1067 → 1391