okladka
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
  • Zarządzanie zasobami aplikacji
  • Budowanie okien dialogowych
  • Korzystanie z kontrolek
  • Obsługa wielozadaniowości i wielowątkowości

Poznaj techniki i metody tworzenia aplikacji dla systemu operacyjnego Windows.


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)
    • 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)
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)
  • 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)