Visual Studio 2005. Programowanie z Windows API w języku C++

Visual Studio 2005.
Programowanie
z Windows API w jêzyku C++
Autor: Piotr Besta
ISBN: 978-83-246-1567-4
Format: 158x235, stron: 728

Napisz w³asne aplikacje dla systemu Windows
• Jak tworzyæ okna, menu i elementy graficzne?
• W jaki sposób zarz¹dzaæ zasobami aplikacji?
• Jak budowaæ aplikacje wielow¹tkowe?
System operacyjny to nie tylko œrodowisko, w którym mo¿emy uruchamiaæ
zainstalowane programy – to tak¿e Ÿród³o zasobów dla programów tworzonych przez
nas samych. Ka¿da aplikacja dla systemu Windows, w której mo¿na znaleŸæ ikony,
okna dialogowe, paski przewijania i inne powszechnie znane elementy, korzysta
z bibliotek zwanych Windows API – zestawu funkcji u³atwiaj¹cych zaprogramowanie
okreœlonych komponentów. Dziêki zastosowaniu Windows API mo¿emy umieszczaæ
w naszych aplikacjach typowe dla systemu operacyjnego sk³adniki interfejsu
u¿ytkownika i modu³y wykorzystuj¹ce urz¹dzenia zewnêtrzne.
Ksi¹¿ka „Visual Studio 2005. Programowanie z Windows API w jêzyku C++”
to podrêcznik, dziêki któremu poznasz metody tworzenia programów dla systemu
operacyjnego Windows. Nauczysz siê korzystaæ z systemowego API w celu
zaimplementowania w aplikacji mechanizmów interfejsu u¿ytkownika, wyœwietlania
elementów graficznych i obs³ugiwania przetwarzania wielow¹tkowego. Dowiesz siê,
jak wykorzystywaæ zasoby programowe, budowaæ biblioteki statyczne i biblioteki DLL,
obs³ugiwaæ mysz i klawiaturê oraz mierzyæ czas. Przeczytasz o tym, jak dzia³aj¹ aplikacje
dla systemu Windows, i zdobêdziesz wiedzê niezbêdn¹ do tego, by tworzyæ w³asne!
• Tworzenie okien i umieszczanie w nich tekstów oraz elementów graficznych
• Korzystanie z GDI
• Wyœwietlanie map bitowych
• Tworzenie bibliotek statycznych
• Obs³uga klawiatury i myszy
Wydawnictwo Helion • Zarz¹dzanie zasobami aplikacji
ul. Koœciuszki 1c • Budowanie okien dialogowych
44-100 Gliwice • Korzystanie z kontrolek
tel. 032 230 98 63 • Obs³uga wielozadaniowoœci i wielow¹tkowoœci
e-mail: helion@helion.pl Poznaj techniki i metody tworzenia aplikacji dla systemu operacyjnego Windows

Spis tre ci
Wstöp .............................................................................................. 9
Rozdziaä 1. WinMain — fundament aplikacji Windows ....................................... 11
1.1. Pierwszy program .................................................................................................. 11
1.1.1. Tworzymy projekt aplikacji ......................................................................... 12
1.1.2. Dodajemy do projektu plik kodu .................................................................. 16
1.1.3. Piszemy kod programu ................................................................................. 17
1.1.4. Funkcja MessageBox ................................................................................... 19
1.1.5. Kompilujemy kod i uruchamiamy program ................................................. 22
1.2. Wi cej o Visual Studio .......................................................................................... 24
1.2.1. Konfiguracja Debug i Release ..................................................................... 24
1.2.2. Biblioteki statyczne ...................................................................................... 26
1.3. Tworzenie okna ..................................................................................................... 27
1.3.1. Klasa okna ................................................................................................... 28
1.3.2. Rejestracja klasy okna .................................................................................. 34
1.3.3. Jak wyrejestrowaü klas okna? .................................................................... 35
1.3.4. Funkcja CreateWindowEx ........................................................................... 35
1.3.5. Wy wietlanie okna ....................................................................................... 38
1.3.6. Procedura okna ............................................................................................ 39
1.3.7. Kolejka wiadomo ci ..................................................................................... 40
1.3.8. P tla wiadomo ci ......................................................................................... 40
1.3.9. Definicja procedury okna ............................................................................. 43
1.3.10. Przetwarzanie wiadomo ci ......................................................................... 45
1.3.11. Wiadomo ci WM_CREATE i WM_DESTROY ....................................... 46
1.3.12. Projekt: Okno ............................................................................................. 47
Rozdziaä 2. Rysowanie w oknie ........................................................................ 51
2.1. Wiadomo ü WM_PAINT ...................................................................................... 51
2.1.1. Jak uniewa niü prostok tny fragment obszaru roboczego? .......................... 52
2.1.2. Jak zatwierdziü prostok tny fragment obszaru roboczego? ......................... 53
2.1.3. Obsáugiwanie wiadomo ci WM_PAINT ..................................................... 53
2.2. Kontekst urz dzenia ............................................................................................... 57
2.2.1. Czym jest kontekst urz dzenia? ................................................................... 58
2.2.2. Wáa ciwo ci kontekstu urz dzenia ............................................................... 58
2.2.3. Pobieranie uchwytu kontekstu urz dzenia ................................................... 64
2.2.4. Inne operacje na kontek cie urz dzenia ....................................................... 65
2.3. Wy wietlanie tekstu ............................................................................................... 66
2.3.1. Funkcja DrawText ....................................................................................... 67
2.3.2. Wiadomo ci WM_SYSCOMMAND i WM_CLOSE .................................. 68
2.3.3. Projekt: Tekst w oknie 01 ............................................................................ 71
2.3.4. Pobieranie informacji o czcionce ................................................................. 74

4 Visual Studio 2005. Programowanie z Windows API w jözyku C++

2.3.5. Zmiana domy lnej czcionki ......................................................................... 77
2.3.6. Tworzenie nowej czcionki ........................................................................... 79
2.3.7. Funkcja TextOut .......................................................................................... 84
2.3.8. Wi cej okien? .............................................................................................. 85
2.3.9. Niszczenie okna ........................................................................................... 85
2.3.10. Zmiana wáa ciwo ci okna .......................................................................... 86
2.3.11. Wiadomo ci WM_SETFOCUS, WM_KILLFOCUS
i WM_ACTIVATE .................................................................................... 88
2.3.12. Projekt: Tekst w oknie 02 .......................................................................... 90
2.4. Rysowanie pikseli, linii, prostok tów, kóá, elips i wielok tów .............................. 99
2.4.1. Rysowanie pikseli ...................................................................................... 100
2.4.2. Rysowanie linii .......................................................................................... 101
2.4.3. Rysowanie prostok tów ............................................................................. 103
2.4.4. Rysowanie kóá i elips ................................................................................. 105
2.4.5. Rysowanie wielok tów .............................................................................. 106
2.5. Obiekty GDI ........................................................................................................ 107
2.5.1. Pióra ........................................................................................................... 108
2.5.2. P dzle ......................................................................................................... 113
2.5.3. Regiony ...................................................................................................... 118
2.5.4. Projekt: Malarz .......................................................................................... 129
2.5.5. Pobieranie aktualnego obiektu kontekstu urz dzenia ................................. 140
2.6. Bitmapy ............................................................................................................... 141
2.6.1. Czym jest bitmapa? .................................................................................... 142
2.6.2. àadowanie bitmapy do pami ci operacyjnej .............................................. 143
2.6.3. Przykáad u ycia funkcji LoadImage ........................................................... 146
2.6.4. Pobieranie informacji o zaáadowanej bitmapie .......................................... 147
2.6.5. Reprezentacja bitmapy w pami ci .............................................................. 148
2.6.6. Wy wietlanie bitmapy ............................................................................... 149
2.6.7. Rysowanie po powierzchni bitmapy .......................................................... 164
2.6.8. Przenoszenie obrazu mi dzy bitmapami .................................................... 167
2.6.9. Oczekiwanie na wiadomo ü ....................................................................... 171
2.6.10. Wiadomo ci WM_MOVE i WM_SIZE ................................................... 176
2.6.11. Projekt: Gaz ............................................................................................. 177
2.6.12. Tworzenie wáasnych bitmap .................................................................... 196
2.6.13. Zapisywanie bitmapy do pliku BMP ........................................................ 200
2.6.14. Projekt: Spektrum barw ........................................................................... 217
2.7. Pobieranie informacji o ustawieniach systemu i kontekstu urz dzenia ................ 228
2.7.1. Informacje o systemie ................................................................................ 228
2.7.2. Informacje o kontek cie urz dzenia ........................................................... 231
2.7.3. Zamykanie i resetowanie systemu .............................................................. 232
2.7.4. Praca ze strukturami RECT ........................................................................ 234
Rozdziaä 3. Tworzenie i korzystanie z biblioteki statycznej ............................... 239
3.1. Czym jest biblioteka statyczna? ........................................................................... 239
3.2. Po co tworzymy biblioteki statyczne? .................................................................. 240
3.3. Przykáad utworzenia biblioteki ............................................................................ 241
3.3.1. Dodajemy do biblioteki funkcje matematyczne ......................................... 243
3.3.2. Dodajemy do biblioteki klas CKot ........................................................... 245
3.3.3. Kompilacja biblioteki ................................................................................. 251
3.4. Testowanie biblioteki ........................................................................................... 252
3.4.1. Tworzymy aplikacj konsolow ................................................................ 252
3.4.2. Dodajemy do aplikacji bibliotek i pliki nagáówkowe ............................... 256
3.4.3. Piszemy kod programu testowego .............................................................. 258
3.5. Operatory new i delete ......................................................................................... 261

Spis tre ci 5

Rozdziaä 4. Klawiatura ................................................................................... 267
4.1. Jak to dziaáa w Windows? .................................................................................... 267
4.2. Wirtualne klawisze .............................................................................................. 268
4.3. Wiadomo ci WM_KEYDOWN i WM_KEYUP ................................................. 270
4.4. Wiadomo ü WM_CHAR ..................................................................................... 273
4.5. Wiadomo ci WM_SYSKEYDOWN i WM_SYSKEYUP ................................... 275
4.6. Niezale ne pobieranie informacji o stanie klawiszy ............................................ 276
4.7. Projekt: Klawiatura .............................................................................................. 277
Rozdziaä 5. Mysz ............................................................................................. 285
5.1. Mysz w Windows ................................................................................................ 285
5.2. Kursor myszy ....................................................................................................... 286
5.3. Wiadomo ci myszy .............................................................................................. 286
5.4. Obsáuga podwójnego klikni cia ........................................................................... 288
5.5. Niezale ne pobieranie i ustalanie pozycji kursora myszy .................................... 289
5.6. Przechwycenie myszy .......................................................................................... 290
5.7. Sterowanie wy wietlaniem kursora ...................................................................... 292
5.8. Projekt: Mysz ....................................................................................................... 293
Rozdziaä 6. Odmierzanie czasu ....................................................................... 301
6.1. Pobieranie systemowego czasu i daty z dokáadno ci do milisekundy ................ 301
6.2. Systemowy licznik milisekund ............................................................................ 303
6.3. Korzystanie z zegara systemowego ..................................................................... 306
6.3.1. Tworzenie wáasnych zegarów .................................................................... 306
6.3.2. Techniki tworzenia zegara ......................................................................... 308
6.3.3. Definiowanie funkcji zegara ...................................................................... 309
6.3.4. U miercanie zegarów ................................................................................. 309
6.4. Projekt: Minuta .................................................................................................... 310
6.4.1. Dokáadne wyznaczanie rozmiaru okna w oparciu o dany rozmiar
obszaru roboczego ..................................................................................... 318
6.5. Specjalistyczne odmierzanie czasu ...................................................................... 320
6.6. Klasa CCzas ......................................................................................................... 323
6.7. Projekt: Stoper ..................................................................................................... 327
6.7.1. Odtwarzanie plików d wi kowych WAV za pomoc funkcji PlaySound .... 339
Rozdziaä 7. Zasoby aplikacji ........................................................................... 341
7.1. Zarz dzanie zasobami .......................................................................................... 342
7.2. Projekt: Kursor i ikona ......................................................................................... 342
7.2.1. Kursory ...................................................................................................... 343
7.2.2. Ikony .......................................................................................................... 350
7.2.3. Odwoáywanie si do zasobów .................................................................... 352
7.2.4. Piszemy kod dla projektu „Kursor i ikona” ................................................ 353
7.3. Zmiana i pobieranie ustawie klasy okna ............................................................ 358
7.4. Projekt: Bitmapa i áa cuchy znaków .................................................................... 360
7.4.1. Bitmapy ...................................................................................................... 360
7.4.2. Tablice áa cuchów znakowych .................................................................. 362
7.4.3. Piszemy kod dla projektu Bitmapa i áa cuchy znaków .............................. 365
7.5. Wysyáanie wiadomo ci do okna .......................................................................... 373
7.6. Projekt: Gáówne menu okna ................................................................................. 375
7.6.1. Jak zbudowane jest menu? ......................................................................... 375
7.6.2. Elementy menu .......................................................................................... 376
7.6.3. Tworzenie menu za pomoc edytora .......................................................... 376
7.6.4. àadowanie menu z zasobów i podá czanie do okna ................................... 381
7.6.5. Niszczenie menu ........................................................................................ 383
7.6.6. Wiadomo ci okna zwi zane z menu .......................................................... 383


7.6.7. Zaznaczanie elementów menu ................................................................... 386
7.6.8. Radiowe elementy menu ............................................................................ 388
7.6.9. Sterowanie dost pno ci elementów menu ................................................ 389
7.6.10. Pobieranie uchwytu gáównego menu i uchwytów podmenu .................... 390
7.6.11. Pobieranie informacji o stanie elementu menu ......................................... 391
7.6.12. Piszemy kod dla projektu „Gáówne menu okna” ..................................... 393
7.6.13. Tworzenie menu w trakcie pracy programu ............................................. 401
7.6.14. Modyfikowanie menu w trakcie pracy programu ..................................... 405
7.6.15. Wy wietlanie elementu menu za pomoc bitmapy .................................. 413
7.6.16. Zmieniamy bitmap zaznaczenia elementu menu .................................... 415
7.6.17. Inne operacje przeprowadzane na elementach menu ................................ 416
7.7. Projekt: Menu kontekstowe i systemowe ............................................................. 418
7.7.1. Menu kontekstowe ..................................................................................... 418
7.7.2. Menu systemowe ....................................................................................... 422
7.7.3. Piszemy kod dla projektu „Menu kontekstowe i systemowe” .................... 424
7.8. Projekt: Skróty klawiaturowe ............................................................................... 431
7.8.1. Tworzenie tablicy skrótów klawiaturowych .............................................. 432
7.8.2. àadowanie tablicy skrótów klawiaturowych .............................................. 434
7.8.3. Tworzenie tablicy skrótów klawiaturowych w trakcie pracy programu ..... 435
7.8.4. Táumaczenie skrótów klawiaturowych na wiadomo ci
WM_COMMAND i WM_SYSCOMMAND ............................................ 437
7.8.5. Piszemy kod dla projektu „Skróty klawiaturowe” ..................................... 439
7.9. Projekt: Niestandardowe zasoby .......................................................................... 447
7.9.1. Tworzenie niestandardowych zasobów ...................................................... 448
7.9.2. àadowanie niestandardowych zasobów ..................................................... 450
7.9.3. Odczytywanie danych z niestandardowych zasobów ................................. 451
7.9.4. Piszemy kod dla projektu „Niestandardowe zasoby” ................................. 452
7.10. Biblioteka á czona dynamicznie jako zewn trzne ródáo zasobów i kodu ........... 456
7.10.1. Jak dziaáaj biblioteki DLL? .................................................................... 456
7.10.2. Projekt: Pierwszy DLL ............................................................................. 457
7.10.3. DllMain — gáówna funkcja biblioteki DLL ............................................. 459
7.10.4. Dodajemy do biblioteki DLL funkcj ...................................................... 461
7.10.5. Dodajemy do biblioteki DLL zmienne ..................................................... 466
7.10.6. Kompilacja i konsolidacja biblioteki DLL ............................................... 467
7.10.7. Wspóáu ytkowanie zmiennych biblioteki DLL przez wiele aplikacji ...... 467
7.10.8. àadowanie biblioteki DLL w trakcie pracy programu i pobieranie
adresów funkcji ....................................................................................... 470
7.10.9. Umieszczanie zasobów w bibliotece DLL i ich wykorzystywanie .......... 472
7.10.10. Projekt: Test biblioteki DLL .................................................................. 473
7.11. Szerokie znaki — UNICODE .............................................................................. 478
7.11.1. Typ danych char ....................................................................................... 479
7.11.2. Typ danych wchar_t ................................................................................. 481
7.11.3. Ogólny znakowy typ danych .................................................................... 483
7.11.4. Szerokie znaki i funkcje ........................................................................... 485
Rozdziaä 8. Okna dialogowe ........................................................................... 489
8.1. Modalne okna dialogowe ..................................................................................... 491
8.2. Projekt: Modalne okno dialogowe ....................................................................... 491
8.2.1. Dodajemy do zasobów programu okno dialogowe .................................... 491
8.2.2. Procedura okna przetwarzaj ca wiadomo ci okna dialogowego ................ 495
8.2.3. Wiadomo ü WM_INITDIALOG ............................................................... 497
8.2.4. Przesuwanie okna i pobieranie uchwytu okna nadrz dnego ...................... 498
8.2.5. Tworzenie, wy wietlanie i zamykanie modalnego okna dialogowego ....... 499
8.2.6. Piszemy kod dla projektu „Modalne okno dialogowe” .............................. 501

Spis tre ci 7

8.3. Niemodalne okna dialogowe ................................................................................ 508
8.4. Projekt: Niemodalne okno dialogowe .................................................................. 509
8.4.1. Tworzenie, wy wietlanie i zamykanie niemodalnego okna dialogowego ..... 509
8.4.2. Wysyáanie wiadomo ci do niemodalnego okna dialogowego .................... 511
8.4.3. Piszemy kod dla projektu „Niemodalne okno dialogowe” ......................... 512
8.5. Predefiniowane okna dialogowe systemu ............................................................ 521
8.5.1. Otwieranie plików ...................................................................................... 522
8.5.2. Wskazywanie plików do zapisu ................................................................. 527
8.5.3. Wybieranie koloru ..................................................................................... 528
8.5.4. Tworzymy klas CSystemoweDlg ............................................................. 530
8.5.5. Projekt: Systemowe okna dialogowe ......................................................... 534
Rozdziaä 9. Kontrolki ...................................................................................... 547
9.1. Jak dziaáaj kontrolki? ......................................................................................... 547
9.2. Kontrolki klasy Button ......................................................................................... 549
9.2.1. Projekt: Prosty przycisk ............................................................................. 549
9.2.2. Typy i style przycisków ............................................................................. 555
9.2.3. Kody powiadomienia przycisków .............................................................. 562
9.2.4. Wiadomo ci kontrolne przycisków ............................................................ 562
9.2.5. Praca w edytorze okien dialogowych ......................................................... 564
9.2.6. Projekt: Przyciski ....................................................................................... 566
9.3. Kontrolki klasy Edit ............................................................................................. 583
9.3.1. Style pola edycji ......................................................................................... 583
9.3.2. Kody powiadomienia pola edycji ............................................................... 584
9.3.3. Wiadomo ci kontrolne pola edycji ............................................................. 585
9.3.4. Umieszczanie i pobieranie warto ci liczbowych z pola edycji ................... 587
9.3.5. Projekt: Pole edycji .................................................................................... 588
9.4. Kontrolki klasy Static .......................................................................................... 596
9.4.1. Style kontrolek statycznych ....................................................................... 596
9.4.2. Wiadomo ci kontrolne kontrolek statycznych ........................................... 597
9.5. Kontrolki klasy ComboBox ................................................................................. 597
9.5.1. Style kontrolki ComboBox ........................................................................ 598
9.5.2. Kody powiadomienia kontrolki ComboBox .............................................. 599
9.5.3. Wiadomo ci kontrolne ComboBox ............................................................ 599
9.5.4. Projekt: ComboBox ................................................................................... 603
9.6. Wygl d kontrolek w systemie Windows XP ........................................................ 612
9.6.1. Tworzenie manifestu .................................................................................. 613
9.6.2. Dodawanie manifestu do projektu aplikacji ............................................... 615
Rozdziaä 10. Paski przewijania ......................................................................... 617
10.1. Rozmiar pasków przewijania ............................................................................... 617
10.2. Budowa pasków przewijania ............................................................................... 618
10.3. Wiadomo ci WM_HSCROLL i WM_VSCROLL ............................................... 619
10.4. Pobieranie i ustawianie stanu pasków przewijania .............................................. 621
10.5. Wy wietlanie, ukrywanie, wá czanie i wyá czanie pasków przewijania .............. 624
10.6. Przewijanie obszaru roboczego okna ................................................................... 625
10.7. Projekt: Ogromne bitmapy ................................................................................... 626
Rozdziaä 11. Procesy i wñtki ............................................................................ 641
11.1. Wielozadaniowo ü ............................................................................................... 641
11.1.1. Tworzenie nowego procesu ...................................................................... 643
11.1.2. Projekt: Nowy proces ............................................................................... 644
11.1.3. Natychmiastowe ko czenie pracy aplikacji ............................................. 648


11.2. Wielow tkowo ü .................................................................................................. 648
11.2.1. Kiedy korzystamy z dodatkowych w tków? ............................................ 649
11.2.2. Tworzenie w tków ................................................................................... 650
11.2.3. Funkcja w tku .......................................................................................... 652
11.2.4. Ko czenie pracy w tków ......................................................................... 652
11.2.5. Usypianie w tków .................................................................................... 654
11.2.6. Projekt: Pierwszy w tek ........................................................................... 654
11.2.7. Projekt: Wi cej w tków ........................................................................... 656
11.2.8. Zmienne globalne programu a zmienne automatyczne
i statyczne w tków ................................................................................... 658
11.2.9. Zawieszanie i przywracanie pracy w tków .............................................. 658
11.2.10. Projekt: Zawieszanie w tku ................................................................... 659
11.2.11. Pobieranie uchwytu w tku ..................................................................... 661
11.2.12. Problemy z w tkami ............................................................................... 661
11.2.13. Metody synchronizacji pracy w tków .................................................... 662
11.2.14. Oczekiwanie na sygnalizowanie pojedynczego obiektu ......................... 662
11.2.15. Projekt: Oczekiwanie na koniec w tku .................................................. 663
11.2.16. Oczekiwanie na sygnalizowanie wielu obiektów ................................... 665
11.2.17. Projekt: Oczekiwanie na koniec wielu w tków ...................................... 666
11.2.18. Zdarzenia ............................................................................................... 668
11.2.19. Projekt: Zdarzenia .................................................................................. 669
11.2.20. Muteksy ................................................................................................. 674
11.2.21. Projekt: Muteks ...................................................................................... 675
11.2.22. Semafory ................................................................................................ 679
11.2.23. Projekt: Semafor .................................................................................... 681
Rozdziaä 12. Nie tylko Windows API ................................................................. 685
12.1. Biblioteka DirectX ............................................................................................... 685
12.2. Konfiguracja Visual Studio .................................................................................. 688
12.3. Obiekt Direct3D ................................................................................................... 689
12.3.1. Tworzenie obiektu Direct3D .................................................................... 690
12.3.2. Pobieranie informacji o karcie graficznej ................................................ 692
Dodatek A ...................................................................................................... 697
Kody ASCII .................................................................................................................. 697
Kody skaningowe klawiatury ....................................................................................... 699
Skorowidz .................................................................................... 701

Rozdziaä 4.
Klawiatura
Nadeszáa najwy sza pora, aby nauczyü si posáugiwania klawiatur . Oczywi cie, mam tu
na my li obsáug zwi zan z czysto programistycznym punktem widzenia. Zaczn od
szybkiego omówienia podstaw dziaáania klawiatury. Nast pnie dowiesz si , jak system
Windows wspóápracuje z klawiatur , jak tworzone s wiadomo ci zwi zane z zdarzeniami
klawiatury oraz w jaki sposób s pó niej wstawiane do kolejki wiadomo ci aplikacji.

Potem wyja ni , czym jest wirtualny klawisz, i powiem, jak odbieraü wiadomo ci z nim
zwi zane. Tu dowiesz si te , jak bez udziaáu procedury okna sprawdzaü stan poszcze-
gólnych klawiszy klawiatury. Poznasz wiadomo ü systemow zwi zan z obieraniem
wyá cznie znaków tekstowych generowanych za pomoc klawiatury. Na zako czenie
rozdziaáu napisz przykáadowy program, który b dzie przechwytywaá informacje o naci-
ni tych klawiszach klawiatury, po czym b dzie je wy wietlaá w oknie.

4.1. Jak to dziaäa w Windows?
Klawiatura to podstawowe urz dzenie, za którego pomoc u ytkownik komunikuje si
z systemem zainstalowanym na komputerze. Dzisiaj klawiatura tak mocno zakorzeniáa
si w naszym yciu, e dla sporej grupy ludzi stanowi codzienne, nieodá czne narz dzie
pracy. Jednym sáowem, trudno wyobraziü sobie dzisiaj wiat bez niej, ale jeszcze trudniej
wyobraziü sobie alternatywne urz dzenie, które mogáoby zast piü klawiatur . Wydawaü
si mo e, e nic nie zast pi klawiszy nawet wtedy, gdy klawiatura b dzie páaska jak
kartka papieru i prze roczysta jak powietrze.

Spotykane dzisiaj klawiatury skáadaj si najcz ciej ze 101 lub 102 klawiszy. S to tzw.
klawiatury rozszerzone, gdy niektóre klawisze zostaáy zdublowane, co — jak by nie
patrzeü — bardzo uáatwia prac .

Ka da klawiatura posiada wbudowany mikroprocesorowy ukáad kontroluj cy kilkadzie-
si t razy w ci gu sekundy stan wszystkich klawiszy. Zebrane informacje s formowane
w pakiety danych, wysyáane nast pnie do jednego z portów wej ciowych komputera.


System Windows w odpowiedzi na przyci ni cie lub zwolnienie klawisza generuje
odpowiedni wiadomo ü. Utworzona wiadomo ü jest przypisywana zawsze do tego
okna, które byáo aktywne w momencie zaistnienia zdarzenia zwi zanego z klawiatur .
Nast pnie wiadomo ü jest wstawiana do systemowej kolejki wiadomo ci. Sk d dalej trafia
do kolejki wiadomo ci wybranej aplikacji. Najwa niejsze jest to, aby pami taá, e system
nie umieszcza nast pnej wiadomo ci zwi zanej ze zdarzeniem klawiatury w kolejce wia-
domo ci aplikacji, dopóki poprzednia wiadomo ü nie zostanie obsáu ona.

4.2. Wirtualne klawisze
Ukáad mikroprocesorowy klawiatury po wykryciu, e który z klawiszy zostaá naci ni ty,
generuje i wysyáa do komputera tzw. kod skaningowy klawisza (kody skaningowe kla-
wiszy zostaáy podane w dodatku A). Przykáadowo klawiszowi A odpowiada kod o war-
to ci 30. Gdy klawisz jest zwalniany, generowany jest ten sam kod skaningowy, z t ró -
nic , e jego warto ü zostaje powi kszona o 128. Po zwolnieniu klawisza A otrzymujemy
kod 158 (128+30).

Pami taj, aby nie myliü kodów skaningowych klawiszy (Original Equipment Manufac-
turer — OEM) z kodem ASCII (American Standards Committee for Information Inter-
change) i z kodami ANSI (American National Standards Institute). Kody ANSI i ASCII
s budowane na podstawie kodu skaningowego, przy uwzgl dnieniu dodatkowych czyn-
ników maj cych wpáyw na stan klawiatury. Te czynniki to stan klawiszy Caps Lock
(du e, maáe litery), Shift (górne znaki klawiszy) oraz Num Lock (aktywna, nieaktywna
klawiatura numeryczna). Mo emy rozró niü 256 kodów ANSI i ASCII (kody ASCII
znajduj si w dodatku A na ko cu ksi ki).

Jak widzisz, za pomoc pojedynczego kodu skaningowego nie jeste my w stanie stwier-
dziü, czy u ytkownik chciaá napisaü du liter , czy maá . Aby poznaü t informacj ,
nale y kontrolowaü klawisze steruj ce stanem klawiatury. Nie martw si . Mam dla
Ciebie bardzo dobr wiadomo ü. Nie b dziemy korzystali bezpo rednio z kodów ska-
ningowych. Dlaczego? Kody skaningowe maj t brzydk cech , e s zale ne od sprz tu.
Mimo ogólnie przyj tych na wiecie standardów wyznaczaj cych parametry produko-
wanych klawiatur i ich ukáadów mikroprocesorowych, mo emy spotkaü takie klawia-
tury, które dla klawisza A wygeneruj odmienny kod skaningowy. Oczywi cie, s to
sytuacje marginalne. Dzisiaj programi ci Windows nie musz si w ogóle tym przejmo-
waü. Byáo to jednak szczególnie irytuj ce dla twórców systemu Windows w jego wcze-
snych latach „ ycia”.

Aby rozwi zaü problem, postanowiono opracowaü niezale ne, oderwane od sprz tu kla-
wisze wirtualne. Kody wirtualnych klawiszy, z wyj tkiem kodów klawiszy literowych
i klawiszy numerycznych z podstawowej cz ci klawiatury (nienumerycznej), s odmienne
od kodów skaningowych, kodów ASCII i ANSI. Wirtualne klawisze nie istniej , s one
wytworem swoistej interpretacji kodów skaningowych klawiszy przeprowadzonej przez
system Windows.

Rozdzia 4. i Klawiatura 269

Wszystkim wirtualnym klawiszom, z wyj tkiem klawiszy literowych i numerycznych
podstawowej klawiatury, zostaá przypisany identyfikator. Identyfikatory rozpoczynaj si
od przedrostka VK (ang. Virtual Key). Ich definicja znajduje si w pliku nagáówkowym
winuser.h. Najwa niejsze identyfikatory zebraáem w tabeli 4.1. Zwróü uwag na to, e
klawisze literowe i numeryczne posiadaj jedynie kod wirtualnego klawisza.

Tabela 4.1. Kod klawiszy wirtualnych
Kod dziesiötnie Kod szesnastkowo Identyfikator Uwagi o wirtualnym klawiszu
8 0x08 VK_BACK Backspace
9 0x09 VK_TAB Tab
13 0x0D VK_RETURN Jeden z klawiszy Enter
16 0x10 VK_SHIFT Jeden z klawiszy Shift
17 0x11 VK_CONTROL Jeden z klawiszy Ctrl
18 0x12 VK_MENU Jeden z klawiszy Alt
20 0x14 VK_CAPITAL Caps Lock
27 0x1B VK_ESCAPE Esc
32 0x20 VK_SPACE Spacja
33 0x21 VK_PRIOR Page Up
34 0x22 VK_NEXT Page Down
35 0x23 VK_END End
36 0x24 VK_HOME Home
37 0x25 VK_LEFT Strzaáka w lewo
38 0x26 VK_UP Strzaáka w gór
39 0x27 VK_RIGHT Strzaáka w prawo
40 0x28 VK_DOWN Strzaáka w dóá
44 0x2C VK_SNAPSHOT Print Screen
45 0x2D VK_INSERT Insert
46 0x2E VK_DELETE Delete
48 – 57 0x30 – 0x39 nie ma Klawisze numeryczne od 0 do 9
z podstawowej cz ci klawiatury
65 – 90 0x41 – 0x5A nie ma Klawisze literowe od A do Z
91 0x5B VK_LWIN Lewy klawisz Windows
92 0x5C VK_RWIN Prawy klawisz Windows
93 0x5D VK_APPS Klawisz aplikacji
145 0x91 VK_SCROLL Scroll Lock
112 0x70 VK_F1 Klawisz F1


Tabela 4.1. Kod klawiszy wirtualnych — ci g dalszy
Kod dziesiötnie Kod szesnastkowo Identyfikator Uwagi o wirtualnym klawiszu
122 0x7A VK_F11 Klawisz F11
123 0x7B VK_F12 Klawisz F12
Kody klawiszy z klawiatury numerycznej
144 0x90 VK_NUMLOCK Num Lock
96 0x60 VK_NUMPAD0 Przy aktywnym Num Lock
106 0x6A VK_MULTIPLY Klawisz mno enia (*)
107 0x6B VK_ADD Klawisz dodawania (+)
108 0x6C VK_SEPARATOR Separator przy nieaktywnym NL (-)
109 0x6D VK_SUBTRACT Klawisz odejmowania (-)
110 0x6E VK_DECIMAL Klawisz kropki (,)
111 0x6F VK_DIVIDE Klawisz dzielenia (/)

4.3. Wiadomo ci WM_KEYDOWN
i WM_KEYUP
Gdy naciskamy klawisz klawiatury, system generuje wiadomo ü WM_KEYDOWN, oznacza-
j c wduszenie jakiego klawisza. Parametr wParam wiadomo ci zawiera kod wci ni tego
wirtualnego klawisza. Przykáadowy fragment kodu procedury okna obsáuguj cy naci ni -
cie klawisza F1 mógáby wygl daü tak:


case WM_KEYDOWN:
if(wParam == VK_F1)
{
// tutaj wstawimy kod wykonujacy jakies dzialanie
// zwiazane z nacisnieciem klawisza F1
}
return 0;

Parametr lParam dostarcza nieco wi cej informacji na temat naci ni tego klawisza. Jest
to m.in. licznik powtórze klawisza, jego kod skaningowy i kilka mniej przydatnych
informacji o stanie klawisza. Spójrz na rysunek 4.1, na którym przedstawiam znaczenie
poszczególnych bitów parametru lParam.

Rysunek 4.1.
Znaczenie bitów
parametru lParam
dla wiadomo ci
WM_KEYDOWN

Bity Opis
0-15 Máodsze sáowo parametru lParam, zawiera informacje o liczbie powtórze klawisza. Najcz ciej
jego warto ü jest równa 1, gdy u ytkownik szybko uderza klawisz klawiatury, niemal
jednocze nie naciskaj c go i zwalniaj c. Jednak czasami mo e si zdarzyü sytuacja, w której
u ytkownik przytrzyma dany klawisz. Co si wówczas dzieje? System z ustalon cz stotliwo ci
caáy czas generuje wiadomo ci WM_KEYDOWN. Do ich parametru wParam jest wstawiany wirtualny
kod przytrzymanego klawisza. Je eli Windows zauwa y, e systemowa kolejka wiadomo ci
zapeánia si wiadomo ciami WM_KEYDOWN, dotycz cymi tego samego klawisza, jest to dla niego
znak, e która z dziaáaj cych aplikacji nie mo e odpowiednio szybko przetwarzaü wiadomo ci
zwi zanych z klawiatur . à czy zatem grup wiadomo ci WM_KEYDOWN w jedn wiadomo ü,
ustawiaj c jej licznik powtórze na odpowiedni warto ü.
Odczytanie liczby powtórze klawisza mogáoby byü zrealizowane w procedurze okna
nast puj co:
case WM_KEYDOWN:
{
unsigned short licznikPowtorzenKlawisza = 0;
licznikPowtorzenKlawisza = LOWORD(lParam);
}
return 0;
Dla wiadomo ci WM_KEYUP warto ü licznika powtórze klawisza zawsze wynosi 1.


Bity Opis
16 – 23 8-bitowy kod skaningowy klawisza. Mo emy go odczytaü nast puj co:
case WM_KEYDOWN:
{
unsigned char kodSkaningowy = 0;
kodSkaningowy = (lParam & 0x00FF0000) >> 16;
}
return 0;
24 Je eli bit jest ustawiony, klawisz nale y do tzw. rozszerzonej grupy klawiszy klawiatury.
Rozszerzone klawisze spotykamy przy klawiaturach 101- i 102-klawiszowych. Informacj
t odczytujemy nast puj co:
case WM_KEYDOWN:
{
bool czyRozszerzony = false;
czyRozszerzony = lParam & 0x01000000;
if(czyRozszerzony)
{
// dzialanie zwiazane z wykryciem rozszerzonego klawisza
} else
{
// dzialanie zwiazane z wykryciem zwyczajnego klawisza
}
}
return 0;
25 – 28 Cztery nieu ywane bity.
29 Kod kontekstu. Dla wiadomo ci WM_KEYDOWN i WM_KEYUP ten bit jest zawsze wyzerowany.
Natomiast dla wiadomo ci WM_CHAR jest ustawiony wtedy, gdy podczas naci ni cia klawisza
zostaá przytrzymany klawisz Alt, w innym przypadku bit jest wyzerowany. Informacj t
mo emy odczytaü nast puj co:
case WM_KEYDOWN:
{
bool czyKodKontekstu = false;
czyKodKontekstu = lParam & 0x20000000;

if(czyKodKontekstu)
{
// dzialanie zwiazane z wykryciem ustawionego bitu kontekstu
} else
{
// dzialanie zwiazane z niewykryciem
// ustawionego bitu kontekstu
}
}
return 0;
30 Okre la poprzedni stan klawisza. Dla wiadomo ci WM_KEYDOWN i WM_CHAR bit jest ustawiony,
gdy klawisz byá ju wci ni ty w chwili wygenerowania wiadomo ci. Je eli klawisz nie byá
wduszony, bit jest wyzerowany. Dla wiadomo ci WM_KEYUP bit jest zawsze ustawiony.
Ustawienie bitu mo emy sprawdziü tak:


Bity Opis
case WM_KEYDOWN:
{
bool czyBylWduszony = false;
czyBylWduszony = lParam & 0x40000000;
if(czyBylWduszony)
{
// kod wykonywany, gdy klawisz byl ju wcisniety
} else
{
// kod wykonywany, gdy klawisz nie by wcisniety
}
}
return 0;
31 Bit stanu przej ciowego. Dla wiadomo ci WM_KEYDOWN bit jest zawsze wyzerowany.
Dla wiadomo ci WM_KEYUP jest zawsze ustawiony. Natomiast dla wiadomo ci WM_CHAR
jest wyzerowany, gdy klawisz zostaá wduszony, a ustawiony, kiedy klawisz zostaá zwolniony.
Informacj o stanie przej ciowym klawisza pobieramy nast puj co:
case WM_KEYDOWN:
{
bool stanPrzejsciowy = false;
stanPrzejsciowy = lParam & 0x80000000;
if(stanPrzejsciowy)
{
// kod wykonywany, gdy bit jest ustawiony
} else
{
// kod wykonywany, gdy bit jest wyzerowany
}
}
return 0;

Je eli procedura okna przetworzy wiadomo ü WM_KEYDOWN, powinna zwróciü do systemu
warto ü zerow .

Gdy zwalniamy klawisz klawiatury, system generuje wiadomo ü WM_KEYUP. Parametr
wParam wiadomo ci zawiera kod zwolnionego wirtualnego klawisza, a parametr lPa-
ram zawiera takie same dodatkowe informacje o klawiszu, jak wiadomo ü WM_KEYDOWN.
Je eli procedura okna przetwarza wiadomo ü WM_KEYUP, powinna zwróciü do systemu
warto ü zerow .

4.4. Wiadomo è WM_CHAR
Poznaáe ju dwie wiadomo ci zwi zane z klawiatur , WM_KEYDOWN i WM_KEYUP. S to
tzw. wiadomo ci klawiszowe. Teraz poznasz jeszcze jedn wiadomo ü — WM_CHAR —
któr cz sto nazywa si wiadomo ci znakow .


Wiadomo ci klawiszowe nie pozwalaj jednoznacznie okre liü, czy u ytkownik nacisn á
du , czy maá liter . Aby to stwierdziü, nale aáoby kontrolowaü klawisze steruj ce sta-
nem klawiatury, czyli takie klawisze jak Caps Lock, Shift oraz Alt. Z uwzgl dnieniem ich
stanu kod skaningowy wci ni tego klawisza powinien zostaü przeksztaácony na odpo-
wiadaj cy mu kod znaku z zestawu znaków aktualnie wybranego w systemie.

System Windows dostarcza funkcj , za której pomoc mo emy automatycznie dokonaü
tego przeksztaácenia. Jest ni TranslateMessage, wywoáujemy j najcz ciej wewn trz
p tli wiadomo ci aplikacji. Funkcja TranslateMessage przeksztaáca wiadomo ü klawi-
szow (WM_KEYDWON i WM_KEYUP) na wiadomo ü znakow (WM_CHAR). Niech Ci si nie wy-
daje, e wiadomo ü klawiszowa jest zast powana wiadomo ci znakow . Funkcja Trans-
lateMessage tworzy now wiadomo ü i umieszcza j w kolejce wiadomo ci aplikacji
w taki sposób, e zostanie ona pobrana przez funkcj GetMessage lub PeekMessage podczas
kolejnego przebiegu p tli wiadomo ü.

Gdy w naturalny sposób uderzamy w klawisz klawiatury oznaczony symbolem A (naci-
skamy go i zaraz puszczamy), system wygeneruje nast puj c sekwencj wiadomo ci.
Oczywi cie zakáadamy, e p tla wiadomo ci aplikacji jest wyposa ona w funkcj Trans-
lateMessage oraz klawisz Caps Lock jest wyá czony, a klawisz Shift nie jest przytrzy-
mywany.
WM_KEYDOWN — (kod naciskanego wirtualnego klawisza A: 0x41, dziesi tnie 65)
WM_CHAR — (kod ANSI znaku a: 0x61, dziesi tnie 97)
WM_KEYUP — (kod zwalnianego wirtualnego klawisza: 0x41, dziesi tnie 65)

Gdy wá czymy klawisz Caps Lock i naci niemy klawisz A lub przytrzymamy klawisz
Shift i naci niemy klawisz A, zostanie wygenerowana nast puj ca sekwencja wiadomo ci.
Wybraáem drug opcj .
WM_KEYDOWN — (kod naciskanego wirtualnego klawisza Shift: 0x10, dziesi tnie 16)
WM_KEYDOWN — (kod naciskanego wirtualnego klawisza A: 0x41, dziesi tnie 65)
WM_CHAR — (kod ANSI znaku A: 0x41, dziesi tnie 65)
WM_KEYUP — (kod zwalnianego wirtualnego klawisza A: 0x41, dziesi tnie 65)
WM_KEYUP — (kod zwalnianego wirtualnego klawisza Shift: 0x10, dziesi tnie 16)

Zauwa , e klawisz Shift nie generuje wiadomo ci WM_CHAR. Dlaczego? To proste, bo nie
generuje samodzielnie adnego tekstowego znaku. Robi to natomiast klawisze Tab,
Enter oraz Backspace. Rodzi si wi c pytanie, jak identyfikowaü te znaki? Z pewno ci
wiesz, e klawiszowi Tab odpowiada znak (kod) steruj cy 't', klawiszowi Enter —
'r', a klawiszowi Backspace — znak 'b'. U ywamy ich tak samo jak zwykáych kla-
wiszy literowych.

Nie musimy jednak koniecznie przechwytywaü zdarzenia naci ni cia wy ej wymienio-
nych trzech klawiszy za pomoc wiadomo ci WM_CHAR, mo emy to równie dobrze zrobiü,
korzystaj c z wiadomo ci WM_KEYDWON i identyfikatorów klawiszy wirtualnych VK_TAB,
VK_RETURN i VK_BACK.


Parametr wParam wiadomo ci WM_CHAR nie zawiera kodu wirtualnego klawisza, jest w nim
umieszczony kod ANSI znaku, pochodz cy z aktualnie wybranego w systemie zestawu
znaków.

Oto przykáadowy fragment kodu procedury okna przechwytuj cy wprowadzenie przez
u ytkownika znaku A i znaku tabulacji.
case WM_CHAR:
{
if(wParam == 'A')
{
// dzialanie zwiazane z wprowadzeniem znaku A
}

if(wParam == 't')
{
// dzialanie zwiazane z wprowadzeniem znaku tabulacji
}
}
return 0;

Parametr lParam zawiera identyczn informacj o stanie naci ni tego lub zwolnionego
klawisza, jak w przypadku wiadomo ci WM_KEYDOWN. Je eli procedura okna przetwarza
wiadomo ü WM_CHAR, powinna zwróciü do systemu warto ü zerow .

4.5. Wiadomo ci WM_SYSKEYDOWN
i WM_SYSKEYUP
Wiadomo ü WM_SYSKEYDOWN jest wstawiana do kolejki wiadomo ci, kiedy naci niemy
klawisz F10 lub przytrzymamy klawisz Alt i wci niemy dodatkowo jaki inny klawisz.
Wiadomo ci WM_SYSKEYDOWN towarzyszy zawsze pojawienie si wiadomo ci WM_SYSKEYUP,
generowanej w momencie zwolnienia klawisza, który zostaá naci ni ty w czasie, gdy kla-
wisz Alt byá przytrzymany. Wiadomo ci WM_SYSKEYDOWN i WM_SYSKEYUP na ogóá nie
przetwarzamy. Oddajemy je do obsáugi przez domy ln procedur okna — DefWin-
dowProc.

Blokowanie tych wiadomo ci mo e powodowaü, e system nie wykona zada , które
wywoáujemy za pomoc skrótów klawiaturowych z u yciem klawisza Alt. Przykáa-
dowo nie zadziaáa kombinacja Alt+F4 zamykaj ca okno.

Z wiadomo ci WM_SYSKEYDOWN i WM_SYSKEYUP najprawdopodobniej nigdy nie skorzystamy
podczas pisania naszych przykáadowych programów. Wiedza o nich b dzie jednak
potrzebna do lepszego zrozumienia tre ci kolejnych rozdziaáów. Parametry wParam
i lParam wiadomo ci WM_SYSKEYDOWN i WM_SYSKEYUP zawieraj takie same informacje jak
dla wiadomo ci WM_KEYDOWN i WM_KEYUP. Powiniene równie pami taü o tym, e gdy je
przetwarzasz, procedura okna powinna zwróciü do systemu warto ü zerow .


4.6. Niezale ne pobieranie informacji
o stanie klawiszy
Czy nie wydaje Ci si , e odbieranie informacji o stanie klawiszy wyá cznie przy u yciu
wiadomo ci WM_KEYDOWN, WM_KEYUP i WM_CHAR w procedurze okna jest nieco niewygodne.
Czasami mo e si zdarzyü, e b dziemy chcieli niezale nie sprawdziü stan jakiego
klawisza, np. podczas przetwarzania wiadomo ci WM_PAINT. Co wtedy? Windows API
dostarcza wiele funkcji do obsáugi klawiatury, dwie z nich mo emy wykorzystaü do
rozwi zania naszego problemu.

Pierwsza to GetKeyState. Jej nagáówek jest zdefiniowany w pliku winuser.h i ma nast -
puj c postaü:
SHORT GetKeyState(int nVirtKey);

Jako parametr nVirtKey podajemy kod wirtualnego klawisza, którego stan zamierzamy
sprawdziü. Je eli klawisz jest wci ni ty, funkcja zwraca warto ü ujemn (najstarszy bit
zwróconej warto ci jest ustawiony). Je eli zwrócona warto ü jest nieujemna, klawisz jest
zwolniony (najstarszy bit zwróconej warto ci nie jest ustawiony).

Je eli najmáodszy bit jest ustawiony, klawisz jest wá czony, w przeciwnym razie klawisz
jest wyá czony. Stan wá czenia i wyá czenia odnosi si do klawiszy steruj cych prac
klawiatury, takich jak Caps Lock, Scroll Lock czy Num Lock. Mimo e mo emy wyró -
niü trzy klawisze tego typu, powiniene za pomoc funkcji GetKeyState sprawdzaü
wyá cznie stan klawisza Caps Lock.

Znam jeszcze jedn bardzo wa n wskazówk , dotycz c pracy z funkcj GetKeyState.
Funkcja nie odnosi si bezpo rednio do klawiatury w celu zbadania stanu danego kla-
wisza. Wykorzystuje fakt, e podczas tworzenia ka dej wiadomo ci okna system za-
pami tuje aktualny stan klawiatury i na podstawie tego zbioru informacji ocenia stan
klawiszy.

Do bezpo redniego badania stanu klawiszy klawiatury sáu y funkcja GetAsyncKeyState.
Podczas wywoáania komunikuje si z klawiatur i zwraca rzeczywisty stan klawisza.
Oto jej nagáówek:
SHORT GetAsyncKeyState(int nVirtKey);

Poprzez parametr nVirtKey okre lamy kod wirtualnego klawisza, którego stanem jeste-
my zainteresowani. Je eli wywoáanie funkcji si powiedzie, zwracana warto ü okre la
stan klawisza. Gdy jej najbardziej znacz cy bit jest ustawiony (warto ü jest ujemna),
klawisz jest wci ni ty. Kiedy natomiast jest wyzerowany (warto ü jest nieujemna),
klawisz jest zwolniony.

Je eli najmniej znacz cy bit jest ustawiony, oznacza to, e klawisz byá naci ni ty po
poprzednim wywoáaniu funkcji GetAsyncKeyState. Je eli zwrócon warto ci jest zero,
znaczy to, e adne z okien aplikacji (procesu) nie jest aktywne, co automatycznie wi e
si z tym, i do aplikacji nie docieraj adne wiadomo ci zwi zane z klawiatur .


Dodatkowo funkcje GetKeyState i GetAsyncKeyState obsáuguj trzy kody wirtualnych
klawiszy powi zanych z przyciskami myszy (tabela 4.2).

Tabela 4.2. Kod wirtualnych przycisków myszy
Kod dziesiötnie Kod szesnastkowo Identyfikator Uwagi o wirtualnym przycisku
1 0x01 VK_LBUTTON Lewy przycisk myszy
2 0x02 VK_RBUTTON Prawy przycisk myszy
4 0x04 VK_MBUTTON rodkowy przycisk myszy

Przykáadowe wywoáanie funkcji GetAsyncKeyState sprawdzaj ce, czy jest naci ni ty
klawisz spacji, mogáoby wygl daü nast puj co:
if(0x8000 & GetAsyncKeyState(VK_SPACE))
{
// kod wykonywany w odpowiedzi na wykrycie
// wcisnietego klawisza spacji
}

4.7. Projekt: „Klawiatura”
Mówi c krótko, przykáadowy program b dzie przechwytywaá wiadomo ci WM_KEYDOWN,
WM_KEYUP oraz WM_CHAR, po czym wypisze informacje o naci ni tym klawiszu. B dzie to
m.in. jego kod skaningowy, kod wirtualny i licznik powtórze .

Budowa programu, w porównaniu do poprzednich przykáadowych programów, nie ulegáa
zmianie (listing 4.1). Program wy wietla jedno okno, w którym demonstruje swoje dziaáa-
nie. Poza funkcj WinMain i procedur okna — ProceduraOkna — zdefiniowaáem
jeszcze tylko jedn funkcj WypiszInformacjeKlawisza. Zanim omówi jej dziaáanie, do-
káadnie przeanalizuj kod programu. Przypuszczam, e je li b dziesz miaá z nim jakiekol-
wiek problemy, to b d dotyczyü tylko nowej funkcji. Na rysunku 4.2 przedstawiam okno
programu Klawiatura po naci ni ciu kilku klawiszy.

Listing 4.1. Odbieranie informacji o naci ni tych klawiszach (projekt: Klawiatura, plik: WinMain.cpp)
001: // P L I K I N A G L O W K O W E
002: ///////////////////////////////////////////
003: #include <windows.h>
004: #include <stdio.h>
005:
006: // D E K L A R A C J E
007: ///////////////////////////////////////////
008: LRESULT CALLBACK ProceduraOkna(
009: HWND hWnd, UINT message,
010: WPARAM wParam, LPARAM lParam);
011:
012: void WypiszInformacjeKlawisza(
013: HWND hwnd, UINT message,
014: WPARAM wParam, LPARAM lParam);
015:


Rysunek 4.2.
Okno programu
Klawiatura

016: // D E F I N I C J E
017: ///////////////////////////////////////////
018: #define WYSOKOSC_OKNA 500
019: #define SZEROKOSC_OKNA 400
020:
021: char* const g_nazwaKlasyOkna = "StandardoweOkno";
022: BOOL g_czyAktywna = true;
023:
024: // W I N M A I N
025: ///////////////////////////////////////////
026: int WINAPI WinMain(
027: HINSTANCE hInstance,
028: HINSTANCE hPrevInstance,
029: LPSTR lpCmdLine,
030: int nShowCmd)
031: {
032: // definiujemy klase okna
033: WNDCLASSEX wndclassex = {0};
034:
035: wndclassex.cbSize = sizeof(WNDCLASSEX);
036: wndclassex.style = CS_VREDRAW | CS_HREDRAW;
037: wndclassex.lpfnWndProc = ProceduraOkna;
038: wndclassex.cbClsExtra = 0;
039: wndclassex.cbWndExtra = 0;
040: wndclassex.hInstance = hInstance;
041: wndclassex.hIcon = LoadIcon(0, (LPCTSTR)IDI_APPLICATION);
042: wndclassex.hCursor = LoadCursor(0, (LPCTSTR)IDC_ARROW);
043: wndclassex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
044: wndclassex.lpszMenuName = 0;
045: wndclassex.lpszClassName = g_nazwaKlasyOkna;
046: wndclassex.hIconSm = LoadIcon(0, (LPCTSTR)IDI_APPLICATION);
047:
048: // rejestrujemy klase okna


049: RegisterClassEx(&wndclassex);
050:
051: // zmienna na uchwyt okna
052: HWND uchwytOkna = 0;
053:
054: // tworzymy okno
055: uchwytOkna = CreateWindowEx(
056: 0, // styl rozszerzony
057: g_nazwaKlasyOkna, // klasa okna
058: "Klawiatura", // tekst na belce
059: WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME, // styl okna
060: 100, // pozycja X okna
061: 60, // pozycja Y okna
062: SZEROKOSC_OKNA, // szerokosc okna
063: WYSOKOSC_OKNA, // wysokosc okna
064: 0, // okno nadrzedne
065: 0, // uchwyt menu
066: hInstance, // uchwyt aplikacji
067: 0); // wskaznik na dane
068:
069: // wyswietlamy okno
070: ShowWindow(uchwytOkna, SW_NORMAL);
071:
072: // wymuszamy odswiezenie okna
073: UpdateWindow(uchwytOkna);
074:
075: // wiadomosc
076: MessageBox(
077: uchwytOkna,
078: "Zamknij okno komunikatu i n"
079: "nacisnij dowolny klawisz klawiatury.",
080: "informacja", MB_OK | MB_ICONINFORMATION);
081:
082: // petla wiadomosci
083: MSG msg;
084: for(;;)
085: {
086: if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0)
087: {
088: if(msg.message == WM_QUIT) break;
089: TranslateMessage(&msg);
090: DispatchMessage(&msg);
091: }
092:
093: if(g_czyAktywna == false)
094: WaitMessage();
095: else ; // po prostu nic nie robimy
096: }
097:
098: return (int)msg.wParam;
099: }
100:
101: // D E F I N I C J E F U N K C J I
102: ///////////////////////////////////////////
103: LRESULT CALLBACK ProceduraOkna(
104: HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
105: {


106: switch(message)
107: {
108: case WM_PAINT:
109: ValidateRect(hWnd, 0);
110: return 0;
111:
112: // w przypadku przechwycenia jednej z wiadomosci
113: // klawiatury wywolujemy funkcje WypiszInformacjeKlawisza
114: case WM_CHAR:
115: case WM_KEYDOWN:
116: case WM_KEYUP:
117: WypiszInformacjeKlawisza(
118: hWnd, message, wParam, lParam);
119: return 0;
120:
121: case WM_CLOSE:
122: if(IDYES ==
123: MessageBox(hWnd, "Czy na pewno zamknac okno?",
124: "Pytanie", MB_YESNO | MB_ICONQUESTION))
125: return DefWindowProc(hWnd, message, wParam, lParam);
126: else
127: return 0;
128:
129: case WM_ACTIVATE:
130: if(LOWORD(wParam) == WA_INACTIVE)
131: {
132: g_czyAktywna = false;
133: } else
134: {
135: g_czyAktywna = true;
136: }
137: return 0;
138:
139: case WM_DESTROY:
140: PostQuitMessage(0);
141: return 0;
142: } // koniec switch
143:
144: return DefWindowProc(hWnd, message, wParam, lParam);
145: }
146:
147: void WypiszInformacjeKlawisza(
148: HWND hwnd, UINT message,
149: WPARAM wParam, LPARAM lParam)
150: {
151: // definicja niezbednych zmiennych
152: // automatycznych i statycznych
153: int wysokoscWierszaTekstu = 0;
154: static unsigned short ileWierszy = 2;
155: char buforWierszaTekstu[80] = {'0'};
156:
157: // naglowek tabeli
158: static char naglowekTabeli[60] =
159: {"WIADOMOSC ZNAK SKAN KOD WIR KOD LICZNIK"};
160: static char podkreslenie[60] =
161: {"-----------------------------------------------"};
162:


163: // pobieramy uchwyt kontekstu urzadzenia okna
164: HDC hdc = 0;
165: hdc = GetDC(hwnd);
166:
167: // wybieramy czcionke o sta ej szerokosci znaku
168: HGDIOBJ gdiObj = 0;
169: gdiObj = SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));
170:
171: // pobieramy wysokosc pojedynczego wiersza tekstu
172: // zapisanego za pomoca czcionki aktualnie wybranej w kontekscie
173: // urzadzenia
174: TEXTMETRIC tm = {0};
175:
176: GetTextMetrics(hdc, &tm);
177: wysokoscWierszaTekstu =
178: tm.tmHeight + tm.tmExternalLeading;
179:
180: // sprawdzamy, czy wyswietlany wiersz jest
181: // pierwszym wierszem tekstu w oknie oraz czy
182: // okno nie zostalo calkowicie zapisane, gdy jeden z
183: // warunkow zostanie spelniony, czyscimy obszar roboczy okna,
184: // malujac go na bia o, po czym wyswietlamy naglowek tabeli
185: if((ileWierszy == 2) ||
186: ((ileWierszy * wysokoscWierszaTekstu) >
187: WYSOKOSC_OKNA - wysokoscWierszaTekstu * 3))
188: {
189: // pobieramy rozmiar obszaru roboczego okna
190: RECT rect = {0};
191: GetClientRect(hwnd, &rect);
192:
193: // malujemy go na bialo
194: FillRect(hdc, &rect, (HBRUSH)GetStockObject(WHITE_BRUSH));
195:
196: // ustalmy pozycje pierwszego wiersza tekstu
197: ileWierszy = 2;
198:
199: // wyswietlamy naglowek tabeli
200: TextOut(
201: hdc, 10, 0,
202: naglowekTabeli, (int)strlen(naglowekTabeli));
203:
204: TextOut(
205: hdc, 10, wysokoscWierszaTekstu,
206: podkreslenie, (int)strlen(podkreslenie));
207:
208: // informacja dzwiekowa
209: MessageBeep(MB_OK);
210: }
211:
212: // przygotowujemy tekst zawierajacy informacje o odebranej
213: // wiadomosci i stanie klawisza
214: sprintf_s(
215: buforWierszaTekstu,
216: sizeof(buforWierszaTekstu),
217: "%-14s%-6c%#-6x%-5i%-9i%-7i",
218:
219: // identyfikator wiadomosci


220: (message == WM_CHAR) ? "WM_CHAR" :
221: (message == WM_KEYDOWN) ? "WM_KEYDOWON" : "WM_KEYUP",
222:
223: // znak
224: (message == WM_CHAR) ? (char)wParam : ' ',
225:
226: // kod skaningowy klawisza, szesnastkowo i dziesietnie
227: (lParam & 0x00FF0000) >> 16,
228: (lParam & 0x00FF0000) >> 16,
229:
230: // kod wirtualnego klawisza
231: (message != WM_CHAR) ? wParam : 0,
232:
233: // licznik powtorzen klawisza
234: (lParam & 0x0000FFFF)
235:
236: ); // <- koniec wywo ania funkcji sprintf_s
237:
238: // wyswietlamy tekst
239: TextOut(
240: hdc, 10, ileWierszy * wysokoscWierszaTekstu,
241: buforWierszaTekstu, (int)strlen(buforWierszaTekstu));
242:
243: // ustalamy pozycje nastepnego wiersza
244: ileWierszy++;
245:
246: // przywracamy pierwotne ustawienia kontekstu urzadzenia,
247: // zatwierdzamy caly obszar roboczy okna i zwalniamy uchwyt
248: // kontekstu urzadzenia
249: SelectObject(hdc, gdiObj);
250: ValidateRect(hwnd, 0);
251: ReleaseDC(hwnd, hdc);
252: }

Gdy uruchomisz program i zaczniesz naciskaü klawisze klawiatury, zobaczysz wypisane
w postaci tabeli informacje o przechwyconej wiadomo ci klawiszowej lub znakowej.
Ka dy wiersz tabeli zawiera identyfikator wiadomo ci, wprowadzony znak (tylko w przy-
padku wiadomo ci WM_CHAR), kod skaningowy klawisza w postaci szesnastkowej i dzie-
si tnej, kod wirtualnego klawisza oraz licznik jego powtórze .

Pierwsz rzecz , jak powiniene zauwa yü, jest to, e program nie od wie a zawarto ci
okna w odpowiedzi na wiadomo ü WM_PAINT. Jest to dziaáanie zamierzone, nie chciaáem
dodatkowo komplikowaü kodu tylko ze wzgl dów czysto estetycznych. Je eli chciaáby
to zmieniü, powiniene gdzie zapami tywaü informacj o ostatnio przechwyconych wia-
domo ciach klawiatury. Lista powinna byü na tyle dáuga, aby podczas odrysowywania
okna mogáa pokryü jego caáy obszar roboczy. Chciaábym równie , aby na tym przykáa-
dzie spostrzegá, jak wa ne jest od wie anie zawarto ci okna dla zwykáego miertelnika
korzystaj cego z Twojego programu. Widz c puste lub cz ciowe odrysowane okno, nie
wiedziaáby, co z nim zrobiü. I na pewno nie winiáby za to siebie, to Ty byáby jego wrogiem
numer jeden.


Funkcja WypiszInformacjeKlawisza jest wywoáywana w odpowiedzi na przechwycenie
wiadomo ci klawiatury. Przekazujemy do niej uchwyt okna, identyfikator wiadomo ci
i jej parametry.

Dziaáanie funkcji rozpoczyna si od zdefiniowania zmiennej wysokoscWierszaTekstu.
Wykorzystamy j do zapami tania wysoko ci pojedynczego wiersza wy wietlanego
tekstu. Druga wa na zmienna to ileWierszy. B dzie przechowywaü liczb wypisanych
wierszy tekstu (pierwsze dwa wiersze zarezerwowane s dla nagáówka tabeli).

Trzecia zmienna to tablica, do której funkcja b dzie generowaü tekst z informacjami
o odebranej wiadomo ci okna. Kolejne dwie zmienne to tablice zawieraj ce tekst two-
rz cy nagáówek tabeli.

Po pobraniu uchwytu kontekstu urz dzenia podá czamy do niego systemow czcionk
o staáej szeroko ci znaku, co pozwoli formowaü informacje wstawiane do tabeli w czy-
telne kolumny.

Nast pnie funkcja pobiera wysoko ü wiersza tekstu zapisanego za pomoc nowej czcionki.
Je eli aden wiersz tekstu nie zostaá wypisany lub caáy obszar okna zostaá zapisany, funk-
cja czy ci na biaáo obszar okna. Nast pnie wy wietla sam nagáówek tabeli i odtwarza za
pomoc funkcji MessageBeep prosty d wi k, identyczny z tym, który sáu y systemowi do
powiadamia o pomy lnym zako czeniu jakiej operacji.

Nagáówek funkcji MessageBeep ma postaü:
BOOL MessageBeep(UINT uType);

Jako parametr uType mo emy podaü jeden z wymienionych poni ej okre laj cych rodzaj
odtwarzanego d wi ku.

Identyfikator Opis
0xFFFFFFFF D wi k z komputerowego gáo niczka
MB_OK Systemowe OK
MB_ICONHAND Systemowa pomoc
MB_ICONQUESTION Systemowe pytanie
MB_ICONEXCLAMATION Systemowy wyj tek (bá d)
MB_ICONASTERISK Systemowy odsyáacz

W wyniku wywoáania funkcji zostaje zainicjalizowane asynchroniczne odgrywanie wy-
branego d wi ku, po czym funkcja natychmiast zwraca sterowanie. Je eli wywoáanie
powiedzie si , zwrócona warto ü jest niezerowa (TRUE). W przypadku niepowodzenia
funkcja zwraca zero (FALSE). Najcz stsz przyczyn nieodegrania d wi ku jest zaj te
urz dzenie audio.

Wracamy do omawiania funkcji WypiszInformacjeKlawisza. Jej kolejny krok polega na
„zmontowaniu” tekstu z informacj o klawiszu. Je eli nie pami tasz szczegóáów dzia-
áania funkcji sprintf_s, powiniene zajrzeü do podpunktu „Funkcje rand, sprintf_s, Sleep
i co jeszcze” w 2. rozdziale.


Dodatkowo niezrozumiaá rzecz mo e byü dziaáanie trójargumentowego operatora ?:.
Wyja ni je, gdy pocz tkuj cy programi ci C++ bardzo cz sto zapominaj o jego ist-
nieniu, przez co trac bardzo pomocne narz dzie.

Przed znakiem zapytania stawiamy wyra enie logiczne; je eli jest prawdziwe, wykony-
wany jest fragment kodu mi dzy znakiem zapytania a dwukropkiem. Je eli wyra enie
jest nieprawdziwe, zostaje wykonany kod znajduj cy si za dwukropkiem. Przyjrzyj si
poni szemu zapisowi.
01: unsigned short ileWlosow = 0;
02: (2 > 20) ? ileWlosow = 500 : ileWlosow = 3000;

Jaka warto ü zostanie przypisana zmiennej ileWlosow? Tak! Masz racj b dzie to war-
to ü 3000, bo wyra enie 2 > 20 jest faászywe (FALSE).

Po wy wietleniu tekstu funkcja ustala pozycj nast pnego wiersza tekstu, po czym przy-
wraca pierwotne ustawienia kontekstu urz dzenia okna, zatwierdza obszar roboczy okna
i zwalnia uchwyt kontekst urz dzenia.

Visual Studio 2005. Programowanie z Windows API w języku C++

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to Visual Studio 2005. Programowanie z Windows API w języku C++ (20)

More from Wydawnictwo Helion (20)

Visual Studio 2005. Programowanie z Windows API w języku C++