Z Wikipedii

Zdarzenie (ang. event) – zapis zajścia w systemie komputerowym określonej sytuacji.

[edytuj] Zdarzenia w programowaniu zdarzeniowym

Zdarzenia generowane są na przykład podczas poruszania myszką, kończenia otwierania dokumentu lub naciśnięcia klawisza na klawiaturze. Mogą być powodowane przez sprzęt (zdarzenia sprzętowe), system (systemowe), bądź oprogramowanie (programowe).

Zdarzenia w postaci specjalnych rekordów są przechowywane przez system operacyjny w tzw. kolejkach zdarzeń (ang. event queues) zbudowanych w oparciu o strukturę FIFO. Kolejki są na ogół przypisane po jednej do wątku (każda aplikacja ma choć jeden). System operacyjny utrzymuje też własne kolejki zdarzeń. Każde zdarzenie wpada do jednej lub większej liczby kolejek. Np. zdarzenia klawiatury wpadają tylko do kolejki aktywnej aplikacji, a zapytanie o możliwość zamknięcia systemu do kolejek wszystkich aplikacji.

Aplikacja odczytuje swoją kolejkę zdarzeń i podejmuje odpowiednie akcje określone przez programistę. Aplikacje na ogół ograniczają się tylko do reagowania na zdarzenia uzyskiwane z systemu operacyjnego (tzw. programowanie zdarzeniowe), nie wykonując żadnego kodu gdy nie ma dla nich żadnych nowych zdarzeń.

Można też skorzystać z mechanizmu tzw. event hooks, dzięki którym aplikacja "podsłuchuje" zdarzenia innej aplikacji lub całego systemu. Jest to stosowane przez debuggery i aplikacje hackerskie (np. keylogger może podglądać hasła wpisywane przez użytkownika przechwytując zdarzenia klawiatury).

Zobacz też: Programowanie zdarzeniowe.

[edytuj] Zdarzenia w systemie Windows

W Windows kolejki zdarzeń są przypisane do wątków, jednak każde zdarzenie zawiera uchwyt okna, w związku z czym są one też nazywane "window message". Pojęcie okna w systemie Windows obejmuje nie tylko okienko na ekranie. Oddzielnymi "oknami" są też np. wnętrze okna, dowolny element okna (każdy przycisk, czy tekst), tło ekranu.

Definicja zdarzenia w systemie Windows, tak jak widzi je aplikacja:

typedef struct tagMSG {
  HWND hwnd;      /*Uchwyt okna docelowego*/
  UINT message;   /*Kod określający rodzaj zdarzenia (zobacz niżej)*/
  WPARAM wParam;  /*Parametr - interpretacja zależna od rodzaju zdarzenia*/
  LPARAM lParam;  /*Parametr - interpretacja zależna od rodzaju zdarzenia*/
  DWORD time;     /*Czas zdarzenia*/
  POINT pt;       /*Punkt ekranu zwiÄ…zany z danym zdarzeniem*/
} MSG;

Rodzajów zdarzeń są tysiące. Oto kilka przykładów:

• WM_KEYDOWN - wciÅ›niÄ™to przycisk na klawiaturze
• WM_KEYUP - puszczono przycisk na klawiaturze
• WM_MOUSEOVER - przesuniÄ™to myszkÄ™, gdy jest na tle danego okna
• WM_INITDIALOG - zdarzenie generowane przed pokazaniem okna dialogowego w celu poinformowania go, że powinno ustawić wszystkie swoje zmienne na wartoÅ›ci poczÄ…tkowe.
• WM_COMMAND - zdarzenie komendy wywoÅ‚ywane przez opcje menu, przyciski okna dialogowego i akceleratory.
• WM_CREATE - utworzono okno
• WM_SIZE - zmieniono rozmiar okna
• WM_PAINT - nakaz odrysowania siÄ™ dla okna
• WM_CLOSE - informacja dla okna, że bÄ™dzie zamkniÄ™te. Okno aplikacji może siÄ™ na przykÅ‚ad zapytać użytkownika, czy zapisać pliki. Ma jeszcze możliwość odwoÅ‚ania zamkniÄ™cia.
• WM_QUIT - bezwarunkowe zamkniÄ™cie aplikacji (bez pytania jej o zgodÄ™)
• WM_TIMER - system informuje o upÅ‚ywie pewnego czasu (na wczeÅ›niejsze żądanie programu)
• WM_QUERYENDSESSION - zapytanie wszystkich aplikacji, czy zgadzajÄ… siÄ™ na zamkniÄ™cie sesji systemu operacyjnego.

Obsługując zdarzenie aplikacja może zwrócić do nadawcy (systemu lub innego procesu) liczbę, która będzie jakoś zinterpretowana w zależności od rodzaju zdarzenia. Może to być na przykład odpowiedź, czy udało się zainicjować zmienne, albo czy jest zgoda na zamknięcie systemu.

Można też definiować własne zdarzenia, i np. komunikować się przy ich pomocy między okienkami lub procesami.

Do programowego tworzenia zdarzeń służą dwie funkcje:

• SendMessage - tworzy zdarzenie i wstrzymuje wykonanie do czasu jego przetworzenia przez adresata. Zwraca odpowiedź adresata.
• PostMessage - dopisuje zdarzenie do kolejki adresata bez oczekiwania na jego przetworzenie

Istnieją tzw. okna modalne, wstrzymujące przetwarzanie zdarzeń przez pozostałe okna danej aplikacji (np. okno z pytaniem na które należy odpowiedzieć tak/nie). Istnieją też systemowe okna modalne, wstrzymujące przetwarzanie zdarzeń przez wszystkie inne okna (np. pytanie o potwierdzenie zamknięcia systemu).

Przykład pętli obsługi zdarzeń:

    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

Przetwarzanie zdarzeń przez aplikację polega na wykonywaniu w pętli funkcji:

• GetMessage - pobiera zdarzenie z kolejki
• TranslateMessage - tÅ‚umaczy niektóre zdarzenia dotyczÄ…ce wciÅ›niÄ™cia przycisków klawiatury
• DispatchMessage - pobrane zdarzenie jest kierowane do wczeÅ›niej zdefiniowanej procedury docelowego okna, która je obsÅ‚uguje (tzw. window procedure). Procedura ta jest definiowana podczas tworzenia okna.

Istnieje też funkcja PeekMessage którą można podglądać zdarzenia w kolejce bez pobierania ich.

[edytuj] Przykładowa aplikacja Windows działająca zdarzeniowo

Ze względu na spory rozmiar ten przykład pokaże się dopiero, gdy klikniesz na słowie [Pokaż] z prawej strony.

#include <windows.h>

static TCHAR lpszAppName[] = TEXT( "API Windows" );

LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{
    //reakcje na poszczególne zdarzenia wysyłane przez użytkownika
    switch (uMsg)
    {
        case WM_CREATE:
             break;

        case WM_DESTROY:
             PostQuitMessage(0);
             break;

        case WM_KEYDOWN:
             break;

        default:
             return (DefWindowProc(hWnd, uMsg, wParam, lParam));

    }
    return(0L);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{ 

    MSG msg;
    WNDCLASS wndclass;
    HWND hWnd; 

    //definicja okna
    wndclass.style = CS_HREDRAW | CS_VREDRAW; 
    wndclass.lpfnWndProc = MainWndProc; 
    wndclass.cbClsExtra = 0; 
    wndclass.cbWndExtra = 0; 
    wndclass.hInstance = hInstance; 
    wndclass.hIcon = NULL; 
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); 
    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); 
    wndclass.lpszMenuName = NULL; 
    wndclass.lpszClassName = lpszAppName; 

    if(RegisterClass(&wndclass) == 0) 
        return FALSE; 

    hWnd = CreateWindow(lpszAppName, lpszAppName, 
                        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
    if(hWnd == NULL)
        return FALSE;

    //pokazanie okna
    ShowWindow(hWnd, SW_SHOW);
    UpdateWindow(hWnd);

    //pętla oczekująca na przychodzące zdarzenia
    while(GetMessage(&msg, NULL, 0, 0))
    {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }

    return msg.wParam;
}

[edytuj] Zdarzenia w systemie Mac OS

Definicja zdarzenia w systemie Mac OS:

struct EventRecord {
   EventKind         what;
   UInt32            message;
   UInt32            when;
   Point             where;
   EventModifiers    modifiers;
};

Opis pól:

• what - pole opisujÄ…ce rodzaj zdarzenia, np.
  • 0 nullEvent
  • 1 mouseDown
  • 2 mouseUp
  • 3 keyDown
  • 4 keyUp
  • 5 autoKey
  • 6 updateEvt
  • 7 diskEvt
  • 8 activateEvt
  • 15 osEvt
  • 23 kHighLevelEvent
• message - dodatkowa informacja zależna od rodzaju zdarzenia
• when - czas (liczba ticków) od startu systemu
• where - pozycja myszy
• modifiers - dodatkowe flagi

[edytuj] Zdarzenia w systemie X Window System

Wszystkie zdarzenia w systemie X Window System mają następujące wspólne pola:

       typedef struct {
            int type;                /* typ zdarzenia*/
            unsigned long serial;    /* liczba ostatnich zleceń przetworzonych przez serwer */
            Bool send_event;         /* true jeśli pochodzi z wywołania SendEvent */
            Display *display;        /* Display z którego zdarzenie zostało odczytane */
            Window window;
       } XAnyEvent;

Dla poszczególnych zdarzeń zdefiniowane są osobne struktury. Unia XEvent łączy je w jedno:

       typedef union _XEvent {
            int type;
            XAnyEvent xany;
            XKeyEvent xkey;
            XButtonEvent xbutton;
            XMotionEvent xmotion;
            XCrossingEvent xcrossing;
            XFocusChangeEvent xfocus;
            XExposeEvent xexpose;
            XGraphicsExposeEvent xgraphicsexpose;
            XNoExposeEvent xnoexpose;
            XVisibilityEvent xvisibility;
            XCreateWindowEvent xcreatewindow;
            XDestroyWindowEvent xdestroywindow;
            XUnmapEvent xunmap;
            XMapEvent xmap;
            XMapRequestEvent xmaprequest;
            XReparentEvent xreparent;
            XConfigureEvent xconfigure;
            XGravityEvent xgravity;
            XResizeRequestEvent xresizerequest;
            XConfigureRequestEvent xconfigurerequest;
            XCirculateEvent xcirculate;
            XCirculateRequestEvent xcirculaterequest;
            XPropertyEvent xproperty;
            XSelectionClearEvent xselectionclear;
            XSelectionRequestEvent xselectionrequest;
            XSelectionEvent xselection;
            XColormapEvent xcolormap;
            XClientMessageEvent xclient;
            XMappingEvent xmapping;
            XErrorEvent xerror;
            XKeymapEvent xkeymap;
            long pad[24];
       } XEvent;

Zobacz też: manual do struktury XEvent

[edytuj] Zdarzenia z dziennika zdarzeń

Drugim, zupełnie odrębnym znaczeniem słowa "zdarzenie" w informatyce jest wpis w dzienniku zdarzeń. Dziennik jest aplikacją systemową, dzięki której administrator może kontrolować bieżącą pracę systemu. Zapisywane są w nim zdarzenia takie jak np. brak możliwości uruchomienia sterownika, albo zalogowanie na konto administratora. Zdarzenia w tym sensie nie mają żadnego związku z wcześniej wymienionym znaczeniem.

[edytuj] Linki zewnętrzne

• Event Manager Reference