Przechwyt klawiatury w Delphi- podsumowanie

     Stosując którąś z metod przechwytywania klawiatury, musimy pamiętać o kilku podstawowych zasadach. Pierwsza z nich wydaje się być oczywista: Nie przejmujemy kontroli nad klawiszem, którego będziemy potrzebować w jego domyślnym działaniu (np. Enter, Backpace). Wyobraźmy sobie przypadek, w którym przejęliśmy kontrolę nad klawiszami liter i nadaliśmy im polecenia inne niż pisanie. Jak teraz wpiszemy swoją odpowiedź w pole edycyjne?

     Druga zasada mówi o tym, że nie musimy używać całej metody i przechwytywać wszystkie klawisze, na jakie ona pozwala. Przechwytujemy tylko te, które potrzebujemy. Odchudzi to nasz kod, a i nam zaoszczędzi czasu na pisanie czegoś niepotrzebnego.

     Trzecia zasada, o której warto pamiętać, dotyczy poprzedniego tematu. Po pierwsze, deklaracje poszczególnych klawiszy i skrótów mogą być w innej kolejności, niż my w tym rozdziale zastosowaliśmy. To od nas zależy. Po drugie, wybierając klawisze i skróty klawiaturowe do przejęcia, deklarujemy je w nowym porządku, dbając o ciągłość deklaracji: deklaracja 1, 2, 3 i tak dalej.

     Czwarta zasada mówi o tym, że nic nie stoi na przeszkodzie, aby nie móc połączyć ze sobą dwie lub wszystkie przedstawione przez nas metody. Możemy to zrobić, choć musimy zwrócić uwagę na to, aby przechwycone klawisze nie wpływały na pracę pozostałych metod. Jeżeli na przykład, przechwycimy klawisz Shift w jednej metodzie, to wszelkie skróty klawiaturowe z użyciem tego klawisza w drugiej metodzie mogą być nieaktywne, gdyż jak tylko naciśniemy ten klawisz, wykona się przypisana do niego procedura.

Zakładanie hooka w Delphi- metoda Short Cut

Metoda Short Cut

    Jest to najbardziej skomplikowana metoda z tych trzech zaprezentowanych (por. Metoda Key Press i Metoda Hot Key). Służy ona do tworzenia skrótów klawiaturowych z użyciem klawiszy rozszerzonych Ctrl i Alt oraz ich połączenia, czyli Ctrl+Alt+klawisz. Jak widzimy po tabeli skrótów, obejmuje ona znaczną ich część. W sumie, za jej pomocą utworzyliśmy aż 165 skrótów. Każdy z nich będzie generował osobną procedurę o nazwie Procedura 1, 2, 3 aż do 165. W jej obrębie zawarliśmy naszą procedurę „Opcja niedostępna”, którą Czytelnik-programista może wymienić na inny zbiór poleceń do wykonania.

     Wszystkie informacje o stworzonych skrótach zawieramy w tablicy rekordów o nazwie ShortCutArray, którą wypełniamy danymi przy uruchomieniu programu (FormCreate):

ShortCutArray[0].sShortCut := TextToShortCut('Alt+`');

ShortCutArray[0].pAction := Procedura1;

     Każda komórka tablicy zawiera dwie dane: tworzony przez nas skrót oraz nazwę procedury, która ma zostać wykonana po uruchomieniu tego skrótu. Zauważmy, że skrót wpisujemy w postaci tekstowej, który dopiero podlega konwersji (TextToShortCut) do postaci skrótu klawiaturowego. W metodzie tej nie stosujemy więc kodów klawiszy, tylko ich tekstowe odpowiedniki.

     Aby móc skorzystać z metody Short Cut musimy do sekcji uses dołączyć odpowiedni moduł, co też robimy, dopisując po przecinku słowo Menus. Po deklaracji wszystkich używanych przez nas procedur, zmiennych i rekordów, przystępujemy do ich wypełniania. Jako pierwszą wypełnimy procedurę Action, która będzie analizowała wciskane przez użytkownika klawisze i badała czy nie pojawił się jakiś skrót klawiaturowy. Tworzymy ją poprzez ręczne wpisanie jej do kodu programu. Co prawda zdarzenie OnAction znajduje się w zakładce Events (w Inspektorze Obiektów), jednak standardowym, podwójnym kliknięciem jej nie utworzymy. Pozostałe dwa systemowe zdarzenia, czyli OnCreate i OnKeyDown tworzymy w zakładce Events, klikając wpierw na puste miejsce formy głównej (gdziekolwiek, byleby nie na jakiś komponent), a następnie podwójnym kliknięciem otwierając je w kodzie.

 

Zdarzenia OnKeyDown, OnKeyUp i OnKeyPress

     Zdarzenie OnKeyDown zostaje wywołane w chwili wciśnięcia klawisza, w przeciwieństwie do zdarzenia OnKeyUp, które jest wywoływane w chwili puszczenia klawisza. Trzecim zdarzeniem w zakładce Events związanym z klawiszami jest zdarzenie OnKeyPress. Ta opcja akurat nie rozróżnia tych dwóch wcześniejszych stanów i jest generowana zawsze po naciśnięciu i puszczeniu klawisza. 

 

     Aby dobrze to wszystko zrozumieć, wyobraźmy sobie, że czynność naciskania na klawisz dzielimy na dwie części: naciskamy na klawisz, a po chwili puszczamy go. Zdarzenie OnKeyPress zostanie wywołane dopiero po zakończeniu całej tej operacji, czyli po puszczeniu klawisza. Zdarzenie OnKeyDown zostanie natomiast wykonane już w pierwszej części, po wciśnięciu klawisza, nie czekając na jego puszczenie. 

 

Jak widzimy, procedura FormKeyDown zawiera tylko jedno polecenie: jakikolwiek klawisz nie zostanie wciśnięty, ma uruchomić procedurę Action, która zanalizuje, czy czasem naciskane klawisze nie są skrótem klawiaturowym.

     Procedurę Action tworzy pętla for...to...do, która analizuje każdy element tablicy ShortCutArray:

for I := 0 to High(ShortCutArray) do

    begin

             { rozbicie skrótu z tablicy }

       ShortCutToKey(ShortCutArray[i].sShortCut, pKey, pShift);

             { porównanie zmiennych }

            if ((pKey = wKey) and (sShift = pShift)) then

                 ShortCutArray[i].pAction; //wywołanie odpowiedniej procedury

    end;

     Z uwagi na to, iż skrót składa się z dwóch klawiszy (klawisz rozszerzony i zwykł klawisz), należy rozbić ten skrót na dwie zmienne: pKey, która oznacza kod ASCII klawisza, oraz pShift, która zawiera informację, który z klawiszy rozszerzonych (Ctrl, Alt czy Shift) został naciśnięty. Teraz następuje analiza poprzez porównanie, czy te zmienne są takie same, jak zmienne wKey i sShift, innymi słowy, czy naciśnięte klawisze odpowiadają któremuś ze skrótów zapisanych w tablicy ShortCutArray. Jeżeli odpowiadają, wtedy następuje wywołanie procedury pAction zadeklarowanej w rekordzie, która z kolei uruchomi naszą procedurę do wykonania.

     A oto kod całej metody:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, Menus; //dodać moduł Menus

type

TForm1 = class(TForm)

procedure Opcja_niedostepna;

procedure FormCreate(Sender: TObject);

procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);

private

{ Private declarations }

//procedura, która zanalizuje każde naciśnięcie klawisza

procedure Action(wKey : Word; sShift : TShiftState);

//to są procedury które będą wykonywane, gdy ktoś wciśnie skrót

procedure Procedura1; //Alt+`~

procedure Procedura2; //Alt+1

procedure Procedura3; //Alt+2

procedure Procedura4; //Alt+3

procedure Procedura5; //Alt+4

procedure Procedura6; //Alt+5

procedure Procedura7; //Alt+6

procedure Procedura8; //Alt+7

procedure Procedura9; //Alt+8

procedure Procedura10; //Alt+9

procedure Procedura11; //Alt+0

procedure Procedura12; //Alt+-

procedure Procedura13; //Alt+=

procedure Procedura14; //Alt+q

procedure Procedura15; //Alt+w

procedure Procedura16; //Alt+e

procedure Procedura17; //Alt+r

procedure Procedura18; //Alt+t

procedure Procedura19; //Alt+y

procedure Procedura20; //Alt+u

procedure Procedura21; //Alt+i

procedure Procedura22; //Alt+o

procedure Procedura23; //Alt+p

procedure Procedura24; //Alt+[

procedure Procedura25; //Alt+]

procedure Procedura26; //Alt+a

procedure Procedura27; //Alt+s

procedure Procedura28; //Alt+d

procedure Procedura29; //Alt+f

procedure Procedura30; //Alt+g

procedure Procedura31; //Alt+h

procedure Procedura32; //Alt+j

procedure Procedura33; //Alt+k

procedure Procedura34; //Alt+l

procedure Procedura35; //Alt+;

procedure Procedura36; //Alt+\

procedure Procedura37; //Alt+z

procedure Procedura38; //Alt+x

procedure Procedura39; //Alt+c

procedure Procedura40; //Alt+v

procedure Procedura41; //Alt+b

procedure Procedura42; //Alt+n

procedure Procedura43; //Alt+m

procedure Procedura44; //Alt+,

procedure Procedura45; //Alt+.

procedure Procedura46; //Alt+/

Zakładanie hooka w Delphi- metoda Hot Key

Metoda Hot Key

     Poprzednio poznaliśmy metodę przechwytywania klawiatury o nazwie Key Press. Metoda Hot Key jest drugą możliwością przechwytywania klawiatury i tworzenia skrótów klawiaturowych, jaką daje nam Delphi (zakładka Tools Pallete).

     Podobnie, jak w poprzednim przypadku, do testowania naszych działań wykorzystamy stworzoną przez nas procedurę o nazwie „Opcja niedostępna”. Oprócz niej używać będziemy jeszcze procedurę WMHotKey, którą deklarujemy w sekcji Private.

     W metodzie, którą przedstawiamy, aby przyswoić któryś z klawiszy do naszych potrzeb, musimy najpierw zarejestrować go w funkcji Hot Key i przypisać polecenie, które ma zostać wykonane po jego naciśnięciu. Każdy klawisz i każda kombinacja klawiszy (skróty klawiaturowe) musi zostać osobno zarejestrowana. Rejestracji dokonujemy w procedurze Form Create. Jest to chyba oczywiste miejsce: Przechwytu klawiszy musimy dokonać razem z uruchamiającym się programem.

Spójrzmy na zapis z rejestracji pierwszego klawisza:

                             RegisterHotKey(Handle,$0001,0,VK_F1)

     Polecenie „RegisterHotKey” mówi samo za siebie: „zarejestruj skrót klawiaturowy”. Po słowie Handle mamy identyfikator tego skrótu, który jest liczbą kolejną, począwszy od pierwszej, czyli 0001. Jak widzimy po tej sekcji, w sumie zarejestrowaliśmy 171 różnych klawiszy i ich kombinacji. Po identyfikatorze umieszczamy kod klawisza lub klawiszy, które chcemy przejąć. Nie spotkaliśmy się jeszcze z taką formą identyfikowania klawiszy. Jest ona drugim, równorzędnym sposobem oznaczania klawiszy. Po literach „VK” wpisujemy słowną nazwę klawisza, oczywiście w języku angielskim, który w środowisku Delphi obowiązuje. Chcąc zatem przejąć dany klawisz, musimy wiedzieć, jak się on nazywa. W materiałach pomocniczych do Delphi odnajdziemy bez problemu takie informacje.

     W przypadku, gdy chcemy zarejestrować kombinację klawiszy, musimy podać nazwy obu klawiszy, pamiętając o tym, że dla klawiszy rozszerzonych (Alt, Ctrl, Shift, Win) nie stosujemy początkowych liter w postaci VK, lecz MOD, a także musimy pamiętać o tym, że dla klawisza Ctrl stosujemy jego pełną nazwę, czyli Control.

     Po rejestracji klawiszy musimy jeszcze oprogramować procedury, które zostaną wykonane po ich naciśnięciu. Polecenia te zawieramy w procedurze WMHotKey. Cała ta procedura to zbiór osobnych warunków, które przypisane są do poszczególnych klawiszy zarejestrowanych wcześniej. Program sprawdza, czy któryś z klawiszy (opatrzony tu identyfikatorem „$” został naciśnięty:

       if Msg.wParam= $0001 then

          begin

              Opcja_niedostepna;

           end;

     Jeżeli przyjrzymy się bliżej kodowi metody Hot Key, stwierdzimy, że nie jest ona zbyt skomplikowana. Wydaje się ona być trudna z uwagi na jej rozbudowaną formę, wynikającą tylko i wyłącznie z tego, iż musimy zarejestrować i oprogramować każdy klawisz z osobna.

     Całą ideę metody Hot Key możemy zawrzeć w następujący schemat:

                      Form Create: RegisterHotKey(Handle,$0001,0,VK_F1)

                      WMHotKey: if Msg.wParam= $0001 then ...

    Najpierw rejestrujemy klawisz, a następnie przypisujemy do niego polecenie, które ma zostać wykonane. Taka budowa hooka pozwala nam na wybranie do przechwytu tylko takie klawisze i skróty, jakie chcemy. Nie musimy więc stosować pełnej wersji tej metody, którą tu zamieszczamy. Po wybraniu klawiszy, rejestrujemy je w dowolnej kolejności, pamiętając o tym, aby poszczególne identyfikatory ($0000) były ciągiem kolejnych liczb naturalnych: 0001, 0002, 0003 itd.

       Oto pełny kod metody Hot Key:

 

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;

type

TForm1 = class(TForm)

procedure Opcja_niedostepna;

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

procedure WMHotKey(var Msg: TMessage); message WM_HOTKEY;

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

// PROCEDURA OPCJA NIEDOSTĘPNA //

procedure TForm1.Opcja_niedostepna;

begin

ShowMessage('Opcja niedostępna');

end;

//rejestracja skrótów klawiaturowych

procedure TForm1.FormCreate(Sender: TObject);

begin

// SKRÓTY KLAWIATUROWE F1-F12 i Esc //

RegisterHotKey(Handle,$0001,0,VK_F1); // F1

RegisterHotKey(Handle,$0002,0,VK_F2); // F2

RegisterHotKey(Handle,$0003,0,VK_F3); // F3

RegisterHotKey(Handle,$0004,0,VK_F4); // F4

RegisterHotKey(Handle,$0005,0,VK_F5); // F5

RegisterHotKey(Handle,$0006,0,VK_F6); // F6

RegisterHotKey(Handle,$0007,0,VK_F7); // F7

RegisterHotKey(Handle,$0008,0,VK_F8); // F8

RegisterHotKey(Handle,$0009,0,VK_F9); // F9

RegisterHotKey(Handle,$0010,0,VK_F10); // F10

RegisterHotKey(Handle,$0011,0,VK_F11); // F11

RegisterHotKey(Handle,$0012,0,VK_F12); // F12

RegisterHotKey(Handle,$0013,0,VK_ESCAPE); // Esc

// SKRÓTY KLAWIATUROWE Alt+F1-F12,Esc

RegisterHotKey(Handle,$0014,MOD_ALT,VK_F1); //Alt+F1

RegisterHotKey(Handle,$0015,MOD_ALT,VK_F2); //Alt+F2

RegisterHotKey(Handle,$0016,MOD_ALT,VK_F3); //Alt+F3

RegisterHotKey(Handle,$0017,MOD_ALT,VK_F4); //Alt+F4

RegisterHotKey(Handle,$0018,MOD_ALT,VK_F5); //Alt+F5

RegisterHotKey(Handle,$0019,MOD_ALT,VK_F6); //Alt+F6

RegisterHotKey(Handle,$0020,MOD_ALT,VK_F7); //Alt+F7

RegisterHotKey(Handle,$0021,MOD_ALT,VK_F8); //Alt+F8

RegisterHotKey(Handle,$0022,MOD_ALT,VK_F9); //Alt+F9

RegisterHotKey(Handle,$0023,MOD_ALT,VK_F10); //Alt+F10

RegisterHotKey(Handle,$0024,MOD_ALT,VK_F11); //Alt+F11

RegisterHotKey(Handle,$0025,MOD_ALT,VK_F12); //Alt+F12

RegisterHotKey(Handle,$0026,MOD_ALT,VK_ESCAPE); //Alt+Esc

// SKRÓTY KLAWIATUROWE Ctrl+ F1-F12,Esc

RegisterHotKey(Handle,$0027,MOD_CONTROL,VK_F1); //Ctrl+F1

RegisterHotKey(Handle,$0028,MOD_CONTROL,VK_F2); //Ctrl+F2

RegisterHotKey(Handle,$0029,MOD_CONTROL,VK_F3); //Ctrl+F3

RegisterHotKey(Handle,$0030,MOD_CONTROL,VK_F4); //Ctrl+F4

RegisterHotKey(Handle,$0031,MOD_CONTROL,VK_F5); //Ctrl+F5

RegisterHotKey(Handle,$0032,MOD_CONTROL,VK_F6); //Ctrl+F6

RegisterHotKey(Handle,$0033,MOD_CONTROL,VK_F7); //Ctrl+F7

RegisterHotKey(Handle,$0034,MOD_CONTROL,VK_F8); //Ctrl+F8

RegisterHotKey(Handle,$0035,MOD_CONTROL,VK_F9); //Ctrl+F9

RegisterHotKey(Handle,$0036,MOD_CONTROL,VK_F10); //Ctrl+F10

RegisterHotKey(Handle,$0037,MOD_CONTROL,VK_F11); //Ctrl+F11

RegisterHotKey(Handle,$0038,MOD_CONTROL,VK_F12); //Ctrl+F12

RegisterHotKey(Handle,$0039,MOD_CONTROL,VK_ESCAPE); //Ctrl+Esc

// PRZECHWYT KLAWISZY STRZALEK //

RegisterHotKey(Handle,$0040,0,VK_LEFT); // strzałka w lewo

RegisterHotKey(Handle,$0041,0,VK_RIGHT); // strzałka w prawo

RegisterHotKey(Handle,$0042,0,VK_UP); // strzałka w górę

RegisterHotKey(Handle,$0043,0,VK_DOWN); // strzałka w dół

// PRZECHWYT INNYCH KLAWISZY I SKRÓTÓW KLAWIATUROWYCH //

Przechwyt klawiatury w Delphi - Metoda Key Press

Metoda Key Press

     Przejmowanie kontroli nad klawiszem za pomocą metody Key Press, to pierwsze i podstawowe działanie programistyczne w tej materii. Nie korzystamy tu ze skomplikowanych rozwiązań, tylko wykorzystujemy możliwości Inspektora Obiektów. W jego prawej zakładce (Events) znajduje się zdarzenie nazwane OnKeyPress. Jak sama nazwa wskazuje, reaguje ono na naciśnięcie klawisza. Kiedy ktoś naciśnie dowolny klawisz, program wygeneruje zdarzenie OnKeyPress, które z kolei wykona przypisany do niego kod. Cały przedstawiony przez nas kod, to nic innego, jak zbiór oddzielnych instrukcji warunkowych sprawdzających, czy nie wystąpił dany warunek. Tym warunkiem jest oczywiście naciśnięcie konkretnego klawisza:

if key= #48 then //jeżeli naciśnięto klawisz '0', wtedy...

begin

Opcja_niedostepna;

end;

     Aby móc w ten sposób korzystać z dobrodziejstw Delphi, musimy w Inspektorze Obiektów zmienić właściwość KeyPreview, z false na true. Polecenie to nakaże naszemu programowi przeglądanie klawiatury, czy czasem nie został naciśnięty jakiś klawisz.

     W powyższym przykładzie, po spełnieniu warunku, czyli po naciśnięciu klawisza zero, zostaje uruchomiona procedura Opcja_niedostepna. Jest ona wykonawcą wszystkich pozostałych warunków, nie tylko tej metody, ale także pozostałych. Analizując ową procedurę widzimy, że zawiera ona tylko jedno polecenie, ma wyświetlić komunikat ShowMessage z napisem „Opcja niedostępna”. Procedurę tę utworzyliśmy celowo, aby ukazać, że w bloku begin...end możemy zawrzeć wszystko, każdy sensowny kod do wykonania. Komunikat ten przyda się nam szczególnie wtedy, kiedy będziemy chcieli zastosować przechwyt większej części klawiszy, lecz nie dla wszystkich będziemy mieli jeszcze zastosowanie. Możemy wtedy umieścić taki tymczasowy komunikat, że ta opcja na razie jest nieaktywna.

Kody klawiszy

     W jednej z zabaw wspominaliśmy już, że każdy klawisz ma swój własny identyfikator. Kiedy budowaliśmy ograniczenia dla klawiszy, w polu do wpisywania odpowiedzi (zdarzenie Edit.KeyPress), używaliśmy na przykład klawiszy Backpace (#8) i minusa (#45). Każdy z klawiszy posiada taki kod. Możemy uznać, iż jest to ta informacja płynąca z klawiatury, który klawisz został naciśnięty. Na tej podstawie budujemy właśnie warunek sprawdzający: „Jeżeli (if) został naciśnięty klawisz „0” (key:= #48), wtedy (then) wykonaj instrukcje zawarte w bloku begin...end”. Ot, i cała filozofia...

     Eksperymentując z kodami poszczególnych klawiszy, zauważymy, że metoda Key Press nie zawsze działa. Pomimo wpisania właściwego kodu klawisza, nic się nie dzieje. Wynika to głównie ze „słabości” tej metody. Niektóre klawisze, jak na przykład F2 (pomoc), czy Esc (wyjdź) są domyślnie zarezerwowane dla pewnych ogólnie przyjętych działań i nie dają się przechwycić taką prostą metodą. Analizując tabelę, widzimy jednak, że można to uczynić, stosując bardziej zaawansowane rozwiązania.

     Metoda Key Press wiedzie prym w przechwytywaniu klawiszy standardowych, powszechnie używanych, czyli przede wszystkim klawiszy cyfr i liter, oraz ich kombinacji z klawiszem rozszerzonym Shift. Jako sugestię tylko wskażemy na zależność, że naciśnięcie klawisza z literką „a” przy włączonym przycisku Caps Lock da nam dużą literę „A”. Tę samą dużą literę da w normalnych warunkach kombinacja klawiszy Shift i „a” (Shift+a). Dla małej literki „a” (czyli, gdy Caps Lock jest wyłączony) kod klawisza będzie wynosił #97. W przypadku naciśnięcia tego samego klawisza przy włączonym Caps Lock, kod będzie wynosił #65, czyli będzie taki sam, jak dla kombinacji Shift+a.

Czas zapoznać się z kodem tej metody:

 

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;

type

TForm1 = class(TForm)

procedure Opcja_niedostepna;

procedure FormKeyPress(Sender: TObject; var Key: Char);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

// PROCEDURA OPCJA NIEDOSTEPNA //

procedure TForm1.Opcja_niedostepna;

begin

ShowMessage('Opcja niedostępna');

end;

       ///////////////// przechwyt klawiszy ////////////////////

 

procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char);

begin

if key= #48 then //jezeli nacisnieto klawisz 0, wtedy...

begin

Opcja_niedostepna;

end;

if key= #49 then //jezeli nacisnieto klawisz 1, wtedy...

begin

Opcja_niedostepna;

end;

if key= #50 then //jezeli nacisnieto klawisz 2, wtedy...

begin

Opcja_niedostepna;

end;

Przechwyt klawiatury w Delphi

Wstęp

     Programowanie w języku Delphi umożliwia nie tylko tworzenie programów, ale także sterowanie podzespołami komputera takimi, jaki monitor, napęd CD\DVD, czy porty szeregowe i równoległe. Zwiększa to znacznie możliwości dla naszych projektów, dzięki czemu możemy z nimi wyjść na zewnątrz komputera.

     Nieodzownym elementem większości programów jest interfejs i sterowanie. To dzięki nim użytkownik może realizować swoje zamierzenia, wykorzystując do tego program. Przeważnie odbywa się to za pomocą klikania myszką w wirtualny przycisk, umieszczony na interfejsie programu. Jest to wygodne rozwiązanie dla zwykłych (graficznych) programów komputerowych. Co jednak zrobić w przypadku, gdybyśmy chcieli stworzyć jakiś mobilny projekt, na przykład poruszającego się robota? Chodzenie za nim i uważanie, aby nas nie rozjechał podczas klikania w jego interfejs, nie wchodzi przecież w rachubę. Musimy stworzyć sterowanie jego funkcjami na innej zasadzie.

     Pierwszym, najbardziej naturalnym rozwiązaniem tej kwestii jest klawiatura. Jeżeli użyjemy na dodatek klawiatury bezprzewodowej, mamy w pełni mobilną jednostkę. Nie jest to jednak takie proste. Co prawda klawiatura posiada wystarczająco dużo klawiszy, a w połączeniu ze skrótami klawiaturowymi (czyli naciśnięcie kilku klawiszy jednocześnie) ma ich całą masę (kilkaset), jednak każdy z nich ma swoje przeznaczenie. Nie możemy więc ich wykorzystać w sposób bezpośredni.

    Narzędzia programistyczne radzą sobie jednak doskonale z tego typu problemami. Klawiatura komunikuje się z komputerem, wysyłając doń komunikat, który klawisz został naciśnięty. Na podstawie uzyskanych informacji, komputer wykonuje zadanie przypisane do tego klawisza. Jeżeli, powiedzmy, naciśniemy klawisz z literką „a” nic się nie stanie, gdyż system z niego nie korzysta. Wystarczy jednak uruchomić jakikolwiek edytor tekstu (chociażby WordPad), aby przekonać się, że ten klawisz jest jednak potrzebny.

     Chcąc wykorzystać poszczególne klawisze do swoich celów lub zmienić ich przeznaczenie, musimy przechwycić komunikaty, które są wysyłane do komputera. Po ich przechwyceniu, wydajemy komputerowi własne komendy. Nic więc nie stoi na przeszkodzie, aby komputer po naciśnięciu klawisza „a” wykonał jakąś czynność, odtworzył muzykę lub na przykład, wyłączył się. Powyższy zabieg nazywamy przechwytem klawiatury lub, częściej, z anglojęzycznego oryginału, hookiem: zakładaniem hooka na klawiaturę.

Hook

     Przy pomocy hooka możemy przejąć kontrolę nad każdym klawiszem klawiatury oraz utworzyć skróty klawiaturowe z wykorzystaniem klawiszy rozszerzonych, czyli Ctrl, Alt, Shift, Win, a nawet ich kombinacje, jak ctrl+alt+klawisz. Czym zatem jest ów hook? Jest to procedura, jedna z wielu, która odbiera od klawiatury informacje o tym, jaki klawisz lub klawisze zostały naciśnięte i na tej podstawie wykonuje działanie, które dla tego przypadku wcześniej zdefiniowaliśmy.

Hook to nie jest tylko jedna procedura. Jest to raczej ogólna nazwa procesu przechwytywania klawiatury, a konkretnych procedur, które to realizują, jest kilka. Zazwyczaj uzupełniają się one wzajemnie. Przedstawimy trzy oddzielne procedury, które przechwytują klawiaturę. Oto one: 

- Key Press, 

- Short Cut,

- Hot Key.

     Każda z tych procedur króluje w pewnym, swoim tylko zakresie, lecz połączone razem, doskonale się uzupełniają. Poniższa tabela przedstawia możliwości poszczególnych procedur: