Spośród wielu dostępnych środowisk programistycznych Delphi wyróżnia się łatwością i szybkością tworzenia aplikacji. Zastosowany język programowania ObjectPascal utrwala dobre nawyki programowania strukturalnego, wzbogacając je o nowe możliwości, jakie niesie za sobą programowanie zorientowane obiektowo. Wygodne środowisko RAD, możliwość łatwego uzyskiwania dostępu do relacyjnych baz danych oraz możliwość tworzenia aplikacji wieloplatformowych, to kolejne zalety Delphi, które przekonały doń rzesze programistów.

Książka "Delphi 7. Kompendium programisty" to -- jak wskazuje jej tytuł -- kompletny przewodnik po Delphi, obejmujący zarówno opis zintegrowanego środowiska programistycznego, języka ObjectPascal, jak i najważniejszych funkcjonalności zawartych w dołączonych do Delphi bibliotekach. Jest to pozycja dla początkujących adeptów sztuki programistycznej, a także dla tych wszystkich, którzy chcą poszerzyć i wzbogacić swoją wiedzę o tym wygodnym narzędziu.

Książka przedstawia:

• Podstawowe informacje o Delphi
• Język ObjectPascal -- jego strukturę i składnię
• Programowanie zorientowane obiektowo
• Interfejs Delphi
• Obsługę komunikatów w Delphi
• Korzystanie z rejestru Windows i plików .ini
• Dostęp do plików
• Tworzenie aplikacji wielowątkowych
• Multimedialne funkcje Delphi
• Tworzenie aplikacji sieciowych
• Pisanie własnych bibliotek DLL
• Wykorzystanie oraz tworzenie własnych bibliotek VCL i CLX
• Dostęp do relacyjnych baz danych
• IntraWeb -- Delphi i WWW

Do książki dołączony jest CD-ROM, na którym znajdziesz kody źródłowe wykorzystane w książce. Cennym uzupełnieniem jest także dodatek, przedstawiający przetestowane w praktyce zalecenia dotyczące pisania czytelnego kodu w Delphi.

Osoby które kupowały "Delphi 7. Kompendium programisty", wybierały także:

• Aplikacje w Delphi. Przykłady. Wydanie III 57,95 zł, (32,45 zł -44%)
• Delphi 2007 dla WIN32 i bazy danych 89,00 zł, (66,75 zł -25%)
• Programowanie w języku Delphi 49,00 zł, (36,75 zł -25%)
• Fearless Cross-Platform Development with Delphi 159,00 zł
• Delphi GUI Programming with FireMonkey 159,00 zł

Spis treści

Delphi 7. Kompendium programisty -- spis treści

Wstęp (17)

Część I (19)

Rozdział 1. Podstawy Delphi (21)

• Czym jest programowanie? (21)
• Przegląd języków programowania (22)
• Czym jest Delphi? (23)
  • Co należy umieć? (23)
• Historia Delphi (24)
• Proces instalacji (24)
  • Korzystanie z polskich liter (24)
• Wygląd Delphi (25)
  • Okno główne (26)
  • Projektant formularzy (27)
  • Inspektor obiektów (28)
  • Drzewo obiektów (29)
  • Edytor kodu (30)
• Pierwszy projekt (32)
  • Tworzenie projektu (32)
  • Zapisywanie projektu (34)
  • Otwieranie projektu (34)
• Kompilacja projektu (35)
• Pliki projektu (35)
• Podsumowanie (36)

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

• Plik źródłowy projektu (37)
  • Najprostszy program (38)
• Podstawowa składnia (38)
  • Wielkość liter (39)
  • Pamiętaj o średniku! (39)
  • Bloki begin i end (39)
  • Dyrektywa program (40)
• Komentarze (40)
• Zmienne (41)
  • Deklaracja zmiennych (42)
  • Typy zmiennych (42)
  • Deklaracja kilku zmiennych (44)
  • Przydział danych (44)
• Stałe (46)
  • Domyślne typy stałych (46)
• Używanie stałych i zmiennych w programie (47)
• Tablice danych (48)
  • Tablice jako stałe (49)
  • Tablice wielowymiarowe (50)
  • Tablice dynamiczne (51)
• Operatory (53)
• Aplikacje konsolowe (54)
• Instrukcje warunkowe (55)
  • Instrukcja if..then (55)
  • Instrukcja case..of (58)
  • Instrukcja else (60)
• Procedury i funkcje (63)
  • Procedury (63)
  • Funkcje (64)
  • Zmienne lokalne (65)
  • Parametry procedur i funkcji (66)
  • Parametry domyślne (67)
  • Przeciążanie funkcji i procedur (68)
  • Typy parametrów przekazywanych do procedur i funkcji (69)
  • Procedury zagnieżdżone (71)
• Własne typy danych (71)
  • Tablice jako nowy typ (72)
• Aliasy typów (73)
• Rekordy (73)
  • Przekazywanie rekordów jako parametr procedury (73)
  • Deklaracja rekordu jako zmienna (75)
  • Instrukcja packed (75)
• Instrukcja wiążąca with (75)
• Moduły (76)
  • Tworzenie nowego modułu (76)
  • Budowa modułu (77)
  • Włączanie modułu (78)
  • Sekcja Initialization oraz Finalization (78)
• Konwersja typów (79)
• Rzutowanie (81)
• Pętle (82)
  • Pętla for..do (82)
  • Pętla while..do (83)
  • Pętla repeat..until (85)
  • Procedura Continue (85)
  • Procedura Break (86)
• Zbiory (87)
  • Przypisywanie elementów zbioru (87)
  • Odczytywanie elementów ze zbioru (88)
  • Dodawanie i odejmowanie elementów zbioru (89)
• Wskaźniki (90)
  • Tworzenie wskaźnika (90)
  • Przydział danych do wskaźników (90)
  • Do czego to służy? (91)
  • Przydział i zwalnianie pamięci (93)
  • Wartość pusta (94)
• Pliki dołączane (94)
• Etykiety (95)
• Podsumowanie (95)

Rozdział 3. Programowanie obiektowe (97)

• VCL (97)
• Podstawowy kod modułu (98)
  • Plik DFM formularza (99)
• Umieszczanie komponentów na formularzu (100)
  • Umieszczanie komponentów (100)
  • Zmiana właściwości komponentu (100)
  • Zdarzenia komponentów (101)
• Kod generowany automatycznie (103)
• Klasy (104)
  • Czym właściwie są klasy? (105)
  • Tworzenie klas (105)
  • Definicja metod (105)
  • Tworzenie klasy (106)
  • Poziomy dostępu do klasy (107)
  • Dziedziczenie (108)
  • Typy metod (109)
  • Przedefiniowanie metod (109)
  • Konstruktory i destruktory (112)
• Przykład użycia klas (112)
  • Ogólne założenia (112)
  • Tworzenie modułu Engine (113)
  • Interfejs programu (117)
  • Kod źródłowy formularza głównego (118)
• Parametr Sender procedury zdarzeniowej (120)
  • Przechwytywanie informacji o naciśniętym klawiszu (120)
  • Obsługa parametru Sender (122)
• Operatory is i as (123)
• Parametr Self (123)
• Łańcuchy tekstowe (124)
  • ShortString (125)
  • AnsiString (125)
  • WideString (126)
  • Łańcuchy z zerowym ogranicznikiem (126)
• Operacje na łańcuchach (126)
  • Łączenie łańcuchów (126)
  • Wycinanie łańcucha (127)
  • Uzyskiwanie fragmentów łańcucha (127)
  • Wstawianie danych do łańcucha (128)
  • Wyszukiwanie danych w łańcuchu (129)
  • Pozostałe funkcje (129)
• Typ wariantowe (131)
• Właściwości (132)
• Zdarzenia (137)
• Wyjątki (141)
  • Słowa kluczowe try..except (141)
  • Słowa kluczowe try..finally (142)
  • Słowo kluczowe raise (143)
  • Klasa Exception (144)
  • Selektywna obsługa wyjątków (145)
  • Zdarzenie OnException (145)
• Klasa TApplication (148)
  • Właściwości klasy TApplication (148)
  • Metody klasy TApplication (149)
  • Zdarzenia klasy TApplication (151)
• Podsumowanie (152)

Rozdział 4. IDE Delphi (153)

• Paski narzędziowe (154)
  • Pasek Standard (154)
  • Pasek View (154)
  • Pasek Debug (155)
  • Pasek Desktop (156)
  • Pasek Custom (156)
  • Pasek Internet (156)
• Repozytorium (157)
  • Dodawanie projektu do Repozytorium (157)
  • Ustawienia Repozytorium (158)
• Praca z paletą komponentów (158)
  • Umieszczanie kilku obiektów naraz (159)
  • Menu palety komponentów (159)
• Projektant formularzy (161)
  • Menu projektanta formularzy (162)
• Drzewo obiektów (164)
• Inspektor obiektów (165)
  • Menu podręczne Inspektora obiektów (165)
  • Właściwości Inspektora obiektów (166)
• Eksplorator kodu (168)
• Przeglądarka projektu (169)
• Lista To-Do (169)
  • Znaczniki to-do w kodzie (170)
• Diagramy (171)
• Code Insight (172)
  • Code Completion (173)
  • Ustawienia Code Insight (174)
• Projekty (174)
  • Opcje projektu (175)
  • Pliki projektu (182)
• Menedżer projektu (183)
  • Pasek narzędziowy (183)
  • Praca z menedżerem projektu (184)
  • Menu podręczne menedżera projektów (184)
• Kilka wersji językowych projektu (188)
  • Tworzymy angielską wersję językową (188)
  • Tłumaczenie projektu (190)
  • Kompilacja projektu (191)
• Kilka formularzy w jednym projekcie (191)
  • Wyświetlenie drugiego formularza (192)
  • Dynamiczne tworzenie formularza (192)
• Aplikacje MDI (194)
  • Projektowanie interfejsu (194)
  • Kod źródłowy przykładowej aplikacji (197)
• Czy warto? (198)
• Delphi a C++Builder (198)
  • Rozmiar aplikacji wykonywalnej i czas kompilacji (199)
  • Pliki (199)
  • Składnia (199)
• Co nowego w Delphi 7? (201)
  • Zmiany w IDE (202)
  • Nowe komponenty (203)
  • Bazy danych (205)
  • .NET (205)
  • Modyfikacje kompilatora (206)
• Podsumowanie (206)

Podsumowanie części I (207)

Część II (209)

Rozdział 5. Obsługa komunikatów (211)

• Czym są komunikaty? (211)
• Rodzaje komunikatów (212)
  • Komunikaty okienkowe (212)
  • Komunikaty powiadamiające (213)
  • Komunikaty definiowane przez użytkownika (213)
• Jak działają komunikaty? (215)
• Obsługa komunikatów (215)
  • Przechwytywanie komunikatów (215)
  • Struktura TMsg (216)
  • Struktura TMessage (217)
• Specyficzne struktury typów (219)
• Zdarzenie OnMessage (220)
• Wysyłanie komunikatów (222)
  • Perform (222)
  • Funkcje SendMessage i PostMessage (224)
• Komunikaty rozgłaszające (226)
• Deklarowanie własnych komunikatów (226)
• Funkcje operujące na uchwytach (228)
• "Zahaczanie" okien (233)
  • Zakładanie globalnego hooka (234)
  • Funkcja obsługująca hooka (235)
• Podsumowanie (238)

Rozdział 6. Rejestry i pliki INI (239)

• Czym jest Rejestr Windows? (239)
  • Podstawowe klucze (240)
  • Podstawowe pojęcia (241)
• Pliki INI (241)
  • Budowa (241)
• Rejestr kontra plik INI (242)
• Klasa TRegistry (242)
  • Tworzenie nowych kluczy (242)
  • Otwieranie istniejących kluczy (243)
  • Usuwanie kluczy (244)
  • Dodawanie wartości (244)
  • Odczyt danych (247)
  • Inne funkcje operujące na Rejestrze (249)
• Praktyczny przykład (253)
• Klasa TINIFile (255)
  • Tworzenie nowego pliku INI (255)
  • Zapisywanie danych (256)
  • Odczyt danych (256)
  • Funkcje związane z operacjami na sekcjach (257)
  • Przykładowy program (258)
• Podsumowanie (260)

Rozdział 7. Obsługa plików (261)

• Pliki tekstowe (261)
  • Inicjalizacja (262)
  • Tworzenie nowego pliku (262)
  • Otwieranie istniejącego pliku (263)
  • Odczyt plików tekstowych (263)
  • Zapis nowych danych w pliku (265)
  • Zapis danych na końcu pliku (265)
• Pliki amorficzne (266)
  • Otwieranie i zamykanie plików (266)
  • Tryb otwarcia pliku (267)
  • Zapis i odczyt danych (268)
  • Przykład działania - kopiowanie plików (269)
• Inne funkcje operujące na plikach (271)
• Funkcje operujące na katalogach (273)
• Pliki typowane (274)
  • Deklaracja (275)
  • Tworzenie pliku i dodawanie danych (275)
  • Odczyt rekordu z pliku (276)
  • Przykład działania - książka adresowa (276)
• Kopiowanie i przenoszenie plików (283)
  • Kopiowanie (283)
  • Przenoszenie pliku (283)
  • Struktura TSHFileOpStruct (283)
• Strumienie (285)
  • Podział strumieni (286)
  • Prosty przykład na początek (286)
  • Konstruktor klasy TFileStream (288)
  • Pozostałe metody i właściwości klasy TStream (288)
  • Właściwości (289)
  • Metody (289)
  • Praktyczny przykład (290)
• Wyszukiwanie (297)
  • Rekord TSearchRec (297)
  • Jak zrealizować wyszukiwanie? (297)
  • Rekurencja (299)
  • Praktyczny przykład (299)
• Informacja o dyskach (303)
  • Pobieranie listy dysków (303)
  • Pobieranie rozmiaru dysku (304)
  • Pobieranie dodatkowych informacji (304)
• Podsumowanie (307)

Rozdział 8. Aplikacje wielowątkowe (309)

• Czym tak naprawdę są wątki? (309)
• Klasa TThread (310)
• Deklaracja klasy TThread (310)
• Tworzenie nowej klasy wątku (311)
• Kilka instancji wątku (313)
  • Tworzenie klasy (313)
  • Kod klasy (314)
• Wznawianie i wstrzymywanie wątków (316)
• Priorytet wątku (317)
• Synchronizacja (317)
  • Treść komentarza (318)
• Zdarzenia klasy TThread (320)
• Przykład: wyszukiwanie wielowątkowe (320)
  • Jak to działa? (320)
  • Wyszukiwanie (321)
  • Obliczanie czasu przeszukiwania (322)
  • Kod źródłowy modułu (322)
• Podsumowanie (325)

Rozdział 9. Multimedia (327)

• Z czego będziemy korzystać? (327)
  • OpenGL (328)
  • DirectX (330)
• Tworzenie bitmap (331)
  • Korzystanie z komponentu TImage (331)
  • Ładowanie obrazków w trakcie działania programu (332)
  • Klasa TBitmap (332)
  • Odczytywanie obrazka ze schowka (333)
• Pliki JPEG (337)
  • Klasa TJPEGImage (337)
  • Wyświetlanie obrazków w komponencie TImage (338)
  • Przykład działania - kompresja plików (338)
• Pliki GIF (339)
• Zasoby (339)
  • Tworzenie zasobów (339)
  • Wykorzystanie zasobów (341)
  • Ręczne tworzenie zasobów (344)
  • Doklejanie plików EXE (347)
• Klasa TCanvas (347)
• Pióra i pędzle (348)
  • Klasa TPen (348)
  • Klasa TBrush (350)
• Czcionki (351)
  • Właściwości klasy TFont (352)
• Metody klasy TCanvas (352)
  • Draw (353)
  • FillRect (353)
  • StretchDraw (354)
  • TextOut (354)
  • TextRect (355)
  • TextWidth, TextHeight (355)
  • TextExtent (356)
  • MoveTo (356)
  • LineTo (356)
  • Inne funkcje służące do rysowania kształtów (357)
• Proste animacje tekstowe (360)
  • Tekst trójwymiarowy (3D) (360)
  • Efekt maszyny do pisania (361)
  • Animacja na belce tytułowej (362)
  • Inne płynne animacje (365)
• Odtwarzanie dźwięków (366)
  • Funkcja PlaySound (366)
  • Użycie komponentu TMediaPlayer (367)
• Odtwarzanie filmów (368)
• Kontrolka Flash (375)
  • Instalacja kontrolki (375)
  • Wykorzystanie komponentu (377)
• Podsumowanie (377)

Rozdział 10. Biblioteki DLL (379)

• Czym jest biblioteka DLL? (379)
• Do czego mogą się przydać biblioteki DLL? (380)
  • Zalety (380)
  • Wady (380)
• Tworzenie bibliotek DLL (381)
  • Budowa biblioteki (382)
  • Rozmiar biblioteki (382)
• Eksportowanie procedur i funkcji (382)
  • Eksportowanie przez nazwę (382)
  • Eksport przez indeks (383)
• Ładowanie bibliotek DLL (383)
  • Ładowanie statyczne (384)
  • Ładowanie dynamiczne (384)
• Konwersje wywołania (386)
• Formularze w bibliotekach DLL (387)
  • Tworzenie formularza (387)
  • Eksportowanie formularza (387)
• Przekazywanie rekordów do bibliotek (389)
  • Budowa pliku mp3 (389)
  • Odczyt tagu z pliku mp3 (390)
  • Demo (392)
• Łańcuchy w bibliotekach DLL (394)
• Zasoby w bibliotece DLL (394)
  • Przygotowanie zasobów (394)
  • Ładowanie zasobów z biblioteki DLL (395)
• Procedura inicjująco-kończąca (396)
  • Blok begin biblioteki DLL (396)
  • DLLProc (396)
  • Kod biblioteki (397)
  • Program wykorzystujący bibliotekę (398)
• Podsumowanie (398)

Rozdział 11. Aplikacje sieciowe (399)

• Z czego będziemy korzystać? (399)
• Odrobinę teorii (400)
  • IP (400)
  • TCP (401)
  • Porty (402)
  • HTTP (402)
  • HTTPS (402)
  • FTP (403)
  • SMTP (403)
• Biblioteka WinInet.dll (403)
  • Ustanawianie połączenia (404)
  • Otwieranie konkretnego adresu URL (405)
  • Odczyt pliku (405)
  • Pobieranie rozmiaru pliku (406)
• Sprawdzanie połączenia (409)
• Sprawdzanie IP (410)
  • Zainicjowanie biblioteki (410)
  • Pobieranie adresu IP (411)
• Łączenie przy użyciu gniazd (412)
  • Czego użyć? (412)
  • Łączenie pomiędzy komputerami (412)
  • Wymiana danych (413)
  • Jak działają "konie trojańskie"? (416)
• Pingi (418)
  • Wysyłanie sygnału ping (418)
  • Odpowiedzi z serwera (418)
• Kontrolka TWebBrowser (420)
  • Ładowanie strony (422)
  • Odświeżanie (422)
  • Następna i poprzednia strona (423)
  • Pozostałe kody (423)
• Protokół SMTP (424)
  • Interfejs programu (424)
  • Działanie programu (424)
• Protokół HTTP (428)
  • Łączenie z serwerem (429)
  • Wymiana danych (429)
  • Pobieranie kodu strony WWW (430)
  • Wysyłanie danych przez skrypt PHP (431)
• Praktyczne przykłady wykorzystania HTTP (433)
  • Sprawdzenie nowej wersji programu (433)
  • Korzystanie z zewnętrznej wyszukiwarki (436)
• Protokół FTP (442)
• Podsumowanie (442)

Rozdział 12. WinAPI (443)

• Czym tak naprawdę jest WinAPI? (443)
  • Zasady tworzenia programów za pomocą WinAPI (444)
  • Brak zdarzeń (444)
  • Brak komponentów (444)
• Zalety wykorzystania WinAPI (444)
• Pierwszy program (445)
• Funkcja okienkowa (445)
• Rejestracja klasy (446)
• Tworzenie formularza (448)
• Komunikaty i uchwyty (450)
• Łańcuchy (451)
  • Konwersja łańcuchów (451)
  • Funkcje operujące na łańcuchach (452)
• Tworzenie kontrolek (454)
  • Umieszczanie kontrolek przy starcie programu (454)
  • Flagi kontrolek (457)
• Obsługa zdarzeń (459)
  • Uchwyty do kontrolek (460)
• Tworzenie bardziej zaawansowanych kontrolek (462)
  • Pozostałe kontrolki (464)
• Wyświetlanie grafiki (464)
  • Rysowanie w WinAPI (465)
  • Kontekst urządzenia graficznego (465)
  • Obsługa WM_PAINT (466)
  • Ładowanie i wyświetlanie bitmapy (467)
• Ładowanie zasobów (468)
  • Skompilowane zasoby (468)
  • Wykorzystanie zasobów (469)
• Podsumowanie (473)

Rozdział 13. COM i ActiveX (475)

• Czym jest COM? (475)
  • Kontrolka w rozumieniu COM (475)
  • Odrobinę historii (476)
• Tworzenie obiektów COM (476)
• Metody i właściwości (478)
  • Dodawanie metod (478)
  • Dodawanie właściwości (480)
• Kod źródłowy kontrolki (481)
• Przykład działania: kodowanie tekstu (484)
• Budowa i rejestracja kontrolki (486)
• Wykorzystanie obiektu COM (486)
• Interfejsy (488)
  • GUID (489)
• ActiveX (489)
• Import kontrolek ActiveX (489)
  • Wykorzystanie kontrolki TVText (491)
• Tworzenie kontrolek ActiveX (492)
• Przykład: wyświetlanie napisów do filmu (493)
  • Tworzenie interfejsu COM (493)
  • Tworzenie kontrolki ActiveX (494)
  • Budowa i rejestracja (506)
• ActiveX w Internecie (506)
  • Względy bezpieczeństwa (506)
  • Przykładowa kontrolka (506)
• Podsumowanie (509)

Podsumowanie części II (511)

Część III (513)

Rozdział 14. Komponenty VCL i CLX (515)

• Czym jest komponent? (515)
• VCL (516)
• CLX (516)
  • Tworzenie aplikacji opartych na CLX (516)
  • CLX a VCL (516)
• Architektura CLX (517)
• Windows a Linux (517)
  • Kompilacja warunkowa (518)
• Rodzaje komponentów (518)
  • Komponenty wizualne (518)
  • Komponenty niewizualne (518)
  • Komponenty graficzne (519)
• Hierarchia komponentów (519)
  • TObject (519)
  • TPersistent (521)
  • TComponent (522)
  • TControl (525)
  • TWinControl i TWidgetControl (526)
  • Klasy TCustom (527)
  • TGraphicControl (527)
• Budowa komponentu (527)
  • Właściwości (527)
  • Zdarzenia (529)
  • Metody (530)
• RTTI (530)
  • Właściwości obiektu (530)
  • Dokładniejsze informacje o obiekcie (532)
• Podsumowanie (535)

Rozdział 15. Tworzenie komponentów (537)

• Tworzenie nowego komponentu (537)
• Edycja kodu (538)
• Konstruktory i destruktory (539)
• Właściwości (540)
  • Klauzula default (540)
  • Klauzula stored (541)
  • Klauzula nodefault (541)
  • Właściwość wyliczeniowa (541)
  • Właściwość zbiorowa (542)
• Zdarzenia (543)
  • Definiowanie własnych zdarzeń (544)
• Ikona dla komponentów (544)
• Przykładowy komponent (545)
  • Ogólny zarys klasy (545)
  • Komunikaty (545)
  • Kod źródłowy komponentu (546)
• Instalacja komponentów (548)
• Demonstracja możliwości komponentu TURLabel (550)
• Zachowanie komponentu (551)
• Komponenty graficzne (551)
  • Ogólny zarys klasy komponentu (552)
  • Kod źródłowy komponentu (553)
• Pakiety komponentów (558)
• Podsumowanie (560)

Podsumowanie części III (561)

Część IV (563)

Rozdział 16. Bazy danych BDE (565)

• Czym jest baza danych? (565)
• Typy baz danych (566)
  • Lokalne bazy danych (566)
  • Bazy danych typu klient-serwer (566)
• Wielowarstwowość baz danych (566)
• Bazy danych w Delphi (567)
• Borland Database Engine (567)
  • Sterowniki baz danych (567)
• Przykładowa baza danych (567)
• Komponenty bazodanowe (569)
  • Komponent TTable (570)
  • TDataSource (571)
  • TDataSet (571)
  • Komponent TQuery (572)
• BDE Administrator (573)
  • Tworzenie nowej bazy danych (573)
• Tworzenie bazy w kodzie programu (574)
• Tworzenie tabel (575)
• Tworzenie rekordów (577)
• Odczytywanie wartości z tabeli (578)
• Przykładowy program korzystający z naszej bazy danych (578)
• Podsumowanie (580)

Rozdział 17. Bazy danych dbExpress (581)

• Aplikacje klient-serwer (581)
  • Narzędzia (582)
  • Komponenty (582)
• Łączenie z serwerem (582)
  • Kontrola procesu logowania (584)
  • Zdarzenia AfterConnect i AfterDisconnect (585)
• Jak działa MySQL? (585)
  • Tabele (585)
  • Zapytania (586)
• Tworzenie tabel (586)
• Dodawanie rekordów (587)
• Kasowanie rekordów (589)
  • Procedura kasująca (590)
• Odczytywanie rekordów (590)
  • Przykładowy program (591)
• Zmiana wartości rekordów (593)
• Przykładowy program: spis sprzedanych towarów (594)
• Inne komponenty dbExpress (597)
• Programy oparte o dbExpress (598)
• Podsumowanie (598)

Podsumowanie części IV (599)

Część V (601)

Rozdział 18. Delphi a Internet (603)

• Z czego będziemy korzystali? (603)
  • Serwer Personal Web Server (604)
• CGI, ISAPI, NSAPI (605)
• Tworzenie rozszerzeń serwera (606)
• Akcje serwera (607)
• Uruchamianie biblioteki (609)
• Kod źródłowy biblioteki ISAPI (609)
• TWebRequest i TWebResponse (610)
• Wykorzystanie szablonów (612)
  • Tworzenie nowego szablonu (613)
  • Szablony dynamiczne (613)
  • Przykładowy program (615)
  • Dodatkowe parametry (617)
• Wysyłanie i odbieranie cookies (618)
  • Ustawianie pliku cookies (618)
  • Odczyt cookies (619)
• Wysyłanie strumieni (620)
• Korzystanie z baz danych (621)
• WebSnap (623)
• Podsumowanie (623)

Rozdział 19. IntraWeb (625)

• Czym właściwie jest IntraWeb? (625)
• Tworzenie projektu IntraWeb (626)
  • Umieszczanie komponentów (627)
  • Podgląd wyglądu formularza (627)
• Uruchamianie projektu (628)
  • Obsługa aplikacji serwera (628)
• Generowanie zdarzeń (629)
  • Zdarzenia zastępcze (630)
• Kilka formularzy w jednym projekcie (630)
  • Funkcja ShowMessage w IntraWeb (633)
• Elementy HTML i JavaScript (633)
• Wysyłanie plików (634)
• IntraWeb jako DLL (635)
  • Konwertowanie aplikacji do ISAPI (636)
• IntraWeb kontra tradycyjne metody (636)
• Podsumowanie (637)

Podsumowanie części V (639)

Dodatki (641)

Dodatek A Zasady pisania kodu (643)

• Stosowanie wcięć (644)
• Instrukcje begin i end (644)
• "Styl wielbłądzi" w nazwach procedur (645)
• Stosuj wielkie litery (645)
• Parametry procedur (645)
• Instrukcja if (646)
• Instrukcja case (646)
• Obsługa wyjątków (647)
• Klasy (647)
• Komentarze (647)
• Pliki i nazwy formularzy (648)
• Notacja węgierska (648)
• Czy warto? (649)

Zakończenie (651)

Skorowidz (653)