Delphi 6. Praktyka programowania.

Opis

Jeśli chcesz pozyskać jak największe możliwości ostatniej wersji Delphi, to nie możesz się obyć bez takiego źródła, jakim jest niniejsza książka ‘Delphi 6’. Ten praktyczny podręcznik pomaga bardziej rozwinąć nasze umiejętności, rozwikłać trudne problemy oraz zbudować i zaimplementować wyszukane funkcje w naszych aplikacjach bazodanowych, w aplikacjach klient/serwer i internetowych. Specjalna intuicja Marco Cantù – eksperta Delphi – da nam dodatkowe korzyści, gdy pomyślnie zakończymy projekty i sami staniemy się mistrzami w Delphi.

Książka ma 2 tomy i zawiera:

• Nową wersję biblioteki fazy realizacji (RTL)
• Naukę stosowania bibliotek VCL i CLX
• Rozwijanie niestandardowych komponentów
• Tworzenie kontrolek danych i niestandardowych zbiorów danych
• Udoskonalenie programowania bazodanowego przy pomocy BDE i dbExpress
• Udoskonalenie programowania client/serwer przy pomocy InterBase
• Tworzenie interfejsów przy pomocy ADO Microsofta oraz zbioru komponentów dbGo
• Wykorzystanie obsługi Delphi dla COM, OLE Automation i COM+
• Programowanie w wielowarstwowej architekturze aplikacji
• Wykorzystanie obsługi Delphi dla technologii XML i SOAP
• Budowanie praktycznych i potężnych aplikacji internetowych

Spis treści – TOM I

Wstęp (str.15)

Część I. Podstawy (str.19)

Rozdział 1. Zintegrowane środowisko programistyczne Delphi 6 (str.21)

1. Różne wydania Delphi 6 (str.22)
2. Środowisko IDE Delphi 6 (str.22)
3. Object TreeView (str.23)
4. Widoki ładowalne (str.25)
5. IDE dla dwu bibliotek (str.27)
6. Mniejsze rozszerzenia (str.28)
7. Bieżące dodatki IDE (str.29)
8. Zapisanie ustawień pulpitu (str.29)
9. Lista To-Do (str.31)
10. Edytor AppBrowser (str.33)
11. Code Explorer (str.33)
12. Przeszukiwanie w edytorze (str.35)
13. Dokańczanie klas (str.36)
14. Code Insight (str.36)
15. Dodatkowe skróty klawiszowe w edytorze (str.39)
16. Form Designer (str.39)
17. Object Inspector w Delphi 6 (str.41)
18. Tajemnice palety komponentów (str.45)
19. Definiowanie procedur obsługi zdarzeń (str.46)
20. Kopiowanie i wklejanie komponentów (str.46)
21. Od szablonów komponentów do ramek (str.47)
22. Zarządzanie projektami (str.49)
23. Opcje projektu (str.51)
24. Kompilowanie i tworzenie projektów (str.52)
25. Eksploracja projektu (str.53)
26. Dodatkowe oraz zewnętrzne narzędzia Delphi (str.54)
27. Pliki tworzone przez system (str.55)
28. Przeglądanie plików kodu źródłowego (str.60)
29. Object Repository (str.62)
30. W następnych rozdziałach (str.65)

Rozdział 2. Object Pascal: klasy i obiekty (str.67)

1. Język Object Pascal (str.68)
2. Nowa dyrektywa kompilatora $IF (str.68)
3. Nowe dyrektywy podpowiedzi (str.71)
4. Dyrektywa $WARN (str.72)
5. Dyrektywa $MESSAGE (str.73)
6. Klasy i obiekty (str.73)
7. Klasy, obiekty i programowanie wizualne (str.75)
8. Słowo kluczowe self (str.76)
9. Przeciążone metody (str.77)
10. Dynamiczne tworzenie komponentów (str.78)
11. Metody i dane klasy (str.80)
12. Hermetyzacja (str.81)
13. Hermetyzacja i moduły (str.81)
14. Pola Private, Protected i Public (str.82)
15. Hermetyzacja poprzez właściwości (str.84)
16. Hermetyzacja a formularze (str.88)
17. Konstruktory (str.91)
18. Przeciążone metody i konstruktory (str.93)
19. Destruktory (str.94)
20. Kompletna definicja klasy TDate (str.95)
21. Model odwołań do obiektów w Delphi (str.99)
22. Przypisywanie obiektów (str.100)
23. Obiekty i pamięć (str.102)
24. W następnych rozdziałach (str.103)

Rozdział 3. Język Object Pascal: dziedziczenie i polimorfizm (str.105)

1. Dziedziczenie od istniejących typów (str.105)
2. Pola chronione i hermetyzacja (str.108)
3. Dziedziczenie a kompatybilność typów (str.111)
4. Późne wiązanie i polimorfizm (str.113)
5. Pokrywanie, ponowne definiowanie i wprowadzanie metod (str.116)
6. Metody wirtualne a dynamiczne (str.118)
7. Metody abstrakcyjne (str.119)
8. Bezpieczna konwersja typu (str.122)
9. Użycie interfejsów (str.124)
10. Właściwości interfejsu, delegacja, ponowne definiowanie, agregacja i liczenie odwołań (str.128)
11. Obsługa wyjątków (str.132)
12. Przebieg programu i blok finally (str.134)
13. Klasy wyjątków (str.136)
14. Rejestrowanie błędów w dzienniku (str.138)
15. Odwołania do klas (str.139)
16. Tworzenie komponentów za pomocą odwołań do klas (str.141)
17. W następnych rozdziałach (str.143)

Rozdział 4. Biblioteka RTL (str.145)

1. Moduły RTL (str.146)
2. Moduły System i SysInit (str.148)
3. Moduły SysUtils i SysConst (str.149)
4. Moduł Math (str.152)
5. Nowe moduły ConvUtils i StdConvs (str.154)
6. Nowy moduł DateUtils (str.154)
7. Nowy moduł StrUtils (str.155)
8. Nowy moduł Types (str.156)
9. Nowe moduły Variants i VarUtils (str.157)
10. Moduły DelphiMM i ShareMem (str.158)
11. Moduły odnoszące się do COM (str.158)
12. Konwersja danych (str.158)
13. Kilka uwag o konwersji walut (str.162)
14. Klasa TObject (str.166)
15. Program wyświetlający informacje o klasach (str.169)
16. W następnych rozdziałach (str.170)

Rozdział 5. Techniki programowania biblioteki VCL (str.171)

1. Pakiet RTL, VCL oraz CLX (str.172)
2. Tradycyjne składowe VCL (str.172)
3. Struktura CLX (str.173)
4. Składowe biblioteki specyficzne dla VCL (str.174)
5. Klasa TPersistent (str.175)
6. Specyfikator published (str.176)
7. Dostęp do właściwości przez nazwę (str.177)
8. Klasa TComponent (str.180)
9. Właściciel (str.180)
10. Właściwość Name (str.184)
11. Usuwanie pól formularza (str.185)
12. Ukrywanie pól formularza (str.186)
13. Właściwość Tag (str.188)
14. Zdarzenia (str.188)
15. Zdarzenia w Delphi (str.188)
16. Wskaźniki metod (str.189)
17. Zdarzenia są właściwościami (str.190)
18. Listy i klasy kontenerów (str.193)
19. Listy i listy łańcuchów (str.193)
20. Kolekcje (str.196)
21. Klasy kontenerów (str.196)
22. Kontenery i listy bezpieczne pod względem typów (str.199)
23. Strumienie (str.202)
24. Klasa TStream (str.202)
25. Klasy strumieni specjalnych (str.204)
26. Używanie strumieni plikowych (str.205)
27. Strumienie i niezmienność (str.207)
28. Podsumowanie modułów Core VCL i BaseCLX (str.212)
29. Moduł Classes (str.212)
30. Inne główne moduły (str.214)
31. W następnych rozdziałach (str.214)

Część II. Programowanie wizualne (str.215)

Rozdział 6. Kontrolki: VCL kontra VisualCLX (str.217)

1. VCL a VisualCLX (str.218)
2. Obsługa obu bibliotek Delphi 6 (str.219)
3. Wybór biblioteki wizualnej (str.223)
4. Konwersja istniejących aplikacji (str.225)
5. TControl i klasy pochodne (str.227)
6. Kontrolki a właściwość Parent (str.229)
7. Właściwości określające rozmiar i umiejscowienie komponentów na ekranie (str.229)
8. Właściwości określające aktywność i widoczność komponentów (str.230)
9. Czcionki (str.230)
10. Kolory (str.231)
11. Klasa TWinControl w VCL (str.232)
12. Klasa TWidgetControl w CLX (str.233)
13. Otwieramy okno komponentów (str.233)
14. Komponenty umożliwiające wprowadzanie danych tekstowych (str.234)
15. Wybieranie opcji (str.238)
16. Listy (str.239)
17. Kontrolki zakresu (str.245)
18. Kontrola kolejności przechodzenia między komponentami (str.247)
19. Tworzenie menu (str.250)
20. Klawisze skrótów (str.251)
21. Menu podręczne i zdarzenie OnContextPopup (str.252)
22. Dynamiczne tworzenie menu (str.253)
23. Elementy graficzne w menu (str.257)
24. Modyfikacja menu systemowego (str.259)
25. Kontrolki malowane przez komponent właściciela (str.263)
26. Elementy menu malowane przez właściciela (str.264)
27. Pole listy z kolorami (str.266)
28. Style CLX (str.269)
29. W następnych rozdziałach (str.271)

Rozdział 7. Zaawansowane kontrolki VCL (str.273)

1. Komponenty ListView i TreeView (str.274)
2. Lista z elementami graficznymi (str.274)
3. Struktura drzewiasta (str.279)
4. Niestandardowe węzły drzewa (str.282)
5. Formularze z wieloma kartami (str.284)
6. Komponenty PageControl i TabSheet (str.285)
7. Zakładki w programie graficznym (str.290)
8. Interfejs kreatora (str.294)
9. Sposoby dzielenia formularza (str.298)
10. Dzielenie w pionie (str.299)
11. Dzielenie za pomocą komponentu HeaderControl (str.301)
12. Kotwice kontrolek (str.303)
13. Kontrolka Toolbar (str.305)
14. Przykład RichBar (str.307)
15. Menu i pole rozwijane na pasku narzędzi (str.309)
16. Podpowiedzi paska narzędzi (str.310)
17. Prosty pasek stanu (str.311)
18. Dostosowanie podpowiedzi do własnych potrzeb (str.314)
19. W następnych rozdziałach (str.316)

Rozdział 8. Tworzenie interfejsu użytkownika (str.317)

1. Komponent ActionList (str.317)
2. Akcje standardowe w Delphi 6 (str.320)
3. Akcje w praktyce (str.321)
4. Komponenty Toolbar i ActionList w edytorze (str.326)
5. Kontenery na paski narzędzi (str.328)
6. CoolBar (str.328)
7. ControlBar (str.330)
8. Obsługa dokowania w Delphi (str.333)
9. Dokowanie paska narzędzi w komponencie ControlBar (str.335)
10. Dokowanie na komponencie PageControl (str.338)
11. Architektura ActionManagera (str.341)
12. Budowanie prostej aplikacji (str.341)
13. Ostatnio używane elementy menu (str.344)
14. Przenoszenie istniejącego programu (str.346)
15. Użycie akcji list (str.347)
16. W następnych rozdziałach (str.350)

Rozdział 9. Praca z formularzami (str.351)

1. Klasa TForm (str.352)
2. Używanie zwykłych formularzy (str.352)
3. Styl formularza (str.354)
4. Styl obramowania (str.355)
5. Ikony obramowania (str.358)
6. Ustawianie innych stylów okna (str.360)
7. Wprowadzanie danych przez formularz (str.362)
8. Wprowadzanie danych (str.362)
9. Pobieranie danych z myszy (str.364)
10. Przeciąganie i rysowanie za pomocą myszy (str.366)
11. Malowanie w Windows (str.371)
12. Inne techniki: Alpha Blending, Color Key oraz Animate API (str.373)
13. Ustawienie rozmiaru i położenia formularza (str.374)
14. Położenie formularza (str.375)
15. Rozmiar formularza i jego obszaru roboczego (str.376)
16. Ograniczenia dotyczące rozmiaru formularzy (str.377)
17. Przewijanie formularza (str.377)
18. Skalowanie formularzy (str.383)
19. Automatyczne skalowanie formularza (str.386)
20. Tworzenie formularzy (str.387)/
21. Zdarzenia tworzące formularz (str.389)
22. Zamykanie formularza (str.390)
23. Okna dialogowe a formularze (str.391)
24. Dodawanie podrzędnego formularza do programu (str.392)
25. Dynamiczne tworzenie podrzędnych formularzy (str.393)
26. Tworzenie okna dialogowego (str.396)
27. Okno dialogowe z przykładu RefList (str.396)
28. Niemodalne okno dialogowe (str.400)
29. Standardowe okna dialogowe zdefiniowane w Windows (str.403)
30. Zwykłe okna dialogowe Windows (str.403)
31. Zdefiniowane w Delphi okna komunikatów (str.405)
32. Okna „O programie…” i ekrany powitania (str.406)
33. Tworzenie ekranu powitania (str.406)
34. W następnych rozdziałach (str.410)

Rozdział 10. Architektura aplikacji Delphi (str.411)

1. Obiekt Application (str.412)
2. Wyświetlanie okna aplikacji (str.414)
3. Menu systemowe aplikacji (str.415)
4. Aktywowanie aplikacji i formularzy (str.417)
5. Śledzenie formularzy za pomocą obiektu Screen (str.418)
6. Zdarzenia, komunikaty i wielozadaniowość w Windows (str.423)
7. Programowanie sterowane zdarzeniami (str.423)
8. Dostarczanie komunikatów za pomocą Windows (str.424)
9. Przetwarzanie w tle i wielowątkowość (str.424)
10. Sprawdzanie istnienia poprzedniego egzemplarza aplikacji (str.425)
11. Znalezienie kopii głównego okna (str.426)
12. Użycie muteksu (str.426)
13. Przeszukanie listy okien (str.427)
14. Obsługa komunikatów okna zdefiniowanych przez użytkownika (str.429)
15. Tworzenie aplikacji MDI (str.429)
16. MDI w Windows: opis techniczny (str.430)
17. Okno obramowujące i okna potomne w Delphi (str.430)
18. Tworzenie całego menu Window (str.432)
19. Przykład MdiDemo (str.433)
20. Aplikacje MDI z oknami różnych rodzajów (str.436)
21. Formularze potomne i łączące się menu (str.436)
22. Główny formularz (str.437)
23. Podział na podklasy okna MdiClient (str.438)
24. Wizualne dziedziczenie a formularze (str.440)
25. Dziedziczenie z formularza bazowego (str.441)
26. Formularze polimorficzne (str.445)
27. Ramki (str.448)
28. Ramki i karty (str.452)
29. Ramki bez kart (str.453)
30. Formularze bazowe i interfejsy (str.455)
31. Klasa formularzy bazowych (str.455)
32. Używanie interfejsów (str.459)
33. W następnych rozdziałach (str.460)

Rozdział 11. Tworzenie komponentów (str.461)

1. Rozbudowa biblioteki VCL (str.462)
2. Pakiety komponentów (str.462)
3. Zasady pisania komponentów (str.464)
4. Bazowe klasy komponentów (str.465)
5. Budujemy pierwszy komponent (str.465)
6. Lista rozwijana z czcionkami (str.465)
7. Utworzenie pakietu (str.470)
8. Użycie listy rozwijanej z czcionkami (str.474)
9. Tworzenie komponentów złożonych (str.474)
10. Publikowanie podkomponentów w Delphi 6 (str.475)
11. Bitmapy palety komponentów (str.477)
12. Złożony komponent graficzny (str.481)
13. Zdefiniowanie właściwości wyliczeniowej (str.482)
14. Metoda Paint (str.484)
15. Dodanie właściwości TPersistent (str.486)
16. Zdefiniowanie nowego zdarzenia (str.488)
17. Zarejestrowanie kategorii właściwości (str.490)
18. Modyfikacja kontrolek Windows (str.492)
19. Przysłanianie procedur obsługi komunikatów: liczbowe pole edycji (str.492)
20. Pokrywanie metod dynamicznych: przycisk Sound (str.495)
21. Obsługa wewnętrznych komunikatów: przycisk Active (str.497)
22. Komunikaty komponentów i powiadomienia (str.498)
23. Niewizualny komponent (str.504)
24. Użycie komponentu niewizualnego (str.507)
25. Definiowanie niestandardowych akcji (str.508)
26. Tworzenie edytorów właściwości (str.510)
27. Edytor dla właściwości dźwiękowych (str.512)
28. Zainstalowanie edytora właściwości (str.515)
29. Utworzenie edytora komponentów (str.517)
30. Utworzenie podklasy klasy TComponentEditor (str.517)
31. Edytor komponentu ListDialog (str.518)
32. Zarejestrowanie edytora komponentów (str.520)
33. W następnych rozdziałach (str.520)

Rozdział 12. Biblioteki i pakiety (str.521)

1. Rola bibliotek DLL w Windows (str.522)
2. Co to jest łączenie dynamiczne (str.522)
3. Do czego służą biblioteki DLL (str.524)
4. Zasady pisania bibliotek DLL w Delphi (str.526)
5. Korzystanie z istniejących bibliotek DLL (str.527)
6. Tworzenie DLL w Delphi (str.530)
7. Pierwsza prosta biblioteka DLL napisana w Delphi (str.530)
8. Wywołanie DLL napisanej w Delphi (str.534)
9. Nazwy projektów i bibliotek w Delphi 6 (str.535)
10. Formularz Delphi w DLL (str.536)
11. Użycie formularza DLL jako modalnego (str.537)
12. Formularz niemodalny w DLL (str.539)
13. Wywołanie DLL Delphi z języka Visual Basic for Applications (str.542)
14. Wywołanie funkcji DLL w czasie wykonywania programu (str.543)
15. DLL w pamięci: kod i dane (str.546)
16. Współdzielenie danych za pomocą plików odwzorowanych w pamięci (str.547)
17. Użycie pakietów Delphi (str.549)
18. Pakiety dla różnych wersji aplikacji (str.550)
19. Formularze wewnątrz pakietów (str.551)
20. Ładowanie pakietów w czasie realizacji (str.554)
21. Stosowanie interfejsów w pakietach (str.555)
22. Pliki wykonywalne i biblioteki DLL współdzielące pakiety VCL (str.559)
23. Badamy strukturę pakietu (str.561)
24. W następnych rozdziałach (str.566)

Spis treści – TOM II

Część III. Programowanie bazodanowe (str.13)

Rozdział 13. Architektura baz danych w Delphi (str.15)

1. Dostęp do bazy danych: BDE, dbExpress i inne (str.16)
2. Borland Database Engine (BDE) (str.16)
3. ActiveX Data Objects (str.17)
4. Biblioteka dbExpress (str.18)
5. InterBase Express (str.18)
6. Komponent ClientDataSet (str.19)
7. Klasyczne składowe BDE (str.19)
8. Tabele i zapytania (str.20)
9. Tworzenie struktury jeden do wielu (str.24)
10. Inne komponenty dostępu do danych (str.28)
11. Kontrolki danych w Delphi (str.29)
12. Dane na siatce (str.29)
13. DBNavigator i akcje na zbiorze danych (str.30)
14. Tekstowe kontrolki danych (str.30)
15. Kontrolki danych dla list (str.31)
16. Kontrolki przeglądania (str.33)
17. Graficzne kontrolki danych (str.35)
18. Komponent DataSet (str.37)
19. Stan zbioru danych (str.42)
20. Dostęp do pól danych (str.43)
21. Obiekty pola (str.46)
22. Hierarchia klas pól (str.47)
23. Dodawanie pola obliczeniowego (str.50)
24. Pola przeglądania (str.54)
25. Obsługa wartości Null za pomocą zdarzeń pola (str.55)
26. Nawigowanie po zbiorze danych (str.56)
27. Lokalizowanie rekordów w tabeli (str.57)
28. Sumowanie kolumny tabeli (str.58)
29. Zakładki tabeli (str.60)
30. Edytowanie kolumny tabeli (str.62)
31. Tworzenie niestandardowej siatki bazy (str.62)
32. Rysowanie DBGrid (str.63)
33. Komórka z polem wyboru (str.65)
34. Siatka pozwalająca na zaznaczanie wielu rekordów (str.67)
35. Przeciąganie na siatkę (str.69)
36. Aplikacje bazodanowe ze standardowymi kontrolkami (str.70)
37. Naśladowanie kontrolek danych w Delphi (str.70)
38. Przesyłanie żądań do bazy danych (str.73)
39. Zdarzenia bazy danych (str.75)
40. Zdarzenia pól (str.77)
41. Edytowanie dat za pomocą kalendarza (str.78)
42. Siatka z wieloma rekordami (str.80)
43. Panele siatki z kontrolkami (str.81)
44. Obsługa błędów w bazie danych (str.82)
45. W następnych rozdziałach (str.85)

Rozdział 14. Programowanie aplikacji klient-serwer (str.87)

1. Przegląd programowania aplikacji klient-serwer (str.88)
2. Od programowania lokalnego do aplikacji klient-serwer (str.90)
3. Kursory jednokierunkowe (str.90)
4. Zapytania parametryczne i wartości Null (str.91)
5. Elementy projektowania baz danych (str.92)
6. Encje i relacje (str.92)
7. Od kluczy głównych do OID (str.93)
8. Więcej ograniczeń (str.95)
9. Programowanie klient-serwer przy użyciu BDE (str.96)
10. Łączenie przez SQL (str.96)
11. Komponent Database (str.97)
12. Komponenty Table i Query w środowisku klient-serwer (str.98)
13. Dynamiczne zapytania i uaktualnienia buforowane (str.99)
14. Komponent UpdateSQL (str.101)
15. Korzystanie z transakcji (str.106)
16. Używanie SQL Monitora (str.108)
17. Biblioteka dbExpress (str.112)
18. Praca z kursorami jednokierunkowymi (str.112)
19. Platformy i bazy danych (str.113)
20. Komponenty dbExpress (str.113)
21. Komponenty zbioru danych dbExpress (str.118)
22. Jednokierunkowe drukowanie danych (str.126)
23. ClientDataSet i MyBase (str.129)
24. Grupowanie i agregaty (str.132)
25. Uaktualnienia (str.136)
26. Dostęp do zbioru danych Delta (str.137)
27. Aktualizacja danych (str.139)
28. MyBase (model aktówki Briefcase) (str.142)
29. W następnych rozdziałach (str.146)

Rozdział 15. InterBase i IBX (str.147)

1. Rozpoczynanie pracy z InterBase 6 (str.147)
2. Wewnątrz InterBase (str.148)
3. IBConsole (str.150)
4. Programowanie od strony serwera (str.152)
5. Procedury zapamiętane (str.153)
6. Wyzwalacze (i generatory) (str.154)
7. InterBase Express (str.155)
8. Komponenty zbioru danych IBX (str.156)
9. Komponenty administracyjne IBX (str.157)
10. Od BDE do IBX (str.157)
11. Budujemy zapytanie dynamiczne (str.159)
12. Monitorowanie InterBase Express (str.163)
13. Uzyskiwanie danych systemowych (str.164)
14. Bloki Real-World (str.165)
15. Generatory i ID (str.165)
16. Przeszukiwania z uwzględnieniem wielkości liter (str.167)
17. Obsługa siedzib i pracowników (str.169)
18. Budowanie interfejsu użytkownika (str.171)
19. Rejestracja na zajęcia (str.174)
20. Budowanie okna dialogowego do przeglądania (str.177)
21. Dodanie wolnego formularza do zapytań (str.179)
22. W następnych rozdziałach (str.180)

Rozdział 16. ActiveX Data Objects (str.180)

1. Komponenty dostępu do danych Microsoftu – MDAC (str.183)
2. Dostawcy OLE DB (str.184)
3. Dostawcy MDAC OLE DB (str.185)
4. dbGo (str.187)
5. TADOConnection (str.190)
6. Pliki łączenia danych (str.191)
7. Właściwości dynamiczne (str.192)
8. Uzyskiwanie informacji o strukturze (str.193)
9. Użycie motoru Jet (str.194)
10. Paradox (str.195)
11. Excel (str.196)
12. Pliki tekstowe (str.198)
13. Importowanie i eksportowanie (str.199)
14. Położenie kursora i typy kursorów (str.201)
15. Prośmy, ale nie wiadomo, czy dostaniemy (str.203)
16. RecordCount = –1 (str.204)
17. Indeksy klienta (str.204)
18. Klonowanie (str.205)
19. Przetwarzanie transakcji (str.207)
20. Transakcje zagnieżdżone (str.210)
21. Lock Types (str.212)
22. Blokowanie pesymistyczne (str.212)
23. Blokowanie na poziomie strony i na poziomie wierszy w Jet (str.213)
24. Uaktualnienia JOIN (str.215)
25. Uaktualnienia wsadowe (str.216)
26. Blokowanie optymistyczne (str.218)
27. Rozwiązywanie konfliktów uaktualnień (str.221)
28. Zbiory rekordów odłączonych (str.221)
29. Pooling połączeń (str.223)
30. Trwałe zbiory rekordów (str.225)
31. Model aktówki (str.226)
32. Rozwijanie MDAC (str.226)
33. W następnych rozdziałach (str.228)

Rozdział 17. Wielowarstwowe aplikacje bazodanowe z użyciem DataSnap (str.229)

1. Jeden, dwa, trzy poziomy (str.230)
2. Podstawy techniczne DataSnap (str.232)
3. Interfejs IAppServer (str.233)
4. Protokół połączenia (str.234)
5. Pakiety danych (str.235)
6. Komponenty wspierające Delphi (po stronie klienta) (str.236)
7. Komponenty wspierające Delphi (po stronie serwera) (str.237)
8. Budowanie przykładowej aplikacji (str.238)
9. Pierwszy serwer aplikacji (str.238)
10. Pierwszy ,,chudy” klient (str.240)
11. Dodanie ograniczeń do serwera (str.242)
12. Ograniczenia dla pola i tabeli (str.242)
13. Zawieranie właściwości pól (str.243)
14. Zdarzenia pól i tabel (str.244)
15. Dodanie nowych możliwości do klienta (str.245)
16. Kolejność aktualizacji (str.246)
17. Odświeżanie danych (str.246)
18. Zaawansowane możliwości DataSnap (str.248)
19. Zapytania parametryczne (str.249)
20. Niestandardowe metody (str.250)
21. Relacje jeden do wielu (str.251)
22. Używanie brokera połączeń (str.252)
23. Więcej opcji dostawcy (str.253)
24. Komponent SimpleObjectBroker (str.254)
25. Pooling obiektów (str.254)
26. Dostosowanie pakietów danych (str.255)
27. W następnych rozdziałach (str.256)

Rozdział 18. Tworzenie komponentów bazodanowych (str.257)

1. Połączenie danych (str.257)
2. Klasa TDataLink (str.258)
3. Klasy pochodne DataLink (str.259)
4. Tworzenie kontrolek danych dla pól (str.259)
5. Pasek ProgressBar tylko z odczytywaniem (str.259)
6. Pasek TrackBar do odczytu i zapisywania (str.263)
7. Tworzenie niestandardowych połączeń danych (str.267)
8. Komponent do przeglądania rekordów (str.267)
9. Dostosowywanie komponentu DBGrid (str.273)
10. Budowanie niestandardowych zbiorów danych (str.277)
11. Definicja klas (str.278)
12. Część I: inicjalizacja, otwieranie i zamykanie (str.281)
13. Część II: zarządzanie przemieszczaniem i zakładkami (str.287)
14. Część III: zarządzanie buforami rekordów i polami (str.290)
15. Część IV: od buforów do pól (str.294)
16. Testowanie zbioru danych opartego na strumieniach (str.296)
17. Katalog w zbiorze danych (str.297)
18. Lista jako zbiór danych (str.298)
19. Dane katalogowe (str.299)
20. W następnych rozdziałach (str.303)

Część IV. Poza Delphi: łączenie się ze światem (str.305)

Rozdział 19. Programowanie COM (str.307)

1. Co to jest OLE i COM (str.308)
2. Implementacja IUnknown (str.310)
3. Jednoznaczne identyfikatory globalne (str.312)
4. Rola fabryk klas (str.314)
5. Fabryki klas i inne klasy COM w Delphi (str.315)
6. Pierwszy serwer COM (str.316)
7. Interfejsy i obiekty COM (str.317)
8. Inicjalizacja obiektu COM (str.320)
9. Testowanie serwera COM (str.321)
10. Użycie właściwości interfejsu (str.324)
11. Wywoływanie metod wirtualnych (str.325)
12. Użycie interfejsu powłoki (str.326)
13. Tworzenie skrótów (str.326)
14. Używanie powłoki API i obiektów (str.329)
15. Aplikacja ,,planu pracy” (str.330)
16. Utworzenie programu obsługi menu podręcznego (str.333)
17. W następnych rozdziałach (str.340)

Rozdział 20. Od automatyzacji do COM+ (str.341)

1. Automatyzacja OLE (str.341)
2. Wprowadzenie do bibliotek typów (str.343)
3. Utworzenie serwera automatyzacji OLE (str.345)
4. Edytor bibliotek typów (str.346)
5. Kod serwera (str.348)
6. Zarejestrowanie serwera automatyzacji (str.351)
7. Przygotowanie klienta dla serwera (str.352)
8. Interfejsy, zmienne typu Variant i interfejsy wysyłające: porównanie szybkości działania (str.353)
9. Zakres obiektów automatyzacji (str.355)
10. Serwer w komponencie (str.356)
11. Typy danych OLE (str.358)
12. Użycie programów pakietu Office (str.362)
13. Wysyłanie danych do Worda (str.363)
14. Utworzenie tabeli Excela (str.365)
15. Użycie dokumentów złożonych (str.367)
16. Komponent OLE Container (str.369)
17. Użycie obiektu wewnętrznego (str.372)
18. Wprowadzenie do kontrolek ActiveX (str.373)
19. Kontrolki ActiveX a komponenty Delphi (str.375)
20. Użycie kontrolek ActiveX w Delphi (str.376)
21. Tworzenie kontrolek ActiveX (str.378)
22. Budowanie kontrolki ActiveX Arrow (str.378)
23. Dodanie nowych właściwości (str.381)
24. Dodanie karty właściwości (str.383)
25. Formularze ActiveForm (str.386)
26. Organizacja wewnętrzna ActiveForm (str.386)
27. Kontrolka ActiveX XClock (str.388)
28. Formularze ActiveForm na stronach WWW (str.388)
29. Rola formularza ActiveX na stronie WWW (str.391)
30. Ustawienie właściwości XArrow (str.392)
31. Wprowadzenie do COM+ (str.393)
32. Utworzenie komponentu COM+ (str.393)
33. Transakcyjne moduły danych (str.396)
34. Zdarzenia COM+ (str.397)
35. W następnych rozdziałach (str.401)

Rozdział 21. Programowanie w Internecie: gniazda i komponenty Indy (str.401)

1. Podstawy programowania gniazd (str.404)
2. Skonfigurowanie sieci lokalnej: adresy IP (str.404)
3. Lokalne nazwy domen (str.405)
4. Porty TCP (str.405)
5. Protokoły wysokiego poziomu (str.406)
6. Połączenia przez gniazda (str.406)
7. Komponenty gniazd Delphi (str.407)
8. Hosty i porty (str.407)
9. Połączenia blokujące, nie blokujące i wielowątkowe (str.407)
10. Używanie gniazd (str.408)
11. Użycie gniazd z niestandardowym protokołem (str.411)
12. Przesyłanie informacji z bazy danych przez połączenie gniazdowe (str.415)
13. Gniazda blokujące i wątki (str.418)
14. Protokoły internetowe (str.424)
15. Wysyłanie i odbieranie poczty (str.424)
16. Wysyłanie wiadomości do programu pocztowego (str.425)
17. Odbieranie i wysyłanie poczty (str.426)
18. Działanie za pomocą HTTP (str.428)
19. Przejęcie zawartości HTTP (str.429)
20. Przeglądanie niestandardowe (str.434)
21. Prosty serwer HTTP (str.436)
22. Język HTML (str.437)
23. Użycie komponentów Delphi z serii Producer (str.439)
24. Generowanie stron HTML (str.439)
25. Generowanie stron z danymi (str.442)
26. Generowanie tabel HTML (str.443)
27. Użycie arkuszy stylu (str.446)
28. Dynamiczne strony niestandardowego serwera (str.447)
29. Publikowanie statycznych baz danych w sieci WWW (str.448)
30. W następnych rozdziałach (str.449)

Rozdział 22. Programowanie w Internecie za pomocą WebBrokera i WebSnapa (str.451)

1. Dynamiczne strony WWW (str.452)
2. Przegląd CGI (str.453)
3. Przegląd ISAPI/NSAPI (str.454)
4. WebBroker w Delphi (str.456)
5. Budowanie uniwersalnego WebModule (str.460)
6. Generowanie dynamicznego raportu o bazach danych (str.463)
7. Zapytania i formularze (str.465)
8. Wykonywanie za pomocą Web App Debuggera (str.469)
9. Praca z Apache’em (str.472)
10. Praktyczne przykłady (str.474)
11. Licznik odwiedzin strony WWW (str.474)
12. Wyszukiwanie za pomocą motoru Web Search (str.476)
13. Active Server Pages (str.478)
14. WebSnap (str.482)
15. Zarządzanie wieloma stronami (str.485)
16. Skrypty po stronie serwera (str.487)
17. Karty (str.490)
18. WebSnap i bazy danych (str.495)
19. Moduł danych WebSnap (str.496)
20. DataSetAdapter (str.496)
21. Edytowanie danych w formularzu (str.499)
22. Relacja jeden do wielu w architekturze WebSnap (str.501)
23. Sesje, użytkownicy i prawa dostępu (str.504)
24. Sesje (str.504)
25. Polecenie Login (str.506)
26. W następnych rozdziałach (str.508)

Rozdział 23. XML i SOAP (str.509)

1. Wprowadzenie do XML (str.510)
2. Składnia jądra XML (str.511)
3. Dobrze określony XML (str.512)
4. Praca z XML (str.512)
5. Zarządzanie dokumentami XML (str.514)
6. Programowanie za pomocą modelu DOM (str.515)
7. Interfejsy XML wiążące dane (str.525)
8. Używanie SAX API (str.529)
9. Odwzorowanie XML za pomocą transformacji (str.533)
10. XML i Internet Express (str.539)
11. Komponent XMLBroker (str.540)
12. Obsługa JavaScript (str.541)
13. Użycie XSLT (str.550)
14. XSTL w praktyce (str.551)
15. XSLT z użyciem WebSnapa (str.552)
16. Bezpośrednie transformacje XSL za pomocą DOM (str.554)
17. Usługi WWW (str.555)
18. SOAP i WSDL (str.556)
19. Translacje BabelFish (str.557)
20. Budowanie usługi WWW (str.559)
21. DataSnap nad SOAP (str.563)
22. Zakończenie (str.565)

Dodatek A. Przykład RichBar (str.567)

Dodatek B. SQL (str.573)

Skorowidz (str.587)