okladka
C++ Builder jest najnowszym systemem firmy Borland przeznaczonym do szybkiego tworzenia aplikacji. Łączy on w sobie uniwersalność języka C++ i ogromne możliwości systemu Delphi. Dzięki wykorzystaniu komponentów i technik programowania wizualnego, C++ Builder umożliwia błyskawiczne prototypowanie i budowę pełnowartościowych aplikacji przeznaczonych dla Windows.

Książka ta poprowadzi Cię przez zagadnienia programowania w systemie C++ Builder od podstaw, czyli kompendium wiedzy o C++, poprzez prezentację biblioteki VCL i jej komponentów, omówienie narzędzi systemu i metod programowania wizualnego, aż do technik programowania grafiki, obsługi baz danych i aplikacji internetowych.

Dzięki zdobytej w ten sposób wiedzy będziesz mógł błyskawicznie przejść od tradycyjnych metod programowania do projektowania i programowania wizualnego. Czytając ją:

  • poznasz techniki programowania obiektowego i wizualnego;
  • zapznasz się z elementami środowiska systemu C++ Builder 3 oraz biblioteką VCL;
  • zaznajomisz się ze sposobami błyskawicznego prototypowania, budowy i uruchamiania 32-bitowych aplikacji dla Windows 95 i Windows NT;
  • zapoznasz się z zaawansowanymi technikami programowania, jak obsługa wyjątków i komunikatów, wykorzystanie rejestru czy udostępnianie poleceń;
  • poznasz metody programowania grafiki, obsługi baz danych, tworzenia aplikacji inernetowych i własnych komponentów;
  • dowiesz się, jak połączyć ze sobą elementy systemów C++ Builder i Delphi.
Autor książki, Kent Reisdorph, kieruje zespołem programistów w firmie TurboPower Software w Colorado Springs. Współpracuje on także z firmą Borland, biorąc udział w pracach grupy doradczej o nazwie TeamB jako niezależny programista i konsultant.


O autorze (19)
Podziękowania (20)
Jeśli już tu jesteś (21)
Na co zwrócić uwagę (22)
Część I (23)
Rozdział 1. Pierwsze kroki w systemie C++Builder (25)

  • Czym jest C++Builder? (25)
  • IDE od pierwszego wejrzenia (26)
  • Ahoj, przygodo! (29)
  • To samo w wersji tekstowej (31)
  • Wprowadzenie do C++ (37)
    • Narodziny języka (38)
    • Zmienne (39)
    • Typy danych w C++ (40)
    • Operatory (44)
    • Funkcje (46)
    • Funkcja main() (50)
    • Tablice (52)
    • Tablice znakowe (55)
    • Funkcje operujące na łańcuchach (57)
    • Tablice łańcuchów (59)
  • Podsumowanie (60)
  • Warsztat (60)
    • Pytania i odpowiedzi (61)
    • Quiz (61)
    • Zadania (62)
Rozdział 2. Wprowadzenie do C++ (65)
  • Jeżeli... (65)
  • Pętle i ich zastosowania (69)
    • Pętla for (71)
    • Pętla while (73)
    • Pętla do-while (75)
    • Instrukcja goto (76)
    • Instrukcje continue i break (76)
  • Instrukcja switch (77)
  • Zasięg (80)
    • Zmienne zewnętrzne (82)
  • Struktury (82)
    • Tablice struktur (85)
    • Pliki nagłówkowe i pliki źródłowe (85)
    • Struktury w akcji (87)
  • Podsumowanie (91)
  • Warsztat (91)
    • Pytania i odpowiedzi (91)
    • Quiz (92)
    • Zadania (93)
Rozdział 3. Zaawansowane elementy C++ (95)
  • Wskaźniki (95)
    • Zmienne lokalne i dynamiczne (96)
    • Obiekty dynamiczne a wskaźniki (98)
    • Jak to się ma do naszego programu? (98)
    • Dereferencja, czyli wyłuskanie (100)
    • Do dzieła! (101)
  • Referencje (103)
  • Przekazywanie parametrów przez wskaźnik i przez referencję (106)
    • Modyfikator const (108)
  • Operatory new i delete (109)
    • Operator new (109)
    • Operator delete (110)
    • Rozwiązanie zagadki (112)
    • Operatory new[ ] i delete[ ] (112)
  • Co mogą funkcje w C++? (113)
    • Przeciążanie funkcji (113)
    • Parametry domyślne funkcji (116)
    • Funkcje składowe klas (117)
    • Funkcje wstawiane (118)
  • Podsumowanie (119)
  • Warsztat (119)
    • Pytania i odpowiedzi (119)
    • Quiz (120)
    • Zadania (121)
Rozdział 4. O klasach i programowaniu obiektowym (123)
  • Co to jest klasa? (123)
  • Anatomia klasy (124)
    • Dostęp do elementów klasy (125)
    • Konstruktory (127)
    • Destruktory (130)
    • Pola (131)
    • Funkcje składowe (133)
    • Wskaźnik this (136)
    • A teraz przykład (138)
  • Dziedziczenie (145)
    • Dziedziczenie wielokrotne (149)
  • Wprowadzenie do operacji wejścia-wyjścia (151)
    • Odczytujemy dane (152)
    • Zapisujemy dane (154)
    • Ustalenie trybu otwarcia pliku (155)
    • Obsługa plików binarnych (157)
    • Wskaźnik plikowy (157)
    • Swobodny dostęp do pliku (158)
  • Podsumowanie (160)
  • Warsztat (161)
    • Pytania i odpowiedzi (161)
    • Quiz (162)
    • Zadania (163)
Rozdział 5. Biblioteki klas i komponenty (165)
  • Kilka słów wprowadzenia (165)
    • Po co mi to wszystko? (166)
    • Gdzie jest haczyk? (168)
    • Biblioteki jako wzór projektowania i programowania obiektowego (169)
  • Wojny bibliotek (170)
    • Biblioteka Object Windows Library (170)
    • Biblioteka Microsoft Foundation Class Library (171)
    • Co więc wybrać? (173)
  • Nowa twarz w towarzystwie: biblioteka Visual Component Library (173)
    • Komponenty (174)
    • Właściwości, metody i zdarzenia (174)
  • C++Builder a biblioteka VCL (188)
    • VCL dla praktyków C++ (189)
    • Wszystkie obiekty klas zdefiniowanych w VCL muszą być tworzone dynamicznie (189)
    • VCL nie dopuszcza domyślnych parametrów funkcji (190)
    • VCL nie umożliwia dziedziczenia wielokrotnego (191)
  • Implementacja łańcuchów w bibliotece VCL (191)
    • Czy to naprawdę jest potrzebne? (191)
    • Szablon SmallString (192)
    • Klasa AnsiString (193)
    • Typ zbiorowy (198)
  • Nieco więcej o bibliotece VCL (200)
    • Klasy implementujące formularz i aplikację (201)
    • Klasy komponentowe (202)
    • To jeszcze nie koniec... (207)
  • Podsumowanie (208)
  • Warsztat (209)
    • Pytania i odpowiedzi (209)
    • Quiz (210)
    • Zadania (211)
Rozdział 6. Więcej o środowisku systemu (213)
  • Projekty w systemie C++Builder (214)
    • Pliki wykorzystywane w projektach (215)
    • Moduły źródłowe (219)
  • Menu główne i paleta narzędzi (221)
  • Paleta komponentów i jej wykorzystanie (223)
    • Umieszczenie kilku kopii komponentu na formularzu (223)
    • Wyśrodkowanie komponentu na formularzu (224)
    • Menu kontekstowe palety komponentów (225)
    • Nawigacja w palecie komponentów (225)
  • Wracamy do rzeczy, czyli aplikacja wielomodułowa (226)
    • Kompilacja, łączenie i budowa aplikacji (229)
  • Kompilacja innych programów w C++ (231)
  • O formularzach nieco więcej (234)
    • Formularz okna głównego (234)
    • Formularze okienek dialogowych (234)
    • Okienka dodatkowe a dialogi (240)
    • Aplikacje wielodokumentowe (MDI) (241)
    • Podstawowe właściwości formularzy (241)
    • Metody formularzy (245)
    • Zdarzenia obsługiwane przez formularze (246)
  • Inspektor obiektów (248)
    • Lista komponentów (249)
    • Karta właściwości (250)
    • Karta zdarzeń (252)
  • Przykładowa aplikacja MDI (253)
    • Krok 1: projektujemy okno główne (253)
    • Krok 2: programujemy funkcje otwarcia i zapisania pliku (255)
    • Krok 3: programujemy obsługę okienek potomnych (257)
    • Krok 4: projektujemy formularz okienka potomnego (258)
    • Krok 5: projektujemy wizytówkę (259)
  • Podsumowanie (263)
  • Warsztat (263)
    • Pytania i odpowiedzi (263)
    • Quiz (265)
    • Zadania (265)
Rozdział 7. Edytor formularzy i edytor menu (267)
  • Edytor formularzy i jego wykorzystanie (267)
    • Menu kontekstowe edytora formularzy (268)
    • Rozmieszczanie komponentów na formularzu (269)
    • Siatka edytora formularzy (270)
    • Wybieranie komponentów (271)
    • Przesuwanie komponentów (275)
    • Zabezpieczenie komponentów przed przesuwaniem i zmianą rozmiarów (277)
    • Zmiana porządku głębokości komponentów oraz ich kopiowanie, wycinanie i wklejanie (277)
    • Zmiana wielkości komponentów (279)
    • Wyrównywanie komponentów (281)
    • Ustalanie porządku wyboru komponentów (292)
  • Prosimy o menu! (293)
    • Tworzymy menu główne (294)
    • Nieco programowania (303)
    • Menu kontekstowe (309)
    • Tworzenie i zapamiętywanie szablonów menu (311)
  • Podsumowanie (312)
  • Warsztat (312)
    • Pytania i odpowiedzi (312)
    • Quiz (313)
    • Zadania (314)
Podsumowanie (315)
Część II (317)
Rozdział 8. Komponenty biblioteki VCL (319)
  • Nieco przypomnienia (319)
  • Właściwość Name (321)
  • Ważniejsze wspólne właściwości komponentów (322)
    • Właściwość Align (323)
    • Właściwość Color (323)
    • Kursory (324)
    • Właściwość Enabled (325)
    • Właściwość Font (326)
    • Właściwość Hint (328)
    • Właściwości ParentColor, ParentCtl3D, ParentFont i ParentShowHint (328)
    • Właściwość Tag (329)
    • Inne częściej używane właściwości (329)
  • Podstawowe metody komponentów (330)
  • Podstawowe zdarzenia obsługiwane przez komponenty (331)
  • Klasa TStrings (333)
  • Standardowe elementy sterujące Windows (335)
    • Komponenty edycyjne (335)
    • Listy (340)
    • Przyciski (344)
    • Etykiety (353)
    • Paski przewijania (354)
    • Panele (354)
    • I wiele innych... (355)
  • Standardowe okienka dialogowe (356)
    • Metoda Execute() (356)
    • Okienka dialogowe otwarcia i zapisania pliku (357)
    • Okienka dialogowe otwarcia i zapisania pliku graficznego (360)
    • Okienko dialogowe wyboru koloru (361)
    • Okienko dialogowe wyboru czcionki (361)
    • Okienka dialogowe wyszukiwania i zamiany (362)
  • Podsumowanie (363)
  • Warsztat (363)
    • Pytania i odpowiedzi (363)
    • Quiz (365)
    • Zadania (365)
Rozdział 9. Tworzenie aplikacji w systemie C++Builder (367)
  • Składnica obiektów i jej wykorzystanie (368)
    • Dostęp do zawartości składnicy obiektów (368)
    • Wykorzystanie zawartości składnicy obiektów (370)
    • Tworzenie elementów aplikacji z użyciem składnicy obiektów (373)
    • Dodawanie obiektów do składnicy (374)
    • Dodawanie projektów do składnicy (375)
    • Zarządzanie zawartością składnicy (376)
  • Tworzenie formularzy i aplikacji z użyciem kreatorów (378)
    • Kreator dialogów (379)
    • Kreator aplikacji (380)
  • Definiowanie funkcji składowych i pól klasy (385)
    • Deklaracje klas w systemie C++Builder (385)
    • Dodanie funkcji składowej do definicji klasy (387)
    • Dodanie pola do definicji klasy (389)
    • Usunięcie kodu wygenerowanego przez system (390)
  • Szablony komponentów (390)
  • Wykorzystanie zasobów (393)
  • Pakiety (400)
    • Co to jest pakiet? (401)
    • Łączenie statyczne i dynamiczne (402)
    • Wykorzystanie pakietów w aplikacjach (405)
    • Dystrybucja aplikacji wykorzystujących pakiety (405)
  • Podsumowanie (406)
  • Warsztat (407)
    • Pytania i odpowiedzi (407)
    • Quiz (408)
    • Zadania (409)
Rozdział 10. O projektach nieco więcej (411)
  • Bez projektu ani rusz (411)
  • Korzystanie z menedżera projektów (412)
    • Grupy projektów (412)
    • Okienko menedżera projektów (414)
    • Tworzenie i wykorzystanie grup projektów (416)
    • Budowa projektów i ich grup (418)
  • Konfiguracja projektu (419)
    • Karta Forms (420)
    • Karta Application (422)
    • Karta Compiler (423)
    • Karta Advanced Compiler (427)
    • Karta C++ (429)
    • Karta Pascal (429)
    • Karta Linker (429)
    • Karta Directories/Conditionals (432)
    • Karta Version Info (433)
    • Karta Packages (435)
    • Karta Tasm (436)
  • Edytor kodu (436)
    • Podstawowe operacje na tekście źródłowym (437)
    • Zaawansowane funkcje edytora (443)
    • Menu kontekstowe edytora kodu (447)
    • Zmiana konfiguracji edytora (448)
  • Podsumowanie (452)
  • Warsztat (452)
    • Pytania i odpowiedzi (452)
    • Quiz (453)
    • Zadania (454)
Rozdział 11. Debugger (457)
  • Po co używać debuggera? (458)
  • Polecenia debuggera (458)
  • Punkty wstrzymania (460)
    • Ustawianie i usuwanie punktów wstrzymania (460)
    • Lista punktów wstrzymania (462)
    • Bezwarunkowe punkty wstrzymania (464)
    • Warunkowe punkty wstrzymania (464)
    • Polecenie Run to Cursor (465)
  • Śledzenie zmiennych (466)
    • Podgląd wyrażeń wskazanych kursorem (466)
    • Menu kontekstowe listy zmiennych śledzonych (468)
    • Okienko dialogowe ustawień śledzenia (468)
    • Zawieszenie śledzenia zmiennej (470)
    • Dodanie zmiennej do listy zmiennych śledzonych (470)
    • Korzystanie z listy zmiennych śledzonych (471)
  • Inspektor danych (473)
    • Inspekcja danych lokalnych (476)
  • Pozostałe narzędzia uruchomieniowe (476)
    • Podgląd i modyfikacja zmiennych (476)
    • Stos wywołań funkcji (478)
    • Podgląd rejestrów procesora (479)
    • Lokalizacja adresów w kodzie źródłowym (479)
  • Praca krokowa (480)
  • Uruchamianie bibliotek DLL (483)
  • Raport uruchomieniowy (484)
  • Okienko widoku modułów (485)
  • Techniki uruchomieniowe (485)
    • Funkcja OutputDebugString() (486)
    • Naruszenia ochrony dostępu do pamięci (486)
    • Wskazówki i rady (488)
  • Konfiguracja debuggera (489)
    • Opcja Integrated debugging (490)
    • Grupa General (490)
    • Grupa Event Log (490)
    • Grupa Exceptions (490)
  • Podsumowanie (491)
  • Warsztat (491)
    • Pytania i odpowiedzi (491)
    • Quiz (492)
    • Zadania (493)
Rozdział 12. Programy narzędziowe i konfiguracja IDE (495)
  • Edytor graficzny (496)
    • Kolor tła i atramentu (497)
    • Funkcje graficzne edytora (498)
    • Powiększanie rysunku (500)
    • Dobór szerokości linii i kształtu pędzla (501)
    • Projektowanie map bitowych (501)
    • Projektowanie ikon (502)
    • Projektowanie kursorów (504)
    • Menu kontekstowe edytora graficznego (505)
    • Tworzenie plików zasobów (505)
  • Agent WinSight, czyli szpiegostwo w Windows (507)
    • Wymiana komunikatów w systemie Windows (508)
    • Panel listy okienek (509)
    • Panel komunikatów (510)
    • Jak śledzić okienka? (511)
    • Filtrowanie komunikatów (511)
    • Pozostałe funkcje programu WinSight (513)
  • Resource Expert (515)
  • DOS-owe programy narzędziowe (516)
    • GREP.EXE (517)
    • COFF2OMF.EXE (517)
    • IMPLIB.EXE (517)
    • TOUCH.EXE (518)
    • TDUMP.EXE (518)
  • Konfiguracja menu narzędzi (520)
    • Okienko dialogowe konfiguracji narzędzi (520)
  • Konfiguracja środowiska systemu (522)
    • Karta Preferences (523)
    • Karta Library (524)
    • Karta Palette (525)
    • Karta Code Insight (526)
  • Podsumowanie (527)
  • Warsztat (527)
    • Pytania i odpowiedzi (527)
    • Quiz (529)
    • Zadania (529)
Rozdział 13. Więcej, lepiej, szybciej (531)
  • Elementy dekoracyjne (531)
    • Paski narzędzi (531)
    • Komponent CoolBar (533)
    • Komponent ToolBar (535)
    • Paski statusowe (542)
    • Palety narzędzi (549)
  • Udostępnianie poleceń (550)
    • Kilka słów wstępu (550)
    • Na kłopoty - OnIdle (551)
    • No to do roboty! (552)
    • Rozwiązania alternatywne (554)
  • Drukujemy (555)
    • Okienka dialogowe obsługujące drukowanie (555)
    • Drukowanie łatwe... (558)
    • ...i trudniejsze (560)
    • Drukowanie map bitowych (566)
  • Kursory i ich wykorzystanie (567)
    • Nieco teorii (567)
    • Kursory standardowe (568)
    • Kursory definiowane przez użytkownika (569)
  • Podsumowanie (570)
  • Warsztat (570)
    • Pytania i odpowiedzi (571)
    • Quiz (572)
    • Zadania (572)
Rozdział 14. Zaawansowane techniki programowania (575)
  • Programowanie systemu pomocy aplikacji (575)
    • Tworzymy plik pomocy (576)
    • Identyfikatory kontekstu i właściwość HelpContext (577)
    • Implementacja systemu pomocy w aplikacji (578)
    • Definiowanie identyfikatorów kontekstu w postaci stałych symbolicznych (580)
    • System pomocy w praktyce (581)
  • Obsługa wyjątków (582)
    • Składnia obsługi wyjątków (584)
    • Generacja wyjątków (585)
    • Przechwytywanie wyjątków (586)
    • Przechwytywanie nieobsłużonych wyjątków na poziomie aplikacji (588)
    • Obsługa wyjątków a uruchamianie programu (590)
  • Baza rejestracyjna systemu i jej wykorzystanie (591)
    • Klucze (592)
    • Typy danych przechowywanych w rejestrze (593)
    • Klasa TRegistry (593)
    • Wykorzystanie klasy TRegistry do operacji na rejestrze (596)
  • Obsługa komunikatów (603)
    • Kilka słów teorii (603)
    • Wysyłanie i ogłaszanie komunikatów (606)
    • Obsługa zdarzeń (607)
    • Obsługa komunikatów w kodzie użytkownika (608)
    • Komunikaty użytkownika (613)
  • Podsumowanie (615)
  • Warsztat (615)
    • Pytania i odpowiedzi (615)
    • Quiz (616)
    • Zadania (617)
Podsumowanie (619)
Część III (621)
Rozdział 15. Programowanie operacji graficznych (623)
  • Grafika minimalnym kosztem (623)
  • Konteksty urządzeń i klasa TCanvas (624)
  • Obiekty GDI (627)
    • Pióra, pędzle i czcionki (627)
    • Ograniczanie obszaru rysowania (633)
  • Podstawowe operacje graficzne (635)
    • Wyprowadzanie tekstu (635)
    • Rysowanie map bitowych (641)
  • Mapy bitowe przechowywane w pamięci (643)
  • Podsumowanie (648)
  • Warsztat (648)
    • Pytania i odpowiedzi (649)
    • Quiz (649)
    • Zadania (650)
Rozdział 16. Bazy danych w systemie C++Builder (651)
  • Kilka słów wprowadzenia (652)
    • Lokalne bazy danych (653)
    • Bazy danych typu klient-serwer (654)
    • Warstwowa architektura baz danych (654)
  • Interfejs BDE (655)
    • Sterowniki BDE (656)
    • Aliasy BDE (656)
    • Sterowniki SQL Links (657)
  • Lokalna baza InterBase (658)
  • Komponenty "bazodanowe" w systemie C++Builder (658)
    • Klasa TDataSet (660)
    • Komponent Table (666)
    • Komponent Query (672)
    • Komponent StoredProc (675)
    • Komponent UpdateSQL (676)
    • Komponent DataSource (677)
    • Komponent Session (677)
    • Komponent Database (678)
    • Komponent BatchMove (680)
    • Klasa TField (681)
  • Komponenty obsługujące bazy typu klient-serwer (685)
  • Tworzenie aliasów BDE (685)
    • Utworzenie aliasu za pomocą aplikacji BDE Administrator (686)
    • Programowe utworzenie aliasu (687)
  • Podsumowanie (688)
  • Warsztat (688)
    • Pytania i odpowiedzi (688)
    • Quiz (689)
    • Zadania (689)
Rozdział 17. Formularze obsługujące bazy danych (691)
  • Kreator formatek (691)
    • Konstrukcja formularza jednotabelowego (692)
    • Konstrukcja formularza wielotabelowego (697)
  • Budowa formularza "na piechotę" (700)
  • Komponenty reprezentujące dane (703)
    • Wspólne właściwości komponentów reprezentujących dane (703)
    • Komponent DBGrid (704)
    • Komponent DBNavigator (705)
    • Komponent DBText (705)
    • Komponent DBEdit (705)
    • Komponent DBMemo (705)
    • Komponent DBImage (706)
    • Komponenty DBListBox i DBComboBox (706)
    • Komponent DBCheckBox (707)
    • Komponent DBRadioGroup (707)
    • Komponenty DBLookupListBox i DBLookupComboBox (708)
    • Komponent DBRichEdit (708)
    • Komponent DBCtrlGrid (708)
    • Pozostałe komponenty związane z bazami danych (710)
  • Podsumowanie (710)
  • Warsztat (710)
    • Pytania i odpowiedzi (711)
    • Quiz (711)
    • Zadania (712)
Rozdział 18. Aplikacje "bazodanowe" w systemie C++Builder (713)
  • Programowanie baz danych na poważnie (713)
    • Programowe odczytanie zawartości bazy danych (714)
    • Programowe utworzenie bazy danych (718)
  • Moduły danych i ich zastosowanie (724)
  • Raporty (728)
    • Nieco teorii (728)
    • Budowa raportu metodą tradycyjną (731)
    • Półautomatyczne tworzenie raportów (734)
  • Dystrybucja aplikacji obsługujących bazy danych (734)
  • Podsumowanie (735)
  • Warsztat (735)
    • Pytania i odpowiedzi (735)
    • Quiz (736)
    • Zadania (736)
Rozdział 19. Budowa i wykorzystanie bibliotek DLL (739)
  • Nieco podstaw (740)
    • Czym jest biblioteka DLL? (740)
    • Po co mi biblioteki DLL? (741)
  • Korzystanie z zawartości bibliotek DLL (744)
    • Ładowanie bibliotek DLL do pamięci (744)
    • Wywoływanie funkcji z bibliotek DLL (745)
  • Utworzenie biblioteki DLL (747)
    • Eksportowanie i importowanie funkcji i klas (747)
    • Tajemnicze makro DLL_EXP (751)
    • Utworzenie biblioteki DLL za pomocą składnicy obiektów (752)
    • Generacja pliku biblioteki importowej (756)
  • Budowa aplikacji wykorzystującej bibliotekę DLL (756)
    • Dołączenie pliku nagłówkowego biblioteki do kodu źródłowego (757)
    • Dołączenie biblioteki importowej do projektu (758)
  • Formularze w bibliotekach DLL (758)
    • Wywołanie formularza z biblioteki przez aplikację napisaną w systemie C++ Builder (759)
    • Wywołanie formularza MDI z biblioteki dynamicznej (760)
    • Wywołanie formularza z biblioteki przez aplikację utworzoną za pomocą innego kompilatora (762)
  • Umieszczanie zasobów w pliku DLL (764)
    • Utworzenie biblioteki zasobów (764)
    • Wykorzystanie biblioteki zasobów (766)
  • Podsumowanie (767)
  • Warsztat (767)
    • Pytania i odpowiedzi (767)
    • Quiz (769)
    • Zadania (769)
Rozdział 20. Budujemy własne komponenty (771)
  • Utworzenie komponentu (772)
    • Okienko dialogowe utworzenia komponentu (772)
    • Pierwsza wersja komponentu FlashingLabel (774)
    • Funkcje Register() i ValidCtrCheck() (776)
  • Właściwości i metody komponentu (777)
    • Właściwości komponentu (777)
    • Definiowanie metod komponentu (783)
  • Rozszerzamy komponent FlashingLabel (784)
    • Właściwość ComponentState (790)
  • Testowanie komponentu (791)
  • Dodanie komponentu do palety (793)
    • Definiujemy ikonę komponentu (794)
  • Definiowanie zdarzeń komponentów (796)
    • Podstawowe wiadomości o zdarzeniach (796)
    • Redefinicja zdarzeń klasy bazowej (801)
  • Nowe oblicze komponentu FlashingLabel (802)
  • Podsumowanie (808)
  • Warsztat (808)
    • Pytania i odpowiedzi (808)
    • Quiz (810)
    • Zadania (810)
Rozdział 21. C++Builder a Delphi (813)
  • Delphi i C++Builder - podobieństwa (813)
    • IDE (813)
    • Biblioteka Visual Component Library (815)
    • Formularze (815)
    • Pakiety (816)
  • Delphi i C++Builder - różnice (816)
    • Język (817)
    • Rozszerzenia nazw plików (817)
    • Grupy projektów (818)
    • Menedżer projektów (818)
    • Debugger (818)
    • Funkcje uzupełniania kodu źródłowego i parametrów metod (818)
    • Kompilacja modułów pascalowych (819)
    • Komponenty internetowe ActiveX (819)
    • Tworzenie elementów ActiveX (819)
    • Szybkość kompilacji i objętość kodu wynikowego (819)
  • Konwersja projektu z Delphi do systemu C++Builder (820)
    • Przeniesienie formularzy z Delphi do systemu C++Builder (820)
    • Tłumaczenie tekstu źródłowego (822)
    • Użycie formularzy Delphi w systemie C++Builder (825)
  • Podsumowanie (825)
  • Warsztat (826)
    • Pytania i odpowiedzi (826)
    • Quiz (827)
    • Zadania (827)
Podsumowanie (829)
Dodatki (831)
Dodatek A. Tworzenie aplikacji internetowych (833)
  • Komponenty internetowe w systemie C++Builder (833)
  • Budujemy przeglądarkę WWW (835)
    • Jeszcze jedna przeglądarka...? (835)
    • Fundamenty (836)
    • Wyświetlenie statusu połączenia (838)
    • Drobne retusze (839)
  • Internet Explorer jako komponent internetowy (844)
  • Poczta elektroniczna (846)
  • Dystrybucja aplikacji internetowych (847)
  • Podsumowanie (849)
  • Warsztat (849)
    • Pytania i odpowiedzi (849)
    • Quiz (850)
    • Zadania (850)
Dodatek B. Rozszerzenia języka C++ w systemie C++Builder (851)
  • Nieco historii (851)
  • Rozszerzać, nie rozszerzać...? (853)
  • Nowe słowa kluczowe (855)
    • __automated (855)
    • __classid (856)
    • __closure (856)
    • __declspec (856)
    • __finally (857)
    • __int8, __int16, __int32 i __int64 (857)
    • __property (858)
    • __published (860)
  • Podsumowanie (861)
Dodatek C. Odpowiedzi na pytania testowe (863)
  • Rozdział 1. (863)
  • Rozdział 2. (864)
  • Rozdział 3. (864)
  • Rozdział 4. (865)
  • Rozdział 5. (865)
  • Rozdział 6. (866)
  • Rozdział 7. (867)
  • Rozdział 8. (867)
  • Rozdział 9. (868)
  • Rozdział 10. (869)
  • Rozdział 11. (869)
  • Rozdział 12. (870)
  • Rozdział 13. (871)
  • Rozdział 14. (871)
  • Rozdział 15. (872)
  • Rozdział 16. (872)
  • Rozdział 17. (873)
  • Rozdział 18. (874)
  • Rozdział 19. (874)
  • Rozdział 20. (875)
  • Rozdział 21. (875)
  • Dodatek A. (876)
Dodatek D. C++Builder w Internecie (877)
  • Komercyjne serwisy WWW (877)
  • Prywatne serwisy WWW (879)
  • Grupy dyskusyjne (880)
  • Periodyki elektroniczne (880)
Skorowidz (883)