.:$$:.

Teixeira i Pacheco wciąż dzielą się z czytelnikami swą wiedzą i doświadczeniem, ucząc jak tworzy się aplikacje bazodanowe -- lokalne, wielowarstwowe i internetowe oraz nowe komponenty, biblioteki DLL itd. Czytając tę książkę, masz niepowtarzalną okazję podnieść swoje kwalifikacje, gdyż umożliwia ona zapoznanie się m.in. z zasadami tworzenia aplikacji międzyplatformowych, metodologią tworzenia komponentów i ich edytorów, filozofią programowania obiektowego i programowaniem współbieżnym.

Niniejsza książka, napisana przez dwukrotnych laureatów nagrody za najlepszą książkę o Delphi, przyznanej przez czytelników Delphi Informant, stworzona przez programistów dla programistów, to miarodajny przewodnik po nowościach Delphi 6.

Czytając "Delphi 6. Vademecum profesjonalisty", poznasz między innymi:

• historię Delphi i techniczne oraz ekonomiczne uwarunkowania jego rozwoju,
• bogactwo środowiska IDE i współdziałanie jego elementów w procesie tworzenia aplikacji,
• najważniejsze elementy języka Object Pascal,
• szczegóły biblioteki CLX i zasady tworzenia aplikacji międzyplatformowych dla Windows i Linuksa,
• mechanizm komunikatów Windows i zasady ich obsługi w tworzonych aplikacjach,
• podstawy tworzenia i wykorzystywania bibliotek DLL,
• realizację programowania współbieżnego za pomocą wątków i włókien oraz mechanizmów synchronizujących,
• zastosowanie nowych komponentów bazodanowych dbExpress i dbGo for ADO.

O Autorach (13)
Przedmowa do wydania oryginalnego (15)
Przedmowa do wydania polskiego (17)
Część I Podstawy programowania (19)
Rozdział 1. Programowanie w Delphi (21)

• Rodzina produktów Delphi (21)
• Delphi - co i dlaczego? (23)
• Komfort wizualnego projektowania aplikacji (24)
• Szybkość kompilacji kontra efektywność generowanego kodu (25)
• Możliwości języka programowania w kontekście jego złożoności (26)
• Elastyczność i skalowalność architektury baz danych (27)
• Wzorce projektowania i użytkowania wymuszone przez strukturę środowiska (27)
• Nieco historii (28)
• Delphi 1 (28)
• Delphi 2 (29)
• Delphi 3 (30)
• Delphi 4 (31)
• Delphi 5 (31)
• Delphi 6 (32)
• Środowisko zintegrowane Delphi 6 (32)
• Okno główne (32)
• Projektant formularzy (34)
• Inspektor obiektów (35)
• Edytor kodu (36)
• Eksplorator kodu (36)
• Hierarchia obiektów (36)
• Kod źródłowy projektu (36)
• Prosta aplikacja (38)
• Jeszcze o zdarzeniach... (40)
• Niekontraktowy charakter obsługi zdarzeń (40)
• Prototypowanie kodu (41)
• Rozbudowa zestawu komponentów i konfigurowalne środowisko (42)
• Top 10 - gorąca dziesiątka IDE (42)
• 1. Uzupełnianie klas (42)
• 2. Udostępnianie deklaracji symbolu (43)
• 3. Od deklaracji do definicji (43)
• 4. Dokowanie (43)
• 5. Object Browser (44)
• 6. GUID (44)
• 7. Wyróżnianie składni plików C++ (44)
• 8. Znaczniki To Do... (45)
• 9. Menedżer projektów (45)
• 10. Code Insight (45)
• Podsumowanie (46)

Rozdział 2. Język Object Pascal (47)

• Komentarze (47)
• Nowości w zakresie procedur i funkcji (48)
• Puste nagłówki wywołań (48)
• Przeciążanie (49)
• Domyślne parametry (50)
• Zmienne (51)
• Stałe (52)
• Operatory (55)
• Operator przypisania (55)
• Operatory porównania (55)
• Operatory logiczne (55)
• Operatory arytmetyczne (56)
• Operatory bitowe (57)
• Operatory zwiększania i zmniejszania (57)
• Operatory "wykonaj i przypisz" (58)
• Typy języka Object Pascal (58)
• Porównanie typów (59)
• Znaki (59)
• Mnogość łańcuchów... (59)
• Typy wariantowe (74)
• Typ Currency (88)
• Typy definiowane przez użytkownika (89)
• Tablice (89)
• Rekordy (93)
• Zbiory (94)
• Obiekty (97)
• Wskaźniki (98)
• Aliasy typów (101)
• Rzutowanie i konwersja typów (102)
• Zasoby łańcuchowe (104)
• Instrukcje warunkowe (104)
• Instrukcja If (105)
• Instrukcja wyboru (106)
• Pętle (106)
• Pętla For (106)
• Pętla While...Do (107)
• Pętla Repeat...Until (108)
• Procedura Break() (108)
• Procedura Continue () (109)
• Procedury i funkcje (110)
• Przekazywanie parametrów do procedur i funkcji (111)
• Zasięg deklaracji (118)
• Moduły (118)
• Dyrektywa uses (119)
• Cykliczna zależność między modułami (120)
• Pakiety (122)
• Wykorzystywanie pakietów (123)
• Składnia pakietu (123)
• Programowanie zorientowane obiektowo (123)
• Środowisko bazujące na obiektach kontra środowisko zorientowane obiektowo (125)
• Wykorzystanie obiektów w Delphi (126)
• Deklarowanie obiektów i kreowanie zmiennych obiektowych (126)
• Destrukcja obiektu (127)
• Metody (127)
• Właściwości (131)
• Widoczność elementów obiektu (133)
• Wewnątrz obiektów (134)
• TObject - protoplasta wszystkich klas (135)
• Interfejsy (136)
• Strukturalna obsługa wyjątków (141)
• Wyjątki jako klasy (144)
• Wyjątki a przepływ sterowania w programie (145)
• Ponowienie wyjątku (147)
• RTTI (148)
• Podsumowanie (149)

Rozdział 3. Obsługa komunikatów Windows (151)

• Natura komunikatów (151)
• Typy komunikatów (152)
• Jak funkcjonuje system komunikatów Windows? (152)
• Obsługa komunikatów w kategoriach Delphi (154)
• Struktury specyficzne dla różnych typów komunikatów (155)
• Przetwarzanie komunikatów (155)
• Kontraktowy charakter obsługi komunikatów (157)
• Zwrotne przekazywanie wyniku obsługi komunikatu (158)
• Zdarzenie OnMessage klasy TApplication (159)
• Wysyłanie własnych komunikatów (159)
• Metoda Perform() (160)
• Funkcje SendMessage() i PostMessage() (160)
• Komunikaty niestandardowe (160)
• Komunikaty powiadamiające (161)
• Wewnętrzne komunikaty VCL (161)
• Komunikaty definiowane przez użytkownika (163)
• Anatomia systemu komunikatów VCL (165)
• Związek komunikatów ze zdarzeniami Delphi (174)
• Podsumowanie (174)

Część II Zaawansowane zagadnienia projektowe (177)
Rozdział 4. Tworzenie przenośnego kodu (179)

• Założenia ogólne (179)
• Która wersja? (179)
• Moduły, komponenty i pakiety (181)
• Zmiany w środowisku IDE (181)
• Zgodność pomiędzy Delphi i Kyliksem (182)
• Nie w Linuksie (183)
• Różnice między kompilatorami (183)
• Indywidualne cechy platformy systemowej (184)
• Nowości Delphi 6 (184)
• Definiowalne typy wariantowe (185)
• Jawne wartościowanie elementów typu wyliczeniowego (185)
• Dyrektywa $IF (185)
• Możliwa niezgodność plików *.DFM (185)
• Migracja z Delphi 5 (185)
• Zmiana wartości stałych typowanych (185)
• Negacja wartości typu Cardinal (186)
• Migracja z Delphi 4 (186)
• Zmiany w zakresie biblioteki RTL (186)
• Zmiany w bibliotece RTL (187)
• Zmiany w zakresie obsługi Internetu (188)
• Zmiany w obsłudze baz danych (188)
• Migracja z Delphi 3 (189)
• 32-bitowe liczby całkowite bez znaku (189)
• 64-bitowe liczby całkowite (190)
• Typ Real (190)
• Migracja z Delphi 2 (190)
• Zmiany w zakresie typów boolowskich (191)
• Dyrektywa resourcestring (191)
• Zmiany w bibliotece RTL (192)
• Klasa TCustomForm (192)
• Metoda GetChildren() (192)
• Serwery automatyzacji (193)
• Migracja z Delphi 1 (193)
• Znaki i łańcuchy (193)
• Rozmiar i zakres zmiennych (201)
• Wyrównywanie pól rekordów (201)
• 32-bitowa arytmetyka (202)
• Różnice dotyczące typu TDateTime (203)
• Sekcja finalization (203)
• Język asemblera (204)
• Biblioteki DLL (205)
• Zmiany związane z systemem operacyjnym (206)
• Podsumowanie (210)

Rozdział 5. Aplikacje wielowątkowe (211)

• Natura wątków (211)
• Rodzaje wielozadaniowości (211)
• Do czego może się przydać wielowątkowość? (212)
• Wielowątkowość a komponenty VCL (212)
• Błędne wykorzystanie wielowątkowości (213)
• Klasa TThread (213)
• Obiekty wątków a zmienne (216)
• Kończenie wątku (216)
• Synchroniczne wykorzystywanie komponentów VCL (218)
• Przykładowa aplikacja wielowątkowa (221)
• Priorytety i szeregowanie wątków (222)
• Zawieszanie i wznawianie wątków (225)
• Pomiar czasu w ramach wątku (225)
• Współdziałanie wątków aplikacji (228)
• Pamięć lokalna wątku (228)
• Synchronizacja wątków (232)
• Przykład zastosowania wielowątkowości: zaawansowane wyszukiwanie tekstu (244)
• Interfejs użytkownika (245)
• Proces przeszukiwania (251)
• Zmiana priorytetu wątku przeszukującego (256)
• Wielowątkowy dostęp do BDE (257)
• Wielowątkowe operacje graficzne (263)
• Włókna (267)
• Podsumowanie (273)

Rozdział 6. Biblioteki DLL (275)

• Czym w istocie jest biblioteka DLL (275)
• Bazowy adres ładowania modułu (276)
• Nieco terminologii... (277)
• Łączenie statyczne kontra łączenie dynamiczne (278)
• Korzyści płynące z używania DLL (279)
• Współdzielenie kodu, zasobów i danych przez wiele aplikacji (279)
• Ukrycie szczegółów implementacyjnych (280)
• Tworzenie i wykorzystywanie bibliotek DLL (281)
• Prosty przykład - poznaj siłę swych pieniędzy (281)
• Formularze modalne w bibliotekach DLL (283)
• Formularze niemodalne w bibliotekach DLL (285)
• Wykorzystywanie bibliotek DLL w aplikacjach Delphi (287)
• Automatyczne ładowanie biblioteki DLL (287)
• Ładowanie biblioteki DLL na żądanie (289)
• Procedura inicjująco-kończąca biblioteki DLL (291)
• Definiowanie procedury inicjująco-kończącej (291)
• Obsługa wyjątków w bibliotekach DLL (296)
• Wyjątki a klauzula Safecall (297)
• Funkcje zwrotne (297)
• Działanie funkcji zwrotnej (300)
• Specyficzne wyświetlanie elementów listy (301)
• Wywoływanie funkcji zwrotnych z bibliotek DLL (301)
• Współdzielenie danych biblioteki DLL przez różne procesy (303)
• Tworzenie bibliotek DLL z pamięcią dzieloną (304)
• Dzielenie globalnych danych biblioteki przez aplikacje (307)
• Eksportowanie obiektów z bibliotek DLL (310)
• Podsumowanie (314)

Część III Programowanie obsługi baz danych (315)
Rozdział 7. Bazodanowa architektura Delphi (317)

• Typy baz danych (317)
• Architektura bazy danych (318)
• Połączenia z serwerami baz danych (318)
• Zbiory danych (319)
• Otwieranie i zamykanie zbioru danych (320)
• Nawigowanie wśród rekordów zbioru danych (323)
• Manipulowanie zawartością zbioru danych (326)
• Pola rekordu bazy danych (331)
• Wartości pól (331)
• Typy pól (332)
• Nazwy i numery pól (332)
• Operowanie zawartością pól (333)
• Edytor pól (334)
• Pola typu BLOB (340)
• Filtrowanie danych (345)
• Przeszukiwanie zbiorów danych (346)
• FindFirst() i FindNext() (347)
• Lokalizowanie rekordu za pomocą metody Locate() (347)
• Przeszukiwanie tabeli za pomocą indeksów (348)
• Moduły danych (352)
• Wyszukiwanie, zakresy, filtrowanie (352)
• Zakładki (360)
• Podsumowanie (361)

Rozdział 8. Tworzenie aplikacji bazodanowych za pomocą technologii dbExpress (363)

• Specyfika technologii dbExpress (363)
• Jednokierunkowe zbiory danych tylko do odczytu (363)
• dbExpress kontra BDE (364)
• dbExpress a aplikacje międzyplatformowe (364)
• Komponenty dbExpress (364)
• TSQLConnection (364)
• TSQLDataSet (367)
• Komponenty kompatybilne (371)
• TSQLMonitor (372)
• Edytowalne, dwukierunkowe zbiory danych dbExpress (372)
• TSQLClientDataSet (372)
• Realizacja aplikacji dbExpress (373)
• Podsumowanie (373)

Rozdział 9. Tworzenie aplikacji bazodanowych za pomocą dbGo for ADO (375)

• Strategia uniwersalnego dostępu do danych (375)
• OLE DB, ADO i ODBC w zarysie (375)
• Wykorzystanie technologii dbGo for ADO (376)
• Ustanawianie połączenia z bazą danych za pomocą dostawcy OLE DB (376)
• Przykładowa baza danych (378)
• Komponenty dbGo for ADO (378)
• Przetwarzanie transakcyjne (384)
• Podsumowanie (386)

Część IV Projektowanie i wykorzystywanie komponentów (387)
Rozdział 10. Architektura komponentów: VCL i CLX (389)

• CLX - odsłona pierwsza (389)
• Co to jest komponent? (389)
• Hierarchia komponentów (390)
• Komponenty niewizualne (390)
• Komponenty wizualne (391)
• Struktura komponentu (393)
• Właściwości komponentu (394)
• Metody (396)
• Zdarzenia (397)
• Komponenty jako właściciele innych komponentów (399)
• Komponenty rodzicielskie (400)
• Hierarchia komponentów wizualnych (400)
• Klasa TPersistent (401)
• Klasa TComponent (402)
• Klasa TControl (404)
• Klasy TWinControl i TWidgetControl (404)
• Klasa TGraphicControl (406)
• Klasy kategorii TCustom... (406)
• Pozostałe klasy (407)
• Wykorzystanie informacji RTTI (410)
• Informacja o genealogii i zestawie właściwości klasy (411)
• Przypisywanie właściwościom wartości za pośrednictwem RTTI (433)
• Podsumowanie (436)

Rozdział 11. Tworzenie komponentów VCL (437)

• Podstawy tworzenia komponentów (438)
• Czy tworzenie nowego komponentu w ogóle jest konieczne? (438)
• Etapy tworzenia nowego komponentu (439)
• Rejestrowanie komponentu (460)
• Testowanie komponentu (461)
• Wybór ikony dla komponentu (463)
• Przykładowe komponenty (464)
• Rozszerzenia kontrolek Win32 (464)
• Komponent TddgRunButton (473)
• Komponenty-pojemniki - TddgButtonEdit (478)
• Koncepcja (479)
• Definiowanie właściwości (479)
• Definiowanie zdarzeń (480)
• TddgDigitalClock - jeszcze jeden przykład definiowania zdarzeń (482)
• Umieszczanie kompletnych formularzy w palecie komponentów (485)
• Podsumowanie (487)

Rozdział 12. Zaawansowane techniki tworzenia komponentów (489)

• Komponenty pseudowizualne (489)
• Niestandardowe podpowiedzi kontekstowe (489)
• Animowane komponenty (493)
• Komponent TddgMarquee (494)
• Testowanie komponentu TddgMarquee (504)
• Tworzenie edytorów właściwości (506)
• Definiowanie nowej klasy edytora (506)
• Edycja właściwości w postaci linii tekstu (508)
• Rejestracja nowego edytora właściwości (512)
• Edycja właściwości za pomocą okna dialogowego (512)
• Edytory komponentów (516)
• TComponentEditor (516)
• TDefaultEditor (517)
• Przykład edycji komponentu (517)
• Rejestracja edytora komponentu (519)
• Przechowywanie w strumieniach niepublikowanych danych komponentu (520)
• Określenie strumieniowalnego charakteru właściwości (520)
• Kategoryzacja właściwości (530)
• Klasy kategorii właściwości (531)
• Kolekcje komponentów - klasy TCollection i TCollectionItem (535)
• Przykładowy element kolekcji - klasa TRunBtnItem (537)
• TRunButtons - kolekcja komponentu (537)
• Implementacja - współpraca kolekcji i jej elementów z komponentem macierzystym (538)
• Edycja kolekcji i jej elementów w dialogowym edytorze właściwości (545)
• Podsumowanie (550)

Rozdział 13. Komponenty międzyplatformowe (551)

• CLX - co to jest? (551)
• Architektura CLX (552)
• Z Windows do Linuksa (555)
• Nie ma komunikatów... (555)
• Przykładowe komponenty (556)
• Edytory środowiskowe CLX (585)
• Pakiety (589)
• Konwencje nazewnicze (590)
• Pakiety wykonywalne (591)
• Pakiety środowiskowe (593)
• Ikony komponentów (596)
• Podsumowanie (597)

Dodatki (599)
Dodatek A Skrócony spis treści tomu II (601)
Skorowidz (603)