Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00363 008361 11063061 na godz. na dobę w sumie
Delphi 6. Vademecum profesjonalisty. Tom I - książka
Delphi 6. Vademecum profesjonalisty. Tom I - książka
Autor: , Liczba stron: 624
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-690-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> delphi - programowanie
Porównaj ceny (książka, ebook, audiobook).
Teixeira i Pacheco wciąż dzielą się z czytelnikami swą wiedzą i doświadczeniem, ucząc jak tworzy się aplikacje bazodanowe -- lokalne, wielowarstwowe i internetowe oraz nowe komponenty, biblioteki DLL itd. Czytając tę książkę, masz niepowtarzalną okazję podnieść swoje kwalifikacje, gdyż umożliwia ona zapoznanie się m.in. z zasadami tworzenia aplikacji międzyplatformowych, metodologią tworzenia komponentów i ich edytorów, filozofią programowania obiektowego i programowaniem współbieżnym.

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

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

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Delphi 6. Vademecum profesjonalisty. Tom I Autorzy: Xavier Pacheco, Steve Teixeira T‡umaczenie: Andrzej Gra¿yæski ISBN: 83-7197-690-9 Tytu‡ orygina‡u: Format: B5, stron: oko‡o 620 Zawiera CD-ROM Delphi 6 Developer’s Guide Teixeira i Pacheco wci„¿ dziel„ siŒ z czytelnikami sw„ wiedz„ i do(cid:156)wiadczeniem, ucz„c, jak tworzy siŒ aplikacje bazodanowe (cid:151) lokalne, wielowarstwowe i internetowe oraz nowe komponenty, biblioteki DLL itd. Czytaj„c tŒ ksi„¿kŒ, masz niepowtarzaln„ okazjŒ podnie(cid:156)(cid:230) swoje kwalifikacje, gdy¿ umo¿liwia ona zapoznanie siŒ m.in. z zasadami tworzenia aplikacji miŒdzyplatformowych, metodologi„ tworzenia komponent(cid:243)w i ich edytor(cid:243)w, filozofi„ programowania obiektowego i programowaniem wsp(cid:243)‡bie¿nym. Niniejsza ksi„¿ka, napisana przez dwukrotnych laureat(cid:243)w nagrody za najlepsz„ ksi„¿kŒ o Delphi, przyznanej przez czytelnik(cid:243)w Delphi Informant, stworzona przez programist(cid:243)w dla programist(cid:243)w, to miarodajny przewodnik po nowo(cid:156)ciach Delphi 6. Czytaj„c Delphi 6. Vademecum profesjonalisty, poznasz miŒdzy innymi: historiŒ Delphi i techniczne oraz ekonomiczne uwarunkowania jego rozwoju, bogactwo (cid:156)rodowiska IDE i wsp(cid:243)‡dzia‡anie jego element(cid:243)w w procesie tworzenia aplikacji, najwa¿niejsze elementy jŒzyka Object Pascal, szczeg(cid:243)‡y biblioteki CLX i zasady tworzenia aplikacji miŒdzyplatformowych dla Windows i Linuksa, mechanizm komunikat(cid:243)w Windows i zasady ich obs‡ugi w tworzonych aplikacjach, podstawy tworzenia i wykorzystywania bibliotek DLL, realizacjŒ programowania wsp(cid:243)‡bie¿nego za pomoc„ w„tk(cid:243)w i w‡(cid:243)kien oraz mechanizm(cid:243)w synchronizuj„cych, zastosowanie nowych komponent(cid:243)w bazodanowych dbExpress i dbGo for ADO. 9836+-    6/.3;+.3;.+2+3612+2/13   6/.3;+.3;.+2+437/13   (cid:3) 3.78+;46316+3;+2+  3.+o  6316+3;+2/;/4   Rodzina produktów Delphi...................................................r.................................................21 Delphi — co i dlaczego?...................................................r...................................................r..23 Komfort wizualnego projektowania aplikacji ...................................................r..............24 Szybkość kompilacji kontra efektywność generowanego kodu ......................................25 Możliwości języka programowania w kontekście jego złożoności.................................26 Elastyczność i skalowalność architektury baz danych ...................................................r.27 Wzorce projektowania i użytkowania wymuszone przez strukturę środowiska .............27 Nieco historii...................................................r...................................................r....................28 Delphi 1 ...................................................r...................................................r.....................28 Delphi 2 ...................................................r...................................................r.....................29 Delphi 3 ...................................................r...................................................r.....................30 Delphi 4 ...........................................r...................................................r.............................31 Delphi 5 ...................................................r...................................................r.....................31 Delphi 6 ...................................................r...................................................r.....................32 Środowisko zintegrowane Delphi 6...................................................r....................................32 Okno główne...................................................r...................................................r..............32 Projektant formularzy ...................................................r...................................................r34 Inspektor obiektów ...................................................r...................................................r....35 Edytor kodu ...................................................r...................................................r...............36 Eksplorator kodu...................................................r...................................................r........36 Hierarchia obiektów ...................................................r...................................................r..36 Kod źródłowy projektu ...................................................r...................................................r....36 Prosta aplikacja ...................................................r...................................................r................38 Jeszcze o zdarzeniach... ...................................................r...................................................r...40 Niekontraktowy charakter obsługi zdarzeń ...................................................r..................40 Prototypowanie kodu ...................................................r...................................................r.......41 Rozbudowa zestawu komponentów i konfigurowalne środowisko.......................................42 Top 10 — gorąca dziesiątka IDE...................................................r........................................42 1. Uzupełnianie klas ...................................................r...................................................r..42 2. Udostępnianie deklaracji symbolu...................................................r............................43 3. Od deklaracji do definicji ...................................................r.........................................43 4. Dokowanie...................................................r...................................................r.............43 5. Object Browser ...................................................r...................................................r......44 6. GUID ...................................................r...................................................r.....................44 7. Wyróżnianie składni plików C++...................................................r.............................44  /4  +.//-94630/732+78 $3 3.+o  8. Znaczniki To Do…...................................................r...................................................r45 9. Menedżer projektów ...................................................r.................................................45 10. Code Insight...................................................r...................................................r.........45 Podsumowanie ...................................................r...................................................r.................46 #,/-8 +7-+   Komentarze...................................................r...................................................r......................47 Nowości w zakresie procedur i funkcji...................................................r...............................48 Puste nagłówki wywołań ...................................................r..............................................48 Przeciążanie ...................................................r...................................................r...............49 Domyślne parametry...................................................r...................................................r..50 Zmienne ...................................................r...................................................r...........................51 Stałe ...................................................r...................................................r.................................52 Operatory ...................................................r...................................................r.........................55 Operator przypisania...................................................r...................................................r..55 Operatory porównania ...................................................r..................................................55 Operatory logiczne ...................................................r...................................................r....55 Operatory arytmetyczne ...................................................r...............................................56 Operatory bitowe ...................................................r...................................................r.......57 Operatory zwiększania i zmniejszania ...................................................r.........................57 Operatory „wykonaj i przypisz” ...................................................r...................................58 Typy języka Object Pascal...................................................r..................................................58 Porównanie typów ...................................................r...................................................r.....59 Znaki...................................................r...................................................r..........................59 Mnogość łańcuchów… ...................................................r.................................................59 Typy wariantowe ...................................................r...................................................r.......74 Typ Currency...................................................r...................................................r.............88 Typy definiowane przez użytkownika ...................................................r................................89 Tablice ...................................................r...................................................r.......................89 Rekordy ...................................................r...................................................r.....................93 Zbiory ...................................................r...................................................r........................94 Obiekty ...................................................r...................................................r......................97 Wskaźniki ...................................................r...................................................r..................98 Aliasy typów...................................................r...................................................r............101 Rzutowanie i konwersja typów...................................................r.........................................102 Zasoby łańcuchowe...................................................r...................................................r........104 Instrukcje warunkowe...................................................r...................................................r....104 Instrukcja If...................................................r...................................................r..............105 Instrukcja wyboru ...................................................r...................................................r....106 Pętle ...................................................r...................................................r...............................106 Pętla For...................................................r...................................................r...................106 Pętla While...Do...................................................r...................................................r.......107 Pętla Repeat...Until...................................................r...................................................r..108 Procedura Break()...................................................r...................................................r....108 Procedura Continue ()...................................................r.................................................109 Procedury i funkcje...................................................r...................................................r........110 Przekazywanie parametrów do procedur i funkcji ...................................................r.....111 Zasięg deklaracji ...................................................r...................................................r............118 Moduły...................................................r...................................................r...........................118 Dyrektywa uses...................................................r...................................................r........119 Cykliczna zależność między modułami ...................................................r.....................120 Pakiety ...................................................r...................................................r...........................122 Wykorzystywanie pakietów ...................................................r.......................................123 Składnia pakietu ...................................................r...................................................r......123 #4786/-  Programowanie zorientowane obiektowo...................................................r.........................123 Środowisko bazujące na obiektach kontra środowisko zorientowane obiektowo.........125 Wykorzystanie obiektów w Delphi...................................................r...................................126 Deklarowanie obiektów i kreowanie zmiennych obiektowych.....................................126 Destrukcja obiektu...................................................r...................................................r...127 Metody...................................................r...................................................r.....................127 Właściwości...................................................r...................................................r.............131 Widoczność elementów obiektu...................................................r.................................133 Wewnątrz obiektów...................................................r...................................................r.134 TObject — protoplasta wszystkich klas ...................................................r.....................135 Interfejsy...................................................r...................................................r..................136 Strukturalna obsługa wyjątków ...................................................r........................................141 Wyjątki jako klasy ...................................................r...................................................r...144 Wyjątki a przepływ sterowania w programie ...................................................r.............145 Ponowienie wyjątku ...................................................r...................................................r147 RTTI...................................................r...................................................r...............................148 Podsumowanie ...................................................r...................................................r...............149 3.+o  ,7o91+392+8’; 2.3;7   Natura komunikatów...................................................r...................................................r......151 Typy komunikatów ...................................................r...................................................r........152 Jak funkcjonuje system komunikatów Windows?...................................................r............152 Obsługa komunikatów w kategoriach Delphi...................................................r...................154 Struktury specyficzne dla różnych typów komunikatów ..............................................155 Przetwarzanie komunikatów...................................................r.............................................155 Kontraktowy charakter obsługi komunikatów ...................................................r...........157 Zwrotne przekazywanie wyniku obsługi komunikatu...................................................r158 Zdarzenie OnMessage klasy TApplication...................................................r.................159 Wysyłanie własnych komunikatów ...................................................r..................................159 Metoda Perform() ...................................................r...................................................r....160 Funkcje SendMessage() i PostMessage() ...................................................r...................160 Komunikaty niestandardowe ...................................................r............................................160 Komunikaty powiadamiające ...................................................r.....................................161 Wewnętrzne komunikaty VCL...................................................r...................................161 Komunikaty definiowane przez użytkownika ...................................................r............163 Anatomia systemu komunikatów VCL...................................................r.............................165 Związek komunikatów ze zdarzeniami Delphi...................................................r.................174 Podsumowanie ...................................................r...................................................r...............174 (cid:3) ++;+273;+2/+1+.2/2+463/83;/  3.+o  $;36/2/46/232/133.9   Założenia ogólne...................................................r...................................................r............179 Która wersja?...................................................r...................................................r...........179 Moduły, komponenty i pakiety...................................................r...................................181 Zmiany w środowisku IDE...................................................r.........................................181 Zgodność pomiędzy Delphi i Kyliksem ...................................................r...........................182 Nie w Linuksie...................................................r...................................................r.........183 Różnice między kompilatorami...................................................r..................................183 Indywidualne cechy platformy systemowej ...................................................r...............184 Nowości Delphi 6 ...................................................r...................................................r..........184 Definiowalne typy wariantowe...................................................r...................................185 Jawne wartościowanie elementów typu wyliczeniowego .............................................185 Dyrektywa $IF...................................................r...................................................r.........185 Możliwa niezgodność plików *.DFM ...................................................r........................185  /4  +.//-94630/732+78 $3 Migracja z Delphi 5 ...................................................r...................................................r.......185 Zmiana wartości stałych typowanych...................................................r.........................185 Negacja wartości typu Cardinal...................................................r..................................186 Migracja z Delphi 4 ...................................................r...................................................r.......186 Zmiany w zakresie biblioteki RTL...................................................r.............................186 Zmiany w bibliotece RTL...................................................r...........................................187 Zmiany w zakresie obsługi Internetu...................................................r..........................188 Zmiany w obsłudze baz danych...................................................r..................................188 Migracja z Delphi 3 ...................................................r...................................................r.......189 32-bitowe liczby całkowite bez znaku...................................................r........................189 64-bitowe liczby całkowite...................................................r.........................................190 Typ Real ...................................................r...................................................r..................190 Migracja z Delphi 2 ...................................................r...................................................r.......190 Zmiany w zakresie typów boolowskich ...................................................r.....................191 Dyrektywa resourcestring...................................................r...........................................191 Zmiany w bibliotece RTL...................................................r...........................................192 Klasa TCustomForm...................................................r...................................................r192 Metoda GetChildren()...................................................r.................................................192 Serwery automatyzacji ...................................................r...............................................193 Migracja z Delphi 1 ...................................................r...................................................r.......193 Znaki i łańcuchy ...................................................r...................................................r......193 Rozmiar i zakres zmiennych...................................................r.......................................201 Wyrównywanie pól rekordów ...................................................r....................................201 32-bitowa arytmetyka ...................................................r.................................................202 Różnice dotyczące typu TDateTime...................................................r...........................203 Sekcja finalization ...................................................r...................................................r...203 Język asemblera...................................................r...................................................r.......204 Biblioteki DLL ...................................................r...................................................r........205 Zmiany związane z systemem operacyjnym ...................................................r..............206 Podsumowanie ...................................................r...................................................r...............210 3.+o  4+-/;/3;83;/   Natura wątków...................................................r...................................................r...............211 Rodzaje wielozadaniowości ...................................................r.......................................211 Do czego może się przydać wielowątkowość?...................................................r...........212 Wielowątkowość a komponenty VCL...................................................r........................212 Błędne wykorzystanie wielowątkowości...................................................r....................213 Klasa TThread...................................................r...................................................r................213 Obiekty wątków a zmienne ...................................................r........................................216 Kończenie wątku ...................................................r...................................................r.....216 Synchroniczne wykorzystywanie komponentów VCL .................................................218 Przykładowa aplikacja wielowątkowa...................................................r........................221 Priorytety i szeregowanie wątków...................................................r..............................222 Zawieszanie i wznawianie wątków ...................................................r............................225 Pomiar czasu w ramach wątku ...................................................r...................................225 Współdziałanie wątków aplikacji ...................................................r.....................................228 Pamięć lokalna wątku...................................................r.................................................228 Synchronizacja wątków...................................................r..............................................232 Przykład zastosowania wielowątkowości: zaawansowane wyszukiwanie tekstu ...............244 Interfejs użytkownika ...................................................r.................................................245 Proces przeszukiwania...................................................r................................................251 Zmiana priorytetu wątku przeszukującego...................................................r.................256 Wielowątkowy dostęp do BDE...................................................r.........................................257 3.+o #4786/-  Wielowątkowe operacje graficzne...................................................r....................................263 Włókna...................................................r...................................................r...........................267 Podsumowanie ...................................................r...................................................r...............273 ,38/   Czym w istocie jest biblioteka DLL ...................................................r.................................275 Bazowy adres ładowania modułu ...................................................r...............................276 Nieco terminologii…...................................................r..................................................277 Łączenie statyczne kontra łączenie dynamiczne...................................................r...............278 Korzyści płynące z używania DLL...................................................r...................................279 Współdzielenie kodu, zasobów i danych przez wiele aplikacji.....................................279 Ukrycie szczegółów implementacyjnych ...................................................r...................280 Tworzenie i wykorzystywanie bibliotek DLL ...................................................r..................281 Prosty przykład — poznaj siłę swych pieniędzy ...................................................r........281 Formularze modalne w bibliotekach DLL...................................................r..................283 Formularze niemodalne w bibliotekach DLL...................................................r.............285 Wykorzystywanie bibliotek DLL w aplikacjach Delphi ...................................................r..287 Automatyczne ładowanie biblioteki DLL ...................................................r..................287 Ładowanie biblioteki DLL na żądanie ...................................................r.......................289 Procedura inicjująco-kończąca biblioteki DLL ...................................................r................291 Definiowanie procedury inicjująco-kończącej ...................................................r...........291 Obsługa wyjątków w bibliotekach DLL...................................................r...........................296 Wyjątki a klauzula Safecall ...................................................r........................................297 Funkcje zwrotne...................................................r...................................................r.............297 Działanie funkcji zwrotnej...................................................r..........................................300 Specyficzne wyświetlanie elementów listy ...................................................r................301 Wywoływanie funkcji zwrotnych z bibliotek DLL...................................................r....301 Współdzielenie danych biblioteki DLL przez różne procesy ..............................................303 Tworzenie bibliotek DLL z pamięcią dzieloną ...................................................r..........304 Dzielenie globalnych danych biblioteki przez aplikacje ...............................................307 Eksportowanie obiektów z bibliotek DLL...................................................r........................310 Podsumowanie ...................................................r...................................................r...............314 (cid:3) 6316+3;+2/3,7o91,+.+2-   3.+o  +3.+23;++6-8/896+/4    Typy baz danych...................................................r...................................................r............317 Architektura bazy danych ...................................................r.................................................318 Połączenia z serwerami baz danych...................................................r..................................318 Zbiory danych ...................................................r...................................................r................319 Otwieranie i zamykanie zbioru danych ...................................................r......................320 Nawigowanie wśród rekordów zbioru danych ...................................................r...........323 Manipulowanie zawartością zbioru danych ...................................................r...............326 Pola rekordu bazy danych...................................................r.................................................331 Wartości pól...................................................r...................................................r.............331 Typy pól...................................................r...................................................r...................332 Nazwy i numery pól ...................................................r...................................................r332 Operowanie zawartością pól...................................................r.......................................333 Edytor pól ...................................................r...................................................r................334 Pola typu BLOB ...................................................r...................................................r......340 Filtrowanie danych..................................r...................................................r..........................345 Przeszukiwanie zbiorów danych...................................................r.......................................346 FindFirst() i FindNext() ...................................................r..............................................347 Lokalizowanie rekordu za pomocą metody Locate() ...................................................r.347 Przeszukiwanie tabeli za pomocą indeksów...................................................r...............348  /4  +.//-94630/732+78 $3 3.+o  3.+o  Moduły danych ...................................................r...................................................r..............352 Wyszukiwanie, zakresy, filtrowanie ...................................................r.................................352 Zakładki ...................................................r...................................................r.........................360 Podsumowanie ...................................................r...................................................r...............361 $;36/2/+4+-,+3.+23;- +433-8/-2331.,46/77   Specyfika technologii dbExpress...................................................r......................................363 Jednokierunkowe zbiory danych tylko do odczytu ...................................................r....363 dbExpress kontra BDE ...................................................r...............................................364 dbExpress a aplikacje międzyplatformowe ...................................................r................364 Komponenty dbExpress...................................................r...................................................r.364 TSQLConnection...................................................r...................................................r.....364 TSQLDataSet...................................................r...................................................r...........367 Komponenty kompatybilne ...................................................r........................................371 TSQLMonitor ...................................................r...................................................r..........372 Edytowalne, dwukierunkowe zbiory danych dbExpress ...................................................r..372 TSQLClientDataSet...................................................r...................................................r.372 Realizacja aplikacji dbExpress ...................................................r.........................................373 Podsumowanie ...................................................r...................................................r...............373 $;36/2/+4+-,+3.+23;-+433-.,3036  Strategia uniwersalnego dostępu do danych ...................................................r.....................375 OLE DB, ADO i ODBC w zarysie ...................................................r...................................375 Wykorzystanie technologii dbGo for ADO ...................................................r......................376 Ustanawianie połączenia z bazą danych za pomocą dostawcy OLE DB ......................376 Przykładowa baza danych ...................................................r..........................................378 Komponenty dbGo for ADO ...................................................r............................................378 Przetwarzanie transakcyjne...................................................r...............................................384 Podsumowanie ...................................................r...................................................r...............386 (cid:3)  63/83;+2/;3678;+2/3432/28 ;  3.+o  6-8/896+3432/28’;   CLX — odsłona pierwsza...................................................r.................................................389 Co to jest komponent? ...................................................r...................................................r...389 Hierarchia komponentów...................................................r..................................................390 Komponenty niewizualne ...................................................r...........................................390 Komponenty wizualne...................................................r................................................391 Struktura komponentu...................................................r...................................................r....393 Właściwości komponentu...................................................r...........................................394 Metody...................................................r...................................................r.....................396 Zdarzenia ...................................................r...................................................r.................397 Komponenty jako właściciele innych komponentów...................................................r.399 Komponenty rodzicielskie...................................................r..........................................400 Hierarchia komponentów wizualnych ...................................................r..............................400 Klasa TPersistent ...................................................r...................................................r.....401 Klasa TComponent ...................................................r...................................................r..402 Klasa TControl ...................................................r...................................................r........404 Klasy TWinControl i TWidgetControl...................................................r.......................404 Klasa TGraphicControl...................................................r...............................................406 Klasy kategorii TCustom…...................................................r........................................406 Pozostałe klasy ...................................................r...................................................r........407 #4786/-  Wykorzystanie informacji RTTI...................................................r.......................................410 Informacja o genealogii i zestawie właściwości klasy ..................................................411 Przypisywanie właściwościom wartości za pośrednictwem RTTI................................433 Podsumowanie ...................................................r...................................................r...............436 3.+o  $;36/2/3432/28’;    Podstawy tworzenia komponentów ...................................................r..................................438 Czy tworzenie nowego komponentu w ogóle jest konieczne? ......................................438 Etapy tworzenia nowego komponentu ...................................................r.......................439 Rejestrowanie komponentu ...................................................r........................................460 Testowanie komponentu...................................................r.............................................461 Wybór ikony dla komponentu ...................................................r....................................463 Przykładowe komponenty...................................................r.................................................464 Rozszerzenia kontrolek Win32...................................................r...................................464 Komponent TddgRunButton ...................................................r......................................473 Komponenty-pojemniki — TddgButtonEdit ...................................................r....................478 Koncepcja ...................................................r...................................................r................479 Definiowanie właściwości...................................................r..........................................479 Definiowanie zdarzeń ...................................................r.................................................480 TddgDigitalClock — jeszcze jeden przykład definiowania zdarzeń.............................482 Umieszczanie kompletnych formularzy w palecie komponentów ................................485 Podsumowanie ...................................................r...................................................r...............487 3.+o  ++;+273;+2/8/-28;36/2+3432/28’;  Komponenty pseudowizualne...................................................r...........................................489 Niestandardowe podpowiedzi kontekstowe ...................................................r...............489 Animowane komponenty...................................................r..................................................493 Komponent TddgMarquee...................................................r..........................................494 Testowanie komponentu TddgMarquee ...................................................r.....................504 Tworzenie edytorów właściwości...................................................r.....................................506 Definiowanie nowej klasy edytora..................................................r.....................................506 Edycja właściwości w postaci linii tekstu ...................................................r..................508 Rejestracja nowego edytora właściwości ...................................................r...................512 Edycja właściwości za pomocą okna dialogowego...................................................r....512 Edytory komponentów...................................................r...................................................r...516 TComponentEditor ...................................................r...................................................r..516 TDefaultEditor...................................................r...................................................r.........517 Przykład edycji komponentu ...................................................r......................................517 Rejestracja edytora komponentu ...................................................r................................519 Przechowywanie w strumieniach niepublikowanych danych komponentu.........................520 Określenie strumieniowalnego charakteru właściwości................................................520 Kategoryzacja właściwości...................................................r...............................................530 Klasy kategorii właściwości ...................................................r.......................................531 Kolekcje komponentów — klasy TCollection i TCollectionItem .......................................535 Przykładowy element kolekcji — klasa TRunBtnItem .................................................537 TRunButtons — kolekcja komponentu ...................................................r......................537 Implementacja — współpraca kolekcji i jej elementów z komponentem macierzystym ...................................................r................................538 Edycja kolekcji i jej elementów w dialogowym edytorze właściwości ........................545 Podsumowanie ...................................................r...................................................r...............550 3.+o   3432/28#.4+80363;/   CLX — co to jest? ...................................................r...................................................r.........551 Architektura CLX ...................................................r...................................................r..........552  /4  +.//-94630/732+78 $3 Z Windows do Linuksa...................................................r...................................................r..555 Nie ma komunikatów…...................................................r..............................................555 Przykładowe komponenty ...................................................r..........................................556 Edytory środowiskowe CLX ...................................................r............................................585 Pakiety ...................................................r...................................................r...........................589 Konwencje nazewnicze ...................................................r..............................................590 Pakiety wykonywalne...................................................r.................................................591 Pakiety środowiskowe ...................................................r................................................593 Ikony komponentów ...................................................r...................................................r......596 Podsumowanie ...................................................r...................................................r...............597 3.+8 .  3.+8/ #6’-3274786/-839   #363;.     Rozdział 13. Trzy poprzednie rozdziały poświęcone były architekturze i projektowaniu komponen- tów VCL, przeznaczonych dla platformy MS Windows. W niniejszym rozdziale zaj- miemy się podstawami projektowania komponentów CLX, umożliwiających tworzenie aplikacji zarówno dla Windows, jak i dla Linuksa. Tak się szczęśliwie składa, iż znacz- na część umiejętności nabyta podczas projektowania komponentów VCL okaże się przydatna również w odniesieniu do komponentów CLX. CLX — wymawiane najczęściej jako „clicks” — to akronim od Component Library for Cross-Platform, czyli „międzyplatformowej biblioteki komponentów”; pojawił się po raz pierwszy w związku z Kyliksem — wywodzącym się z Delphi narzędziem typu RAD dla Linuksa. Biblioteka CLX jest jednak czymś więcej niż tylko adaptacją VCL na gruncie Linuksa: jej obecność w Delphi 6 umożliwia (po raz pierwszy w historii Delphi) przekroczenie granic Windows i tworzenie aplikacji zgodnych zarówno z Del- phi, jak i Kyliksem. Ponadto biblioteka VCL (w Delphi) utożsamiana bywa raczej z komponentami wizual- nymi (również w nazwie), co nie powinno dziwić wobec faktu, iż komponenty te sta- nowią większą jej część (i jednocześnie lwią część palety komponentów). Tymczasem architektura CLX jest nieco bardziej złożona, bo oprócz wizualnych komponentów grupy 79+ zawiera także komponenty +7/, +8+ i /8. +7/ to grupa klas i modułów wspólnych dla Delphi 6 i Kyliksa — należą do niej m.in. moduły #78/, #7 87 i +77/7, określane w Delphi (od początku) mianem biblioteki RTL. Mimo iż moduły te stanowić mogą składniki aplikacji obydwu typów — VCL i CLX — za aplikację CLX zwykło się uważać taką, której strona wizualna zrealizowana została na podstawie klas grupy 79+. 79+ stanowi odmianę tego, co większość programistów skłonna jest uważać (w Delphi) za VCL, jednak oparta jest nie na standardowych kontrolkach Windows  (cid:5) K 63/83;+2/;3678;+2/3432/28(cid:26); z bibliotek 7/6  czy 38 , lecz na tzw. widżetach1 zawartych w bibliote- ce !8. Do grupy +8+ zaliczają się komponenty zapewniające dostęp do danych za pomocą nowej technologii .,46/77, natomiast nowe, międzyplatformowe oblicze WebBrokera ucieleśniają komponenty grupy /8. W niniejszym rozdziale skoncentrujemy się głównie na 79+, ze szczególnym uwzględnieniem tworzenia nowych komponentów na bazie tej architektury. Opiera się ona (jak już wcześniej wspominaliśmy) na bibliotece !8 („cute”) firmy Troll Tech, sta- nowiącej niezależną od konkretnej platformy bibliotekę klas C++, realizujących funk- cjonalność widżetów składających się na interfejs użytkownika. Ściślej — w chwili obecnej biblioteka !8 zawiera elementy charakterystyczne dla środowisk MS Windows oraz X Window System, może więc być wykorzystywana zarówno na potrzeby aplika- cji windowsowych, jak i linuksowych; na jej podstawie zrealizowano właśnie linukso- wy menedżer okien KDE. Biblioteka !8 nie jest bynajmniej jedyną dostępną międzyplatformową biblioteką klas; to, iż Borland zdecydował się właśnie na nią, wynika z kilku istotnych przyczyn. Po pierwsze, jej klasy podobne są w dużym stopniu do klas komponentów VCL — na przykład ich właściwości zrealizowane zostały z udziałem metod dostępowych /8(cid:31) xxxx/#/8xxxx, po drugie — wykorzystują podobny do VCL mechanizm powiadamiania o zdarzeniach (tzw. sygnały). Wreszcie po trzecie — jej widżety to nic innego jak stan- dardowe kontrolki interfejsu użytkownika, spełniające tę samą rolę co standardowe kontrolki Windows. To wszystko pozwoliło na stworzenie komponentów biblioteki CLX przez „nadbudowanie” pascalowych otoczek wokół gotowych widżetów — za- miast budowania całej architektury „od zera”. Jak przed chwilą stwierdziliśmy, 79+ jest grupą klas Object Pascala zbudowanych na bazie funkcjonalności widżetów biblioteki !8 — co stanowi analogię do komponentów VCL zbudowanych na bazie standardowych kontrolek Windows i biblioteki Windows API. Podobieństwo to nie jest bynajmniej przypadkowe, lecz wynika z jednego z celów projektowych: łatwości przystosowywania istniejących aplikacji VCL do architektury CLX. Rysunki 13.1 i 13.2 przedstawiają hierarchiczną strukturę klas w obydwu tych środowiskach; przyciemnione prostokąty na rysunku 13.1 wynróżniają podstawowe klasy biblioteki VCL. Już na pierwszy rzut oka widać różnicę pomiędzy obydwiema hierarchiami — w archi- tekturze CLX pojawiły się nowe (w stosunku do VCL) klasy, niektóre zostały przesu- nięte do innych gałęzi. Różnice te zaznaczone zostały na rysunku 13.2 za pomocą rozja- śnionych prostokątów. I tak, na przykład, komponent zegarowy ($$/6) nie wywodzi się już bezpośrednio z klasy $3432/28, lecz z nowej klasy $+2./3432/28, stano- wiącej klasę bazową do obsługi wszystkich tych przypadków, gdy komponent niewizu- alny wymaga dostępu do uchwytu (handle) jakiejś kontrolki !8. Innym przykładem jest etykieta $+,/, nie będąca już kontrolką graficzną, lecz wywodząca się z klasy $6+/(cid:31) 32863, która wykorzystuje różnorodne możliwości kształtowannia obrzeża widżetów !8. To spolszczona postać angielskiego terminu widget, który jest zlepkiem słów Visual Gadget — przyp. tłum. 1 3.+o  K3432/28(cid:5).4+80363;/  792/  Hierarchia klas VCL Nieprzypadkowe jest także podobieństwo nazw klas bazowych kontrolek wizualnych — $ 232863 (VCL) i $ .1/832863 (CLX): charakterystyczny dla Windows człon „Win” ustąpił miejsca charakterystycznemu dla CLX „Widget”. Mając na względzie łatwość przenoszenia kodu źródłowego Borland zdefiniował klasę $ 232863 także w bibliotece CLX, stanowi ona jednak tylko synonim klasy $ .1/832863. Można było oczywiście uniknąć tej nieco mylącej w skutkach (zwłaszcza dla nieświadomego użytkownika) operacji i utworzyć dwa oddzielne moduły dla obydwu grup kontrolek, a później odróżniać je za pomocą symboli kompilacji warunkowej; utrudniłoby to jed- nak przenoszenie kodu źródłowego (identyfikator $ 232863 straciłby rację bytu, a jego systematyczna zmiana na $ .1/832863 wymagałaby dodatkowej fatygi), zaś w apli- kacjach międzyplatformowych konieczne byłoby utrzymywanie dwóch identyfikatorów na oznaczenie klasy bazowej kontrolek.  (cid:5) K 63/83;+2/;3678;+2/3432/28(cid:26); Zwróć uwagę, iż utrzymywanie w pojedynczym pliku koędu dla obydwu typów komponentów (VCL i CLX) jest czymś jakościowo różnym oęd tworzenia kodu uniwersalnego komponentu CLX, dającego się użyć zarównęo w Delphi 6, jak i w Kyliksie (takimi komponentami zajmiemy się w dalszej części rozdziału). 792/   Hierarchia klas CLX Na szczęście różnice przedstawione na rysunku 13.2 nie mają zbyt dużego znaczenia dla twórców aplikacji, ponieważ większość komponentów VCL posiada na gruncie CLX identycznie nazwane odpowiedniki. Nie mają jednak takiego szczęścia twórcy nowych komponentów — zmiany w hierarchii klas mają dla nich znaczenie znasadnicze. Strukturę hierarchii klas można łatwo zobaczyć za pomoęcą przeglądarki obiektów (Object Browser) w Delphi 6 i w Kyliksie; jednak ze względu na synonim ę$ 232863, uzyskamy dwie identyczne hierarchie (dla $ .1/832863 i $ 232863). Pomiędzy VCL i CLX istnieje jeszcze więcej podobieństw, których nie sposób uwzględnić na przedstawionych rysunkach. Na przykład znane z VCL płótno (+2:+7) ma w CLX niemal identyczną naturę i wykorzystywane jest w bardzo zbliżony sposób, 3.+o  K3432/28(cid:5).4+80363;/  choć oczywiście różnice pomiędzy obydwoma środowiskami przesądzają o jego odmiennej implementacji: w VCL jest ono otoczką kontekstu urządzenia, zaś w CLX — analogicznego mechanizmu zwanego malarzem (painter), mimo to obydwa te me- chanizmy reprezentowane są przez tę samą właściwość +2./. Ponadto, z uwagi na wymóg łatwości przenoszenia kodu, niemal identycznie wyglądają interfejsy komponentów w obydwu grupach — pod względem repertuaru właściwości publicznych (49,-) i publikowanych (49,7/.) oraz zdarzeń (2-, 2+21/, 2/ 6/77) i ich metod dyspozycyjnych (--., +21/-. i / 6/77-.). Mimo wielu podobieństw pomiędzy analogicznymi elementami komponentów VCL i CLX, istniejące między tymi środowiskami różnice dają znać o sobie tym wyraźniej, im bliż- sza staje się zależność konkretnego elementu od mechaninzmu charakterystycznego tylko dla jednego ze środowisk. I tak, w środowisku Kyliksa traci sens większość odwołań do Win32 API; mechanizmy typowe jedynie dla Windows — jak np. MAPI — muszą być zastąpione równoważnymi mechanizmami linuksowymi, a używające ich komponenty nie nadają się po prostu do przeniesienia na platformę linuksową. Z kolei niektóre problemy rozwiązywane przez funkcje biblioteki RTL muszą być rozwiązane w inny sposób — przykładem może być czułość Linuksa na wielkość liter w nazwach plików; Pascal, niewrażliwy na wielkość liter w identyfikatorach, staje się pod Kyliksem wraż- liwy na wielkość liter w nazwach modułów w dyrektywach 97/7! Linux pozbawiony jest też wielu znanych z Windows mechanizmów systemowych — nie ma tu technologii COM, są jednak obsługiwane interfejsy; nie ma też dokowania okien, „dwukierunkowej” (bidirectional) obsługi tekstu, lokalizowania charakterystycz- nego dla krajów azjatyckich itp. Pewnym problemem dla autorów aplikacji i komponentów jest istnienie oddzielnych modułów, dedykowanych tylko określonym platformom, na przykład kod kontrolek win- dowsowych znajduje się w pliku Controls.pas, zaś kod dla widżetów CLX — w pliku QControls.pas. Stwarza to możliwość „pomieszania” obydwu środowisk w sytuacji, gdy komponent CLX lub aplikacja przeznaczona dla Kyliksa opracowywane są w śro- dowisku Delphi 6. Tak skonstruowany komponent, jeżeli zawiera elementy typowe wyłącznie dla VCL, będzie bez problemu pracował w Delphi 6, najczęściej jednak od- mówi współpracy pod Kyliksem. Można uniknąć takiej sytuacji, gdy, za radą Borlanda, komponenty i aplikacje przeznaczone dla Kyliksa będziemy opracowywać pod Kylik- sem — niestety, środowisko Kyliksa jest (w zgodnej opinii programistów) mniej kom- fortowe od Delphi 6. Wobec opisanych konsekwencji różnic pomiędzy VCL i CLXę, nie wydaje się uzasadnione używanie komponentów CLX w aplikacjach przeznaczonycęh wyłącznie dla Windows. /+392+8(cid:12); Linux (a raczej — podsystem  2.3;) nie implementuje typowego dla Windows me- chanizmu komunikatów; w efekcie nie do zaakceptowanina jest w Kyliksie kod źródłowy  (cid:5) K 63/83;+2/;3678;+2/3432/28(cid:26); odwołujący się do identyfikatorów w rodzaju ;)988323;2, ;)#/896736 czy ;)+6. Reagowaniem na zachodzące w systemie zdarzenia zajmują się w bibliotece !8 wyspe- cjalizowane klasy — dzieje się tak niezależnie od platformy systemowej, tak więc kom- ponent CLX nie jest zdolny reagować na komunikaty nawet pod Windows; zamiast znanych z Delphi metod z klauzulą /77+1/ (np. $/8+21/.-.), powinien on korzy- stać z równoważnych metod dynamicznych ($/8+21/.-.), co wyjaśnimy dokładniej w następnym punkcie. 6o+.3;/3432/28 W niniejszym punkcie przyjrzymy się nieco dokładniej przykładom transformacji kom- ponentów VCL na równoważne komponenty CLX. Na początek zajmiemy się popular- nym „spinerem” — to pomocniczy komponent współpracujący najczęściej z polem edycyjnym, dokonujący jego automatycznej inkrementacji lub dekrementacji; realizuje on wiele interesujących mechanizmów (jak specyficzne rysowanie), współpracę z kla- wiaturą i myszą, przyjmowanie i utratę skupienia (focus) itp. Trzy kolejne komponenty to pochodne bazowego spinera. Pierwszy z nich wzbogacony jest o obsługę myszy i wyświetlanie specyficznych kursorów już na etapie projektowa- nia, drugi realizuje współpracę z listą obrazków (+1/78), trzeci natomiast współpra- cuje z kontrolką reprezentującą pole bazy danych. Wszystkie prezentowane w tym rozdziale moduły nadają sięę do wykorzystania zarówno w Delphi 6, jak i w Kyliksie. 3.78+;+3432/28$..1#422/6 Rysunek 13.3 przedstawia trzy egzemplarze komponentu $..1#422/6 na formularzu aplikacji CLX. W odróżnieniu od pionowo ułożonych strzałek, charakterystycznych dla windowsowego spinera, komponent ten posiada odpowiednie przyciski w układzie po- ziomym: inkrementujący i dekrementujący. 792/   Komponent TddgSpinner pomocny przy wprowadzaniu liczb całkowitych Wydruk 13.1 przedstawia kompletny kod źródłowy modułu !..1#42 4+7 implementu- jącego komponent $..1#422/6. Podobnie jak spiner windowsowy, wywodzi się on z klasy $978332863 — tyle że w tym przypadku jest to klasa CLX i komponent mo- że być używany zarówno w Windows, jak i pod Linuksem. 3.+o  K3432/28(cid:5).4+80363;/  Choć migracja na platformę CLX rzadko wiąże się ze zmianą nazw komponentów, to jednak zasadą jest poprzedzanie nazwy modułu VCL literą ! dla podkreślenia zależno- ści tegoż modułu od biblioteki !8. Każdy z prezentowanych wydruków zawiera „wykomentowanęe” linie stanowiące część kodu VCL; komentarze oznaczone dodatkowo jako  podkreślają elementy specyficzne dla przenoszenia komponentu z VCL do CLX. .69  QddgSpin.Pas — kod pródłowy komponentu TddgSpinner 2 !..1#42 2/73.9o4//289/3432/28$..1#422/26,,38/(cid:30) +;/6+-43339o3 32/46-7/2+-/;463;2+.+2;+683  ;3.6’ 2/293.;2.3;73;/13742/6+437+.+-/1342323;39o3 32/ 786+o( 3432/288/2;;3.7+,3;/;/67$978332863 ./327869/;//28/6/79--3 ;3-(cid:30)+463;+2/986+8+ 794/2+(cid:30)74/-0-2/673;+2/;74’o46+-+7 34618 , +3234+ 2 928!..1#42 28/60+-/ 97/7 #7 87(cid:30)+77/7(cid:30)$4/7(cid:30)!8(cid:30)!328637(cid:30)!6+4-7  8  2.3;7(cid:30)/77+1/7(cid:30)#7 87(cid:30)+77/7(cid:30)6+4-7(cid:30)3286327(cid:30)367(cid:30) 178 8( 84/ $..198832$4/ ,8297(cid:30),8 97( $..1#422/6:/28463-/.96/ #/2./6$,/-8/; +9/228/1/6 :+63;+21/33/+22(303,/-8 $..1#422/6-+77 $978332863( 46:+8/   3+3432/289  +9/28/1/6 2-6//2828/1/6 98832336$336 98832 .828/1/6 297823;233/+2  97823;233/+2   7+ 2.3463-/.96.+6/23;- 2+21/$380:/28 2+2121$..1#422/6:/28  8   ,432 7//83.392+-2/2/7.3278+42/;  ,7o91+392+89 2.3;7 463-/.96/ /813./ :+671$ /813./(  (cid:5) K 63/83;+2/;3678;+2/3432/28(cid:26); /77+1/;)/813./  ,7o91+392+893432/289 463-/.96/2+,/.+21/. :+671$/77+1/( /77+1/-)2+,/.+21/. 8( 4638/-8/. 463-/.96/ +283:/66./ 463-/.96/6+;98832 98832$..198832$4/3;233/+2 392.7$ /-8(:689+  /83.3,7o91 463-/.96//- +9/ 392828/1/6(:689+ 463-/.96/2- +9/ 392828/1/6(:689+ 092-83296736 37832$ 328 092-832397/:/698832 82$..198832$4/(33/+22   ,2+,/.+21/.+78+49//83.+392+2-2  -)2+,/.+21/.  463-/.96/2+,/.+21/.3:/66./  3;//83.3,7o91.+6/q 463-/.96/+21/.2+- 092-832+2+21/ /; +9/28/1/6(33/+2.2+2-  46/./023;+2//83.3,7o91.+6/q 463-/.96/328/63:/66./ 463-/.96/383:/66./ 463-/.96//3;2 :+6/ 36.#08$#08#8+8/(3:/662./ 463-/.96/397/3;2 98832$397/98832#08$#08#82+8/ (cid:30)28/1/6(3:/66./ 463-/.96/397/ 4 98832$397/98832#08$#08#8+28/ (cid:30)28/1/6(3:/66./  8   ,432 7/./+6+-/378+o/232/; 092-8323397/ //3;2 #08$#08#8+8/ 397/ 37$ 328(33/+223:/66./ 092-8323397/ // 4 #08$#08#8+8/ 397/ 37$ 328(33/+23:/66./ 8( 092-8323397/ //3;2 #08$#08#8+8/ -3278397/ 37$ 328(33/+223:/66./ 092-8323397/ // 4 #08$#08#8+8/ -3278397/ 37$ 328(33/+23:/66./  /83..378+43;/;o+-;3- 463-/.96/#/898832336  +9/$336(:689+ 463-/.96/#/898832 .8  +9/28/1/6(:689+ 463-/.96/#/8 +9/  +9/28/1/6(:689+ 49,- 3.+o  K3432/28(cid:5).4+80363;/   /+4323+993:/66./;3278698362/ -327869-8366/+8/ ;2/6$3432/28(3:/66./ 49,7/.  3;/./+6+-/;o+-;3
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Delphi 6. Vademecum profesjonalisty. Tom I
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: