okladka
Niniejsza książka prezentuje tajniki niczym nieskrępowanego tworzenia aplikacji 32-bitowych w Delphi 3. Szczególnie dokładnie omówione są te elementy Delphi, które w wersji 3 zostały zmodyfikowane lub w ogóle pojawiły się po raz pierwszy, jak na przykład rozproszone zbiory dancyh czy też model wielowarstwowej bazy danych. Czytając tę książkę znajdziesz mnóstwo szczegółowych informacji dotyczących kluczowych aspektów tworzenia aplikacji w Delphi 3, takich jak:
  • obsługa środowiska zintegrowanego,
  • programowanie w języku Object Pascal,
  • obsługa błędów i ochrona zasobów,
  • wykorzystanie i tworzenie komponentów i kontrolek,
  • zarządzanie bazami danych,
  • automatyzacja OLE,
  • kontrolki ActiveX i formularze aktywne,
  • grafika i drukowanie,
  • uruchamianie, testowanie i śledzenie wykonania programu,
  • tworzenie aplikacji wielowątkowych,
  • tworzenie bibliotek dynamicznych DLL,
  • wykorzystywanie protokołów NSAPI, ISAPI, CGI i WinCGI,
  • całościowe ujęcie tworzonej aplikacji w ramy projektu Delphi.
CD ROM dołączony do książki zawiera kod źródłowy przykładowych aplikacji prezentowanych w książce, a poza tym wersje demo pakietów HREF Tools, Inner Media, Blue Sky, Woll2Woll, Wise... i coś jeszcze.
TOM I
Wstęp (23)
  • Od tłumacza (23)
Część I. Podstawy
Rozdział 1. Co nowego w Delphi 3? (29)
  • Podstawowe elementy Delphi (30)
    • Konfigurowalne środowisko zintegrowane (IDE) (30)
    • Orientacja obiektowa (31)
    • Biblioteka komponentów (31)
    • Komponenty OCX i ActiveX (31)
    • Wzorce (32)
    • Rzeczywista kompilacja (32)
    • Wyjątki i odporność aplikacji na błędy (32)
    • Obsługa baz danych (33)
  • Nowości Delphi 3 (33)
    • Co nowego w środowisku zintegrowanym IDE? (33)
      • Możliwość śledzenia wykonania wewnątrz DLL (33)
      • Rozszerzenia w obrębie edytora (34)
      • Co nowego w zakresie bibliotek VCL i RTL? (35)
        • Nowe komponenty (35)
        • Zmiany w zakresie komponentów (36)
      • Zmiany w obrębie kompilatora (36)
        • Procedura Assert (36)
        • Obsługa pakietów (37)
        • Elementy zgodności z językiem Visual Basic (37)
        • Typ WideString (37)
      • Zmiany w zakresie OLE (37)
      • Rozszerzenia w zakresie obsługi baz danych (38)
        • Rozproszone zbiory danych (38)
        • Dodatkowe sterowniki rodzime (38)
        • Rozszerzenia Database Explorera (38)
    • Co zawiera niniejsza książka? (39)
      • Środowisko zintegrowane (IDE) (39)
      • Język Object Pascal (39)
      • Obsługa błędów i ochrona zasobów (39)
      • Komponenty i kontrolki (39)
      • Tworzenie aplikacji (40)
      • Programowanie bazodanowe (40)
      • Tworzenie i rozbudowa komponentów (41)
      • OLE i ActiveX (41)
      • Grafika i drukowanie (42)
      • Aplikacje wielowątkowe (43)
      • Tworzenie i wykorzystywanie DLL (43)
      • Testowanie i uruchamianie aplikacji (43)
      • Programowanie internetowe (44)
      • Rozszerzenia IDE (44)
      • Współdzielenie kodu przez Delphi i C++ (44)
      • Zaawansowane wykorzystanie funkcji API (44)
    • Przykłady (45)
    • Podsumowanie (45)
Rozdział 2. Środowisko zintegrowane (IDE) (47)
  • Okno główne IDE (48)
    • Pasek Menu (49)
      • Grupa File (49)
      • Grupa Edit (52)
      • Grupa Search (52)
      • Grupa View (54)
      • Grupa Project (56)
      • Grupa Run (57)
      • Grupa Component (57)
      • Grupa Database (58)
      • Grupa Tools (58)
    • Pasek Narzędziowy (59)
    • Paleta Komponentów (60)
      • Konfigurowanie Palety Komponentów (62)
      • Dodawanie nowego komponentu do Palety (63)
  • Inspektor Obiektów (63)
    • Modyfikacja właściwości (64)
    • Właściwość Name (66)
    • Właściwości zdarzeniowe (67)
      • Lokalizowanie procedur zdarzeniowych w kodzie programu (69)
  • Obsługa Projektanta Formularzy i Edytora Kodu (70)
    • Projektant Formularzy (70)
      • Dodawanie komponentów do formularza (70)
      • Manipulowanie grupami komponentów (72)
      • Menu kontekstowe Projektanta Formularzy (73)
    • Edytor Kodu (74)
      • Menu kontekstowe edytora kodu (75)
      • Code Insight (75)
    • Budowanie aplikacji w środowisku Delphi (78)
      • Opcje środowiska (78)
      • Stwórz swą pierwszą aplikację (80)
    • Wykorzystanie Menedżera Projektu (83)
      • Dodawanie i usuwanie plików (83)
      • Tworzenie i otwieranie formularzy i modułów (84)
      • Opcje projektu (84)
      • Uaktualnienie zawartości Menedżera Projektu (85)
    • Wykorzystanie Repozytorium (85)
      • Pobieranie obiektów z Repozytorium (86)
      • Wielokrotne wykorzystanie obiektu w ramach tego samego projektu (86)
      • Ponowne wykorzystanie projektu (86)
  • Podsumowanie (87)
    • Okno główne (87)
    • Projektowanie interfejsu aplikacji (87)
    • Budowanie aplikacji w ramach IDE (87)
    • Dwa użyteczne narzędzia (88)
Rozdział 3. Język Object Pascal - podstawy (89)
  • Wprowadzenie do Object Pascala (90)
  • Typy danych (93)
    • Typy proste (95)
      • Typy porządkowe (96)
    • Typy łańcuchowe (104)
    • Strukturalne typy danych (105)
      • Rekordy (106)
      • Tablice (107)
      • Zbiory (108)
      • Pliki (108)
    • Typy wskaźnikowe (109)
    • Typy proceduralne (110)
    • Typ Variant (111)
      • Typ Variant a automatyzacja OLE (114)
  • Operatory i wyrażenia (114)
  • Instrukcje (116)
    • Instrukcje proste (116)
      • Instrukcja przypisania (117)
      • Instrukcja wywołania procedury (118)
      • Instrukcja skoku (118)
    • Instrukcje strukturalne (118)
      • Instrukcja złożona (119)
      • Instrukcje warunkowe (119)
      • Instrukcja wyboru (120)
      • Instrukcje pętli (121)
      • Instrukcja wiążąca With (123)
  • Procedury i funkcje (125)
    • Zasięg deklaracji (127)
    • Przekazywanie parametrów (127)
      • Kojarzenie przez wartość (128)
      • Kojarzenie przez odwołanie (128)
      • Kojarzenie przez stałą (129)
      • Parametry amorficzne (129)
      • Tablice otwarte (130)
  • Moduły Delphi (132)
    • Część publiczna - interface (133)
    • Część prywatna - implementation (134)
    • Część inicjacyjna - initialization (134)
    • Część kończąca - finalization (134)
  • Podsumowanie (135)
Rozdział 4. Object Pascal - koncepcje zaawansowane (137)
  • Klasy (139)
    • Składnia (139)
    • Zakres widoczności elementów klasy (140)
    • Metody (142)
      • Metoda statyczna (143)
      • Virtual (143)
      • Dynamic (144)
      • Message (145)
      • Abstract (146)
      • Override (147)
      • Metody typu Class (148)
  • Rzutowanie typów (148)
    • Operatory Is i As (148)
    • Jawne rzutowanie typów (149)
  • Typ referencyjny klas (150)
  • Biblioteka uruchomieniowa (Runtime Library) (153)
    • Moduł System (154)
      • Wybrane typy (154)
      • Wybrane zmienne (154)
      • Wybrane podprogramy (155)
    • Moduł SysUtils (156)
      • Wybrane stałe (156)
      • Wybrane typy (157)
      • Wybrane obiekty (157)
      • Wybrane zmienne (158)
      • Wybrane podprogramy (159)
    • Moduł Math (166)
      • Funkcje elementarne (166)
      • Funkcje trygonometryczne (166)
      • Podprogramy finansowe (167)
      • Podprogramy statystyczne (167)
      • Pozostałe podprogramy (168)
  • Podsumowanie (168)
Rozdział 5. Obsługa wyjątków (173)
  • Błędy wykonania (173)
  • Natura wyjątków (175)
  • Definiowanie domyślnej procedury obsługi wyjątków (176)
    • Zdarzenie OnException (176)
    • Tworzenie własnej procedury obsługi zdarzenia OnException (177)
  • Programowanie z użyciem wyjątków (178)
    • Blok try .. finally - szczegóły (179)
    • Blok try .. except - szczegóły (180)
      • Konstrukcja On .. do (180)
    • Zagnieżdżone bloki try... (182)
    • Wywoływanie wyjątków (185)
    • "Ciche" wyjątki (186)
  • Klasa bazowa wyjątków (186)
    • Konstruktory klasy Exception (187)
    • Tworzenie nowych klas wyjątków (188)
  • Wyjątki a wbudowany debugger (190)
  • Podsumowanie (190)
Część II. Tworzenie aplikacji
Rozdział 6. Komponenty Delphi (193)
  • Komponenty wizualne (194)
    • Właściwości i zdarzenia wspólne dla komponentów wizualnych (195)
      • Właściwości klasy TControl (195)
      • Zdarzenia klasy TControl (197)
    • Klasy TWinControl i TGraphicControl (201)
      • Klasa TWinControl (201)
      • Klasa TGraphicControl (203)
    • Kontrolki standardowe (204)
      • Kontrolki wyświetlające tekst (204)
      • Kontrolki umożliwiające wprowadzanie i edycję tekstu (205)
      • Przyciski poleceń (207)
      • Grupy selekcyjne (207)
      • Listy wyboru (209)
      • Pojemniki (212)
      • Kontrolki pozycyjne (212)
    • Kontrolki uzupełniające (213)
      • Mutacje przycisków (213)
      • Rozszerzone komponenty edycyjne (214)
      • Kontrolki służące do wyświetlania grafiki (216)
      • Kontrolki "manipulacyjne" (217)
    • Kontrolki systemowe (218)
      • TOleContainer (218)
      • TPaintBox (218)
      • TMediaPlayer (219)
    • Kontrolki przykładowe (220)
  • Komponenty niewidoczne (220)
    • Komponenty dialogowe (221)
      • TOpenDialog (221)
      • TSaveDialog (221)
      • TFontDialog (222)
      • TColorDialog (222)
      • TPrintDialog (223)
      • TPrinterSetupDialog (224)
      • TFindDialog (224)
      • TReplaceDialog (224)
    • Komponenty systemowe (225)
      • TMainMenu i TPopupMenu (225)
      • TTimer (226)
  • Podsumowanie (227)
    • Komponenty wizualne (227)
    • Komponenty niewidoczne (227)
Rozdział 7. Standardowe kontrolki Win32 (229)
  • Podstawowe kontrolki Win32 (230)
    • TTrackBar (230)
    • TUpDown (233)
    • THotKey (235)
    • TProgressBar (238)
  • Nowości Delphi 3 (241)
    • TToolBar (241)
      • Elementy paska narzędziowego dostępne na etacie projektowania (241)
      • Operowanie paskiem narzędziowym w trakcie wykonania programu (242)
    • TCoolBar (244)
      • Operowanie kontrolką TCoolBar na etapie projektowania (245)
      • Utworzenie wstęg w trakcie wykonania programu (245)
    • TDateTimePicker (245)
    • TAnimate (246)
  • Kontrolki bardziej złożone (246)
    • TStatusBar (247)
      • Właściwości SimplePanel i SimpleText (247)
      • Złożony pasek statusu (248)
    • THeaderControl (254)
    • TImageList (256)
      • TImageList na etapie projektowania (256)
      • TImageList w charakterze "łapacza" ekranów (257)
    • TTabControl (263)
      • Zarządzanie zakładkami (263)
      • Wymiary i rozmieszczenie zakładek (265)
      • Zdarzenia związane z kontrolkami (265)
      • Operacje graficzne komponentu TTabControl (266)
    • TPageControl (268)
      • Tworzenie stron w czasie projektowania (268)
      • Tworzenie stron w czasie wykonania programu (269)
      • Nawigowanie wśród stron kontrolki (271)
      • Przeciąganie stron między kontrolkami (273)
    • TRichEdit (277)
      • Atrybuty tekstu (277)
      • Formatowanie akapitów (279)
      • Wyświetlanie numerów linii i kolumn (283)
      • Wyszukiwanie tekstu (283)
    • TListView (285)
      • Możliwości TListView dostępne w czasie projektowania (285)
      • Możliwości TListView dostępne w czasie wykonania programu (285)
    • TTreeView (288)
      • Możliwości TTreeView dostępne w czasie projektowania (289)
      • Tworzenie pozycji TTreeView w czasie wykonania programu (290)
      • Eksploracja TTreeView (296)
  • Podsumowanie (300)
    • Nowe możliwości TTabControl (302)
    • Nowe możliwości TPageControl (305)
Rozdział 8. Tworzenie aplikacji (309)
  • Formularze (310)
    • Właściwości klasy TForm (310)
      • Active (310)
      • ActiveControl (310)
      • AutoScroll, HorzScrollBar i VertScrollBar (311)
      • BorderIcons (312)
      • BorderStyle (313)
      • Height i Width (315)
      • ClientHeight i ClientWidth (315)
      • FormStyle (316)
      • KeyPreview (317)
      • Menu (318)
      • Position (318)
      • WindowState (320)
    • Zdarzenia klasy TForm (321)
    • Wielokrotne wykorzystanie formularzy (323)
      • Wzorce formularzy (323)
      • Dziedziczenie formularzy (326)
  • Tworzenie aplikacji typu SDI (328)
    • Przykład aplikacji SDI (330)
      • Elementy interfejsu (330)
      • Oprogramowanie zdarzeń (332)
  • Tworzenie aplikacji typu MDI (333)
    • Tworzenie formularzy (334)
      • Tworzenie automatyczne (334)
      • Tworzenie dynamiczne (335)
    • Właściwości formularzy charakterystyczne dla aplikacji MDI (336)
      • ActiveMDIChild (336)
      • MDIChildren i MDIChildCount (336)
      • TileMode (337)
      • WindowMenu (337)
    • Zdarzenia klasy TForm charakterystyczne dla aplikacji MDI (337)
    • Metody klasy TForm charakterystyczne dla aplikacji MDI (338)
    • Przykład aplikacji MDI (339)
      • Konstrukcja interfejsu (339)
      • Oprogramowanie zdarzeń (341)
  • Aplikacje konsolowe (342)
    • Funkcje API odnoszące się do aplikacji konsolowych (344)
  • Projekty wzorcowe - wielokrotne wykorzystanie aplikacji (345)
    • Dodawanie własnych projektów wzorcowych do Repozytorium (347)
  • Opcje projektu (348)
    • Karta Forms (348)
    • Karta Application (348)
    • Karta Compiler (349)
      • Optimization (349)
      • Aligned record fields (349)
      • Stack frames (349)
      • Pentium-Safe FDIV (349)
      • Range Checking (349)
      • I/O Checking (349)
      • Overflow Checking (349)
      • Strict Var-Strings (350)
      • Complete Boolean Eval (350)
      • Extended Syntax (350)
      • Typed @ operator (350)
      • Open Parameters (350)
      • Huge Strings (350)
      • Assignable Typed Constants (350)
      • Debug Information (350)
      • Local Symbols (350)
      • Symbol Information (351)
      • Assertions (351)
      • Show Hints (351)
      • Show Warnings (351)
    • Karta Linker (351)
    • Karta Directories/Conditionals (352)
    • Karta VersionInfo (352)
    • Karta Packages (354)
  • Zaawansowane techniki programistyczne (355)
    • Komponent Application (355)
      • Właściwości klasy TApplication (355)
      • Metody klasy TApplication (357)
      • Zdarzenia klasy TApplication (358)
    • Komponent Screen (360)
      • Właściwości klasy TScreen (360)
      • Zdarzenia klasy TScreen (362)
    • Obsługa zdarzeń dzielonych (363)
    • Aplikacje jednoinstancyjne (363)
  • Podsumowanie (365)
Część III. Tworzenie baz danych
Rozdział 9. Zarządzanie lokalnymi bazami danych (369)
  • Czym są lokalne bazy danych? (370)
    • Typy lokalnych baz danych (371)
      • Zalety baz systemu Paradox (371)
      • Niedogodności związane z bazami systemu Paradox (372)
      • Specyfika baz typu Paradox (373)
      • Zalety baz typu dBase (374)
      • Niedogodności związane z bazami typu dBase (376)
      • Co więc wybrać - Paradox czy dBase? (376)
  • Komponenty Delphi realizujące dostęp do danych (376)
    • TTable i TQuery (376)
      • Właściwość Active (377)
      • Właściwości BOF i EOF (377)
      • Właściwość DatabaseName (378)
      • Właściwości DbHandle i Handle (378)
      • Właściwości Fields i FieldCount (378)
      • Właściwość Modified (378)
      • Właściwość RecordCount (379)
      • Metoda FieldByName (379)
      • Metody Edit, Insert, Post i Cancel (379)
      • Metody First, Last, Prior, Next i MoveBy (380)
      • Metoda Locate (380)
      • Zdarzenia typu BeforeXXX (381)
      • Zdarzenia typu AfterXXX (381)
      • Zdarzenie OnCalcFields (382)
    • Właściwości i metody charakterystyczne dla TTable (383)
      • Właściwość TableName (383)
      • Właściwość Exclusive (383)
      • Właściwosć IndexName (384)
      • Metoda Locktable (384)
      • Metoda UnlockTable (385)
      • Metoda SetRange (385)
    • Właściwości i metody charakterystyczne dla TQuery (385)
      • Właściwości Params i ParamCount (385)
      • Właściwości RequestLive i CanModify (385)
      • Właściwosć UniDirectional (386)
      • Metody (386)
  • Moduły danych (386)
    • Tworzenie modułu danych (386)
    • Wykorzystanie modułu danych (387)
    • Zdarzenia związane z modułem danych (387)
  • Kontrolki bazodanowe (388)
    • Komponent TDataSource (388)
      • Właściwość AutoEdit (388)
      • Właściwość DataSet (388)
      • Właściwosć State (388)
      • Zdarzenie OnDataChange (389)
      • Zdarzenie OnStateChange (389)
      • Zdarzenie OnUpdateData (389)
    • Przegląd kontrolek bazodanowych (390)
  • Zaawansowane techniki programowania bazodanowego (391)
    • Buforowana edycja (391)
    • Wyjątki związane z bazami danych (391)
    • Transakcje (392)
    • Komponent TSession i obsługa baz danych w warunkach wielowątkowości (393)
      • Sesje oraz komponenty TSession i TSessionList (394)
      • Tworzenie nowej sesji (394)
      • Związanie komponentów bazodanowych z odpowiednią sesją (394)
  • Podsumowanie (396)
Rozdział 10. Zarządzanie bazami danych SQL (397)
  • Czym charakteryzują się bazy SQL? (398)
    • SQL - pierwsze spotkanie (399)
      • Otwarcie tabeli SQL (399)
      • Zapytanie SQL w postaci QBE (400)
      • Instrukcje SQL generowane przez zapytanie QBE (401)
  • Bazy SQL a komponenty TTable i TQuery (402)
    • TTable czy TQuery? (402)
    • Dodatkowe elementy związane z SQL (402)
    • Zwiększenie efektywności (403)
      • Ograniczenie liczby pól (403)
      • Redukcja liczby rekordów (403)
  • Komponenty realizujące dostęp do baz SQL (403)
    • TDatabase (403)
      • Właściwości AliasName i DatabaseName (404)
      • Właściwość KeepConnection (404)
      • Właściwości LoginPrompt i Params (404)
      • Właściwość TransIsolation (405)
      • Metody Open i Close oraz właściwość Connected (405)
      • Metoda CloseDataSets (405)
      • Metody StartTransaction, Commit i RollBack (406)
      • Edytor komponentu TDatabase (406)
    • TStoredProc (406)
      • Właściwości DatabaseName i StoredProcName (407)
      • Właściwości Params, ParamCount, ParamByName i ParamBinMode (407)
      • Metody Prepare, ExecProc, Open i Close (407)
      • Zdarzenia klasy TStoredProc (408)
    • TUpdateSQL (408)
      • Właściwości i metody klasy TUpdateSQL (408)
  • Inne zagadnienia związane z wykorzystaniem baz SQL (409)
    • Transakcje w odniesieniu do baz SQL (409)
    • Parametryzacja zapytań SQL (409)
    • Wskazówki dotyczące efektywności (411)
  • Podsumowanie (411)
Rozdział 11. Bazodanowe narzędzia Delphi 3 (413)
  • Database Explorer (413)
    • Panel nawigacyjny (414)
      • Tworzenie nowego aliasu (415)
      • Logowanie do bazy (415)
      • Oglądanie bazy danych (415)
    • Panel informacyjny (417)
      • Karta Definition (417)
      • Karta Text (418)
      • Karta Data (418)
      • Karta Enter SQL (418)
  • Data Dictionary (419)
    • Databases (419)
    • Attribute Sets (420)
      • Definiowanie nowych atrybutów z poziomu Eksploratora (421)
      • Definiowanie nowych atrybutów z poziomu Delphi (421)
  • SQL Monitor (422)
    • Opcje śledzenia (422)
      • Parametryzowane zapytania SQL (423)
    • Pozostałe aspekty śledzenia aplikacji (423)
  • Podsumowanie (424)
Rozdział 12. Generator Quick Report (425)
  • Komponenty generatora Quick Report (426)
      • Właściwość Bands (426)
      • Właściwość DataSet (427)
      • Właściwość Options (427)
      • Właściwość Page (427)
      • Właściwość PrinterSettings (427)
      • Właściwość ReportTitle (428)
      • Właściwość ShowProgress (428)
      • Zdarzenie OnNeedData (428)
    • TQRSubDetail (428)
    • TQRBand (428)
      • Właściwość BandType (428)
      • Właściwość ForceNewColumn (429)
      • Właściwość ForceNewPage (429)
      • Zdarzenie BeforePrint (429)
    • TQRChildBand (429)
    • TQRGroup (430)
    • TQRLabel (430)
    • TQRDBText (430)
    • TQRExpr (430)
    • TQRSysData (431)
    • TQRMemo (432)
    • TQRRichText (432)
    • TQRDBRichText (432)
    • TQRShape (432)
    • TQRImage (433)
    • TQRDBImage (433)
    • TQRCompositeReport (433)
    • TQRPreview (433)
    • TQRChart (433)
  • Tworzenie raportów (433)
    • QuickReport Wizard (434)
    • Wzorce raportów (435)
      • Quick Report List (436)
      • Quick Report Labels (436)
      • Quick Report Master/Detail (439)
  • Tworzenie własnych podglądów (442)
  • Podsumowanie (443)
Rozdział 13. Zbiory danych definiowane przez użytkownika (445)
    • TDataSet - komponent bazowy dla wszystkich zbiorów danych (446)
  • Tworzenie zbioru danych na bazie TDataSet - komponent TFixedASCIIDataSet. (447)
    • Otwieranie, inicjalizacja i zamykanie zbioru danych (451)
    • Zarządzanie zakładkami (457)
    • Zarządzanie rekordami (460)
    • Podprogramy nawigacyjne (466)
    • Obsługa wyjątków (468)
  • Podsumowanie (468)
Rozdział 14. Aplikacje wielowarstwowe (473)
  • Połączenie aplikacji-klienta z serwerem aplikacji (475)
  • Ładowanie danych do komponentu TClientDataSet (476)
    • Łączenie z serwerem aplikacji (476)
    • Jawne odwołania do obiektu dostawcy TProvider (477)
    • Wykorzystanie właściwości Data i metody Get_Data (479)
    • Pobieranie grupy rekordów ze zbioru TDBDataSet (480)
    • Implementacja niestandardowego sposobu pobierania rekordów z wykorzystaniem metody DataRequest (481)
    • Wykorzystanie plików i strumieni (482)
    • Wykorzystanie metody CreateDataSet (484)
  • Operowanie danymi na poziomie komponentu TClientDataSet (485)
    • Śledzenie zmian (485)
    • Przywracanie danym poprzedniej postaci (487)
  • Fizyczna aktualizacja danych (488)
    • Metoda ApplyUpdates (489)
    • Obsługa błędów w ramach zdarzenia OnUpdateError (489)
    • Obsługa błędów w ramach zdarzenia OnReconcileError (491)
  • Podsumowanie (492)
Część IV. Tworzenie i rozbudowa komponentów
Rozdział 15. Wykorzystanie pakietów (495)
  • Celowość wykorzystywania pakietów (496)
    • Eliminacja zbędnego kodowania (496)
    • Komponenty biblioteki VCL (497)
    • Kiedy nie stosować pakietów (497)
  • Instalowanie i wykorzystywanie pakietów (497)
    • Instalacja pakietów wykonywalnych (498)
    • Instalacja komponentów i innych pakietów środowiskowych (499)
    • Wykorzystywanie pakietów w aplikacjach i bibliotekach DLL (501)
  • Tworzenie własnych pakietów (501)
    • Dyrektywy kompilacji związane z pakietami (506)
    • Dla dociekliwych - mechanizm słabego wiązania modułu w pakiecie (506)
    • Zarządzanie wersjami pakietów (508)
    • Wykorzystanie wykonanych pakietów (508)
  • Podsumowanie (510)
Rozdział 16. Tworzenie komponentów (511)
  • Wybór klasy bazowej (512)
    • Podstawowe klasy bazowe komponentów Delphi (512)
    • Modyfikowanie komponentów istniejących (514)
    • Wykorzystanie wzorców komponentów (514)
  • Tworzenie modułu źródłowego komponentu (515)
    • Definiowanie właściwości (516)
      • Typy właściwości (516)
      • Dyrektywy związane z właściwościami (525)
      • Odczytywanie i nadawanie wartości właściwościom obiektu (527)
      • Inicjowanie pól obiektu (531)
    • Definiowanie metod komponentu (533)
      • Typy metod komponentu (533)
      • Stopień widoczności metody (534)
    • Definiowanie zdarzeń (535)
      • Struktura zdarzenia (535)
      • Przedefiniowywanie zdarzeń standardowych (537)
      • Definiowanie nowych zdarzeń (538)
  • Testowanie komponentu (539)
  • Przyporządkowanie ikony komponentowi (542)
  • Rejestrowanie komponentu (542)
  • Podsumowanie (543)
Rozdział 17. Zaawansowane techniki tworzenia komponentów (547)
  • Ważniejsze właściwości komponentów (547)
    • Reprezentowanie stanu komponentu (548)
    • Reprezentowanie stanu kontrolki (549)
    • Modyfikowanie stylu kontrolki (549)
  • Ważniejsze metody komponentów (551)
    • Metoda Loaded (551)
    • Metoda Notification (551)
    • Metoda FreeNotification (552)
    • Metoda DestroyWnd (553)
    • Metoda GetChildren (554)
  • Odpowiadanie na komunikaty (555)
    • Obsługa komunikatów standardowych (555)
    • Obsługa komunikatów użytkownika (557)
  • Łączniki bazodanowe (558)
    • Podstawowe właściwości i metody komponentu TDataLink (559)
      • Metoda UpdateRecord (559)
      • Właściwość Active (559)
      • Właściwość ActiveRecord (559)
      • Właściwości BufferCount i RecordCount (560)
      • Właściwości DataSet i DataSource (560)
      • Właściwość DataSourceFixed (561)
      • Właściwość Editing (561)
      • Właściwość ReadOnly (561)
    • Podstawowe właściwości, metody i zdarzenia komponentu TDataLink (561)
      • Metoda Edit (561)
      • Metoda Modified (561)
      • Metoda Reset (561)
      • Właściwość CanModify (562)
      • Właściwość Control (562)
      • Właściwość Field (562)
      • Właściwość FieldName (562)
      • Zdarzenie OnActiveChange (562)
      • Zdarzenie OnDataChange (563)
      • Zdarzenie OnEditingChange (563)
      • Zdarzenie OnUpdateData (563)
    • Tworzenie przykładowego komponentu-łącznika (563)
  • Konstruowanie edytorów właściwości (566)
    • Wybór klasy bazowej edytora (566)
    • Redefinicja kluczowych metod edytora (567)
      • Metoda Activate (568)
      • Metoda AllEqual (568)
      • Metoda Edit (569)
      • Metoda GetAttributes (569)
      • Metoda GetEditLimit (570)
      • Metoda GetName (571)
      • Metoda GetProperties (571)
      • Metoda GetValue (572)
      • Metoda GetValues (573)
      • Metoda Initialize (574)
      • Metoda SetValue (574)
    • Pozostałe właściwości i metody edytorów właściwości (575)
      • Właściwość Designer (575)
      • Właściwość PrivateDirectory (575)
      • Właściwość PropCount (575)
      • Właściwość Value (575)
      • Metoda GetComponent (575)
      • Metoda GetPropType (575)
      • Metoda Modified (576)
      • Metody GetxxxxValue i SetxxxxValue (576)
    • Rejestracja edytora właściwości (576)
  • Konstruowanie edytorów komponentów (577)
    • Klasa TComponentEditor (578)
      • Konstruktor Create (578)
      • Metoda Edit (578)
      • Metoda GetVerbCount (578)
      • Metoda GetVerb (579)
      • Metoda ExecuteVerb (579)
      • Metoda Copy (579)
    • Klasa TDefaultEditor (579)
      • Metoda Edit (579)
      • Metoda EditProperty (580)
    • Rejestracja edytora komponentu (580)
    • Przykładowy edytor komponentu (580)
  • Podsumowanie (582)
TOM II
Część V. Technologie OLE
Rozdział 18. OLE, serwery dokumentów i kontrolki ActiveX (631)
  • OLE - pojęcia podstawowe (632)
  • Łączenie a osadzanie obiektów (633)
  • Wykorzystanie komponentu TOLEContainer (635)
    • Elementy definicji klasy TOLEContainer (636)
    • Osadzanie nowo tworzonych i istniejących obiektów (639)
      • Dla dociekliwych: w jaki sposób wyszukać w Rejestrze obiekty OLE? (644)
    • Tworzenie połączeń do obiektów (645)
    • Aktywacja "w miejscu" i minimalizacja do ikony (646)
    • Łączenie menu (649)
    • Współpraca obiektu OLE ze Schowkiem (650)
    • Standardowe dialogi realizowane przez TOLEContainer (652)
    • TOLEContainer a operacje wejścia/wyjścia (654)
    • Strumieniowanie obiektów OLE (654)
    • Skalowanie zawartości pojemnika OLE (655)
    • Rozkazy realizowane przez pojemnik OLE (657)
    • Dostęp do serwera automatyzacji za pośrednictwem właściwości OleObject (659)
      • Parametry pozycyjne a parametry kluczowe (660)
    • Przykładowe programy (662)
  • Wykorzystanie kontrolek ActiveX (664)
    • Instalacja kontrolek ActiveX w Palecie Komponentów (664)
    • Moduł-otoczka kontrolki ActiveX (669)
    • Przykład zastosowania kontrolki ActiveX w aplikacji (675)
      • Opcjonalne parametry w wywołaniach metod kontrolek ActiveX (676)
    • Wykorzystanie właściwości OLEObject kontrolki ActiveX (677)
    • Dystrybucja aplikacji wykorzystującej kontrolki ActiveX (677)
  • Podsumowanie (678)
Rozdział 19. Obiekt COM i interfejsy (679)
  • Podstawy mechanizmu COM (680)
    • COM jako technologia klient/serwer (680)
    • Identyfikacja obiektów COM i interfejsów (681)
    • Dostęp do poszczególnych interfejsów obiektu COM (682)
    • COM jako standard binarny (682)
    • Rola licznika odwołań (683)
    • Bazowy interfejs IUnknown (684)
  • Przykładowy serwer COM - konstrukcja od podstaw (685)
    • Konstrukcja obiektu COM (685)
    • Rejestracja obiektu COM (691)
    • Komunikacja serwera z systemem Windows (691)
    • Interfejs IClassFactory - producent obiektu COM (694)
    • Tworzenie testowej aplikacji-klienta interfejsu IMalloc (697)
  • Rozszerzenia Delphi 3 związane z interfejsami COM (699)
  • Przykład zastosowania - rozszerzenia menu kontekstowego (705)
  • Podsumowanie (713)
Rozdział 20. Automatyzacja OLE (715)
  • Serwery automatyzacji OLE (716)
  • Obiekty automatyzacji OLE i biblioteki informacji o typie (716)
    • Dostęp do obiektu automatyzacji (717)
    • Wykorzystywanie właściwości obiektu automatyzacji (718)
    • Wywoływanie metod obiektu automatyzacji (720)
      • Parametry pozycyjne (720)
      • Parametry kluczowe (721)
      • Kombinowane parametry wywołania (722)
    • Przykład obiektu automatyzacji OLE - Word Basic (722)
  • Automatyzacja OLE a typ wariantowy (724)
    • "Puste" wartości reprezentowane przez typ OLEVariant (726)
    • Zmienne wariantowe zawierające łańcuchy (727)
    • Zmienne wariantowe wskazujące na interfejsy (727)
    • Dodatkowe znaczniki związane ze zmiennymi wariantowymi (727)
    • Programy wspomagające obsługę zmiennych wariantowych (728)
  • Konstrukcja serwerów automatyzacji OLE (732)
    • Tworzenie serwera zewnętrznego (733)
    • Tworzenie serwera wewnątrzprocesowego (743)
    • Zdalne serwery OLE (745)
  • Podsumowanie (745)
Rozdział 21. Tworzenie kontrolek ActiveX (747)
  • Podstawowe obiekty w technologii DAX (748)
    • Obiekty COM technologii DAX (748)
    • Arkusze właściwości DAX (749)
    • Obiekty-producenci DAX (749)
  • Biblioteki informacji o typie (750)
    • Edytor biblioteki typu (750)
    • Informacja o bibliotece (751)
    • Dane wyliczeniowe (752)
    • Interfejsy definiowane w bibliotece typu (754)
    • Klasy składowe definiowane w bibliotece typu (757)
  • Kontrolki ActiveX (758)
  • Przykład -- tworzenie kontrolki PieX (759)
    • Wykorzystanie kreatora kontrolek ActiveX (760)
    • Zawartość biblioteki PieXControlLib (761)
    • Edycja metod i właściwości (761)
    • Tworzenie arkuszy właściwości (769)
    • Rejestrowanie i instalacja kontrolek ActiveX (771)
  • Tworzenie formularzy aktywnych (772)
  • Internetowe zastosowania kontrolek ActiveX i formularzy aktywnych (773)
  • Podsumowanie (774)
Część VI. Zaawansowane zadania
Rozdział 22. Grafika w Delphi 3 (779)
  • Wykorzystanie obiektów TCanvas, TPen i TBrush (780)
    • Właściwość Handle (780)
    • Pióro - właściwość Pen (782)
      • Tworzenie kopii pióra (787)
      • Dodatkowe efekty związane z piórami (787)
    • Pędzel - właściwość Brush (791)
    • Czcionka - właściwość Font (796)
  • Komponent TImage (808)
    • Klasa TPicture (809)
    • Klasa TBitmap i zasoby Windows (810)
      • Niezależność bitmapy od urządzenia i bezpośredni dostęp do pikseli (812)
  • Regiony (812)
  • Metapliki (813)
  • Układ współrzędnych (814)
  • Wielowątkowy dostęp do płótna (816)
  • Podsumowanie (817)
Rozdział 23. Drukowanie w Delphi 3 (819)
  • Jak działają sterowniki drukarek (820)
  • Podstawowe problemy, które możesz napotkać przy drukowaniu (821)
    • Problemy z kolorami (822)
  • Czcionki (824)
  • Kontekst urządzenia drukującego (826)
  • Inne problemy... (827)
    • Złożone wielokąty (827)
    • Skomplikowane regiony (827)
    • Sterowniki 16- i 32-bitowe (827)
    • I ta niepewność... (827)
    • Procedury przerywające (828)
  • Klasa TPrinter i obiekt Printer (828)
    • Procedury Writeln() i Write() (829)
  • Zmiana drukarki i ustawień wydrukowych (831)
  • Funkcje GetDeviceCaps() i DeviceCapabilities() (840)
  • Sekwencje unikowe (844)
  • Drukowanie formularza (846)
  • Omijając TPrinter... (851)
  • Inne zagadnienia związane z wydrukami (852)
  • Podsumowanie (853)
Rozdział 24. Aplikacje wielowątkowe (855)
  • Nieco terminologii... (856)
  • Elementy pracy wielowątkowej (857)
    • Rozpoczynanie i kończenie wątku (859)
    • Priorytety wątków (862)
    • Bezpieczeństwo (865)
    • Sekcje krytyczne (866)
  • Mechanizmy synchronizacyjne wątków (871)
    • Problem zastoju (873)
    • Zdarzenia Win32 (874)
    • Mutex (881)
    • Semafory (882)
  • Dane lokalne wątku: TLS i ThreadVar (884)
  • Klasa TThread (891)
    • Pewien interesujący błąd... (898)
  • Inne zagadnienia (900)
  • Podsumowanie (901)
Rozdział 25. Biblioteki DLL - pojęcia podstawowe (903)
  • Rola bibliotek DLL w Win32 (904)
  • Biblioteki DLL a przenoszenie aplikacji z Win16 do Win32 (905)
    • Biblioteki DLL w Win16 (905)
    • Biblioteki DLL w Win32 (906)
    • Komunikacja międzyprocesowa w Win32 (906)
  • Tworzenie bibliotek DLL przy użyciu Delphi 3 (907)
  • Procedura inicjująco-kończąca biblioteki - DLLMain (909)
  • Konwencje wywoływania procedur i funkcji (912)
  • Eksportowanie procedur/funkcji DLL (914)
  • Ładowanie i rozładowywanie biblioteki DLL (915)
    • Uchwyt modułu i funkcja FreeLibrary (917)
  • Importowanie funkcji/procedur z biblioteki DLL (918)
    • Ładowanie automatyczne (919)
    • Ładowanie jawne (922)
  • Podsumowanie (926)
Rozdział 26. Zawansowane wykorzystanie bibliotek DLL (927)
  • Wykorzystanie klas i obiektów definiowanych w bibliotekach DLL (928)
  • Formularze definiowane w bibliotekach DLL (932)
  • Klasy i obiekty w DLL - raz jeszcze... (938)
  • Mechanizm plików odwzorowanych i współdzielenie danych przez aplikacje (948)
  • Format Portable Executable (PE) (956)
    • Nagłówki modułu (956)
    • Sekcje modułu (958)
    • Program Turbo Dump (TDUMP.EXE) (959)
  • Podsumowanie (970)
Rozdział 27. Testowanie programu i wyszukiwanie błędów (971)
  • Testowanie (972)
    • Projektowanie aplikacji z myślą o jej testowaniu (972)
    • Sekwencje testowe w kodzie aplikacji (973)
    • Asercje (977)
    • Testowanie ścieżek i jednostek (981)
  • Zintegrowany debugger Delphi 3 (982)
    • Opcje IDE związane ze śledzeniem zintegrowanym (982)
    • Włączanie do kodu wynikowego informacji umożliwiających śledzenie (984)
    • Praca krokowa na poziomie kodu źródłowego (985)
    • Obserwowanie i zmiana wartości zmiennych (988)
    • Modyfikacja wartości zmiennych (990)
    • Punkty przerwań (991)
    • Śledzenie wewnątrz bibliotek DLL (993)
    • Śledzenie na poziomie języka asemblera (993)
    • Okno statusu wątków (996)
    • Lista załadowanych modułów (996)
    • Stos wywołań (997)
    • Śledzenie kodu źródłowego komponentów VCL (998)
  • Śledzenie uproszczone (998)
    • Wyświetlanie informacji testowej na formularzu (998)
    • Wykorzystanie procedury ShowMessage (1001)
    • Wypisywanie komunikatów na konsolę (1002)
    • Zapis do pliku kroniki (1003)
  • Kłopotliwe błędy systemowe (1006)
    • Error Setting Debug Exception Hook (1006)
    • Naruszenie ochrony (Access Violation) (1006)
    • Przepełnienie stosu programu (1007)
    • Wyjątki zewnętrzne (1008)
  • Zewnętrzny debugger TD32.EXE (1008)
  • Podsumowanie (1009)
Rozdział 28. Tworzenie aplikacji serwera WWW w Delphi 3 (1011)
  • Podstawowe pojęcia dotyczące aplikacji serwera WWW (1012)
    • HTTP a HTML (1013)
    • Przeglądarka internetowa w roli interfejsu użytkownika (1013)
    • Biblioteki API serwera WWW (1013)
  • Tworzenie przykładowej aplikacji ISAPI (1015)
    • Współpraca serwera WWW z bazami danych (1025)
  • Podsumowanie (1031)
Rozdział 29. Rozszerzenia IDE - interfejs Open Tools API (1033)
  • Tworzenie nowego eksperta (1034)
    • Style narzędzi ekspertowych (1035)
    • Implementacja klasy eksperta (1035)
    • Rejestracja eksperta (1040)
    • Obsługa wyjątków (1043)
  • Przegląd modułów biblioteki Open Tools API (1043)
    • Zmienna ToolServices (1046)
    • Interfejsy związane z projektem (1047)
    • Interfejsy menu głównego (1053)
    • Interfejsy edytora (1058)
  • Podsumowanie (1060)
Rozdział 30. Łączenie kodów Object Pascala i C++ (1061)
  • Metody łączenia kodu Pascala i C++ (1062)
    • Media pośredniczące (1062)
    • Moduły wynikowe .OBJ (1063)
    • Biblioteki DLL (1063)
  • Konwencje wywoływania (1064)
  • Wykorzystanie zbiorów .OBJ do łączenia C++ z Object Pascalem (1065)
    • Wykorzystanie kodu C++ w Object Pascalu (1065)
    • Wykorzystanie w C++ modułów .OBJ generowanych przez Delphi (1068)
  • Łączenie C++ z Object Pascalem za pomocą bibliotek DLL (1069)
    • Funkcje obudowujące (1070)
    • Dostęp do tablic VMT (1074)
  • Wzajemna odpowiedniość typów C++ i Object Pascala (1077)
  • Podsumowanie (1080)
Rozdział 31. Wykorzystanie mechanizmów Windows API (1081)
  • Funkcje zwrotne (1082)
  • Funkcje przechwytujące (1085)
    • Przykład zastosowania - journaling (1088)
  • 32-bitowe liczby całkowite bez znaku (1101)
  • Podsumowanie (1106)
Rozdział 32. Thunking (1107)
  • Typy thunkingu (1107)
    • Universal Thunk (1108)
    • A co z Windows NT? (1109)
    • Wykorzystanie komunikatu WM_COPYDATA (1109)
    • Wykorzystanie funkcji QT_Thunk (Quick Thunking) (1113)
  • Podsumowanie (1118)
Postscriptum - od tłumacza (1119)
    • "Płaski" model pamięci jako jeden z wariantów pamięci wirtualnej (1119)
    • Zagadnienie zastoju (1123)
    • Interfejsy COM a rozszerzenia w dziedziczeniu klas Object Pascala (1125)
  • Autorzy... (1129)
  • Tłumacz... (1131)