Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00057 009073 11061254 na godz. na dobę w sumie
ABC Delphi 6 - książka
ABC Delphi 6 - książka
Autor: Liczba stron: 136
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-504-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> delphi - programowanie
Porównaj ceny (książka, ebook, audiobook).
Delphi 6 to kolejna wersja popularnego środowiska programistycznego firmy Borland, służącego do szybkiego tworzenia aplikacji za pomocą języka ObjectPascal. W Delphi napisano już wiele profesjonalnych aplikacji, co nie oznacza, iż jest ono środowiskiem wyłącznie dla zawodowców. Wręcz przeciwnie, dzięki prostocie obsługi i zaletom wzorowanego na Pascalu języka ObjectPascal, jest ono doskonałym narzędziem dla początkujących programistów, także dla tych, którzy nie mieli wcześniej wiele wspólnego z programowaniem obiektowym.

Dla nich właśnie przeznaczona jest ta książka omawiająca:

Pomocą w zgłębianiu tajników Delphi 6 jest 19 kompletnych przykładowych projektów, ilustrujących najważniejsze ćwiczenia. Po przeczytaniu 'ABC Delphi 6', będziesz mógł samodzielnie pisać aplikacje działające w środowisku Windows. Książka stanowi także doskonały wstęp do innych, bardziej zaawansowanych pozycji, omawiających Delphi.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI ABC Delphi 6 KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG Autor: Andrzej Daniluk ISBN: 83-7197-504-X Format: B5, stron: 136 Przyk³ady na ftp: 1002 kB TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Delphi 6 to kolejna wersja popularnego ġrodowiska programistycznego firmy Borland, s³u¿¹cego do szybkiego tworzenia aplikacji za pomoc¹ jêzyka ObjectPascal. W Delphi napisano ju¿ wiele profesjonalnych aplikacji, co nie oznacza, i¿ jest ono ġrodowiskiem wy³¹cznie dla zawodowców. Wrêcz przeciwnie, dziêki prostocie obs³ugi i zaletom wzorowanego na Pascalu jêzyka ObjectPascal, jest ono doskona³ym narzêdziem dla pocz¹tkuj¹cych programistów, tak¿e dla tych, którzy nie mieli wczeġniej wiele wspólnego z programowaniem obiektowym. Dla nich w³aġnie przeznaczona jest ta ksi¹¿ka omawiaj¹ca: • Podstawy programowania w jêzyku ObjectPascal • Projektowanie zorientowane obiektowo (OOD) • Zintegrowane ġrodowisko programistyczne • ObjectPascal w wydaniu Delphi 6 • Biblioteki VCL i CLX • Tworzenie w³asnych komponentów • Biblioteki DLL Pomoc¹ w zg³êbianiu tajników Delphi 6 jest 19 kompletnych przyk³adowych projektów, ilustruj¹cych najwa¿niejsze æwiczenia. Po przeczytaniu „ABC Delphi 6”, bêdziesz móg³ samodzielnie pisaæ aplikacje dzia³aj¹ce w ġrodowisku Windows. Ksi¹¿ka stanowi tak¿e doskona³y wstêp do innych, bardziej zaawansowanych pozycji, omawiaj¹cych Delphi. Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp ...................................................z............................................ 5 Rozdział 1. Elementarz Object Pascala...................................................z.............. 7 Moduły ...................................................r...................................................r..........................7 Program główny ...................................................r...................................................r............8 Stałe...................................................r...................................................r.............................10 Zmienne...................................................r...................................................r.......................11 Typy całkowite...................................................r...................................................r............12 Typy rzeczywiste...................................................r...................................................r.........12 Typ Currency.......................................r...................................................r...........................13 Typy logiczne...................................................r...................................................r..............13 Typy znakowe ...................................................r...................................................r.............13 Typy łańcuchowe ...................................................r...................................................r........14 Literały łańcuchowe ...................................................r...................................................r....14 Tablice...................................................r...................................................r.........................15 Rekordy ...................................................r...................................................r.......................16 Typ okrojony ...................................................r...................................................r...............18 Typ mnogościowy ...................................................r...................................................r.......18 Typ wyliczeniowy ...................................................r...................................................r.......19 Typ Variant ...................................................r...................................................r.................19 Operatory...................................................r...................................................r.....................20 Wskazania i adresy...................................................r...................................................r......21 Instrukcje sterujące przebiegiem programu ...................................................r...................22 Instrukcja warunkowa If...Then ...................................................r...............................22 Instrukcja warunkowa Case...Of ...................................................r..............................23 Instrukcja iteracyjna Repeat...Until ...................................................r.........................24 Instrukcja iteracyjna While...Do ...................................................r..............................25 Instrukcja iteracyjna For...To...Do ...................................................r...........................26 Procedura przerwania programu Break ...................................................r...................26 Procedura przerwania programu Exit ...................................................r......................27 Procedura wyjścia z programu Halt ...................................................r.........................27 Procedura zatrzymania programu RunError ...................................................r............27 Procedura kontynuacji programu Continue ...................................................r.............28 Procedury ...................................................r...................................................r....................28 Parametry formalne...................................................r..................................................29 Funkcje ...................................................r...................................................r........................31 Moduły na poważnie ...................................................r...................................................r...32 Podsumowanie ...................................................r...................................................r............34 4 ABC Delphi 6 Rozdział 2. Projektowanie obiektowe OOD ...................................................z...... 35 Klasa ...................................................r...................................................r.....................35 Obiekt...................................................r...................................................r....................35 Metody ...................................................r...................................................r..................36 Widoczność obiektów ...................................................r..............................................36 Współdziałanie obiektów...................................................r.........................................36 Implementacja obiektu...................................................r.............................................36 Dziedziczenie ...................................................r...................................................r........36 Podsumowanie ...................................................r...................................................r............36 Rozdział 3. Środowisko programisty — IDE ...................................................z..... 37 Biblioteka VCL ...................................................r...................................................r...........39 Karta Standard ...................................................r...................................................r......40 Karta Additional...................................................r...................................................r....41 Karta Win32...................................................r...................................................r..........43 Karta System ...................................................r...................................................r.........45 Karta Dialogs ...................................................r...................................................r........46 Biblioteka CLX ...................................................r...................................................r...........47 Karta Additional...................................................r...................................................r....48 Karta Dialogs ...................................................r...................................................r........48 Podsumowanie ...................................................r...................................................r............48 Rozdział 4. Object Pascal w wydaniu Delphi ...................................................z.... 49 Formularz ...................................................r...................................................r....................49 Zdarzenia...................................................r...................................................r.....................51 Wykorzystujemy własne funkcje i procedury ...................................................r................56 Metody przeciążane...................................................r...................................................r.....58 Wyjątki ...................................................r...................................................r........................60 Operacje na plikach...................................................r...................................................r.....65 Strukturalna obsługa wyjątków...................................................r......................................71 Tablice otwarte...................................................r...................................................r............72 Tablice dynamiczne...................................................r...................................................r.....73 Typ OleVariant...................................................r...................................................r............74 Rekordy w Delphi ...................................................r...................................................r.......76 Podsumowanie ...................................................r...................................................r............83 Rozdział 5. Biblioteka VCL...................................................z.............................. 85 Komponenty TActionList, TImageList, TOpenDialog, TSaveDialog i TMainMenu ......85 Komponenty TActionManager i TActionMainMenuBar .................................................91 Komponenty TFrame, TSpinEdit i TStaticText...................................................r.............96 Hierarchia własności obiektów. Właściciele i rodzice...................................................r.100 Konstruktor i Destruktor ...................................................r........................................102 Podsumowanie ...................................................r...................................................r..........103 Rozdział 6. Biblioteka CLX...................................................z............................ 105 Komponenty TTimer i TLCDNumber ...................................................r.........................105 Podsumowanie ...................................................r...................................................r..........109 Rozdział 7. Tworzymy własne komponenty ...................................................z.... 111 Podsumowanie ...................................................r...................................................r..........117 Rozdział 8. Biblioteki DLL ...................................................z............................. 119 Podsumowanie ...................................................r...................................................r..........126 Skorowidz...................................................z................................... 127 Rozdział 4. Object Pascal w wydaniu Delphi Rozdział ten poświęcony jest omówieniu praktycznych sposobów wykorzystania po- znanych wcześniej elementów języka Object Pascal w graficznym środowisku Delphi 6. Zapoznamy się tutaj m. in. z pojęciem formularza, wyjątku czy procedury obsługi zda- rzenia. Poznamy również metody wykorzystania w aplikeacji własnych funkcji i proce- dur. Zastosowanie omówionych elementów Delphi zostanie zilustrowane odpowied- nimi ćwiczeniami. Formularz Formularz jest pierwszym obiektem, z którym spotykamy się, rozpoczynając pisanie aplikacji. Po dwukrotnym kliknięciu w obszarze formularza dostajemy się do okna edycji kodu modułu Unit1.pas, który pokazany jest na rysunku 4.1. Object Pascal oferuje nam słowo kluczowe ENCUU, pozwalające na tworzenie obiektów. Przykładowa definicja klasy formularza wygląda następeująco: V[RG 6(QTOENCUU 6(QTO RTQEGFWTG(QTO TGCVG 5GPFGT61DLGEV  RTKXCVG ]2TKXCVGFGENCTCVKQPU_ RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF Zdefiniowana klasa dziedziczy własności bazowej klasey formularza TForm, natomiast sam formularz, traktowany jako zmienna obiektowa, dekelarowany jest jako: XCT (QTO6(QTO 50 Rysunek 4.1. Okno edycji kodu głównego modułu aplikacji ABC Delphi 6 Z zapisu tego odczytamy, iż formularz jest zmienną obiektową, natomiast nazwa kla- sy stała się nowym specyfikatorem typu danych. W definicji klasy możemy zauważyć procedurę: RTQEGFWTG(QTO TGCVG 5GPFGT61DLGEV  Delphi odpowiednio inicjuje formularz (tylko jeden raz), kiedy jest on tworzony po raz pierwszy. Sender jest pewną zmienną typu TObject, wołaną przez wartość. W rze- czywistości Sender reprezentuje pewną właściwość, polegającą na tym, iż każdy obiekt łącznie z formularzem (oraz każdy obiekt VCL i CLX) musi być w pewien sposób poinformowany o przyszłym przypisaniu mu pewnego zdarzenia (w przypad- ku formularza zdarzenie to polega na jego inicjalizeacji). TObject jest bezwzględnym przodkiem wszystkich komponentów i obiektów VCL oraz CLX i umieszczony jest na samym szczycie hieralrchii obiektów. Z rysunku 4.1 możemy odczytać, iż standardowa definicja klasy składa się z kilku czę- ści. Sekcja public służy do deklarowania funkcji i procedur (czyli metod) oraz zmien- nych (zwanych polami), które w przyszłości mogą być udostępniane innym. Zasadni- czą różnicą pomiędzy metodami a zwykłymi funkcjami czy procedurami jest to, że każda metoda posiada niejawny parametr Self, wskazujący na obiekt będący przed- miotem wywołania tej metody. Sekcję public często nazywamy interfejsem obiektu. Sekcja private przeznaczona jest dla pól i metod widzianych jedyneie wewnątrz klasy. Rozdział 4. ♦ Object Pascal w wydaniu Delphi 51 Oprócz elementów wymienionych, definicja klasy może posiadać jeszcze sekcje pro- tected oraz published. W części protected można definiować pola i metody widoczne dla macierzystej klasy i klas po niej dziedziczących. Deklaracje zawarte w sekcji pu- blished (publikowanej) pełnią taką samą rolę, jak deklaracje umieszczone w sekcji public (publicznej). Różnica pomiędzy nimi polega na tym, iż te pierwsze nie tworzą tzw. informacji czasu wykonania. Zdarzenia Zdarzenie (ang. event) określane jest jako zmiana, która występuje w aktualnym sta- nie obiektu i jest źródłem odpowiednich komunikatów, przekazywanych do aplikacji lub bezpośrednio do systemu. Reakcja obiektu na wystąpienie zdarzenia udostępniana jest aplikacji poprzez procedurę obsługi zdarzeń (ang. event procedure) będącą wy- dzieloną częścią kodu. Rolę zdarzeń w aplikacji najlepiej jest prześledzić, wykonując praktyczne ćwiczenie. Tradycyjnie już założymy na dysku nowy katalog. Po uruchomieniu Delphi 6 znany- mi nam już poleceniami menu zapiszmy w nim główny moduł aplikacji, który na- zwiemy Unit_08.pas. Zapiszmy również projekt aplikacji pod nazwą Projekt_08.dpr. Rozmiary formularza ustalimy, korzystając z cech Height (wysokość) i Width (szero- kość), znajdujących się w karcie właściwości (Properties) Inspektora Obiektów. Jeżeli chcemy, aby po uruchomieniu formularz nie „rozpływał” się po ekranie w odpowie- dzi na kliknięcie pola maksymalizacji, w Inspektorze Obiektów rozwińmy cechę Con- straints (ograniczenie) i we właściwe miejsca wpiszmy żądane rozmiary formularza (w pikselach), tak jak pokazano na rysunku 4.2. Rysunek 4.2. Ograniczenie rozmiarów formularza Przejdźmy następnie do cechy Position i wybierzmy poScreenCenter. Wybrane przy- pisanie spowoduje, że w momencie uruchomienia aplikacji formularz pozostanie w centrum ekranu (ale nie pulpitu poDesktopCenter); jeżeli oczywiście w Inspektorze Obiektów cechy Align (zakotwiczenie) nie ustawiliśmy inaczej niż w pozycjei alNone. Na tak przygotowanym formularzu umieśćmy teraz dwa komponenty reprezentujące klasę TButton z karty Standard. Korzystając z Inspektora Obiektów oraz z karty wła- ściwości, cechy Caption przycisków Button1 oraz Button2 zmieńmy odpowiednio na Zamknij i Tekst. Znak , który występuje w nazwach przycisków, spowoduje, że litera, występująca bezpośrednio za nim, stanowić będzie klawisz szybkiego dostępu do procedury obsługi wybranego zdarzenia. W podobny sposób możemy zmienić ce- chy Font wybranych przycisków. Dla każdego z przycisków stworzymy procedurę obsługi odpowiedniego zdarzenia. Klikając dwukrotnie przycisk Zamknij lub w wido- ku drzewa obiektów (Object TreeView) odpowiednio oznaczony komponent, dosta- niemy się do wnętrza właściwej procedury obsługi zdearzenia: 52 ABC Delphi 6 RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP GPF Już w tym miejscu możemy zauważyć, iż w definicji klasy program Delphi wygene- rował automatycznie deklarację przycisku oraz deklarację procedury obsługującego go zdarzenia. Korzystając z notacji kropkowej, kompilator automatycznie został poin- formowany, do której klasy należy wywoływana procedurea. Użycie notacji kropkowej stanowi informację dla kompilatora, że przykładowa pro- cedura Button1Click() należy do przykładowej klasy TForm1 (jest metodą zdefinio- waną w klasie TForm1). Należy zawsze pamiętać, iż szkielety procedur obsługi odpowiednich zdarzeń, np. ta- kich jak $WVVQP NKEM , zostaną automatycznie wygenerowane przez Delphi w od- powiedzi na dwukrotne kliknięcie danego przycisku. W żadnym wypadku procedur tych nie należy wpisywać samodzielnie. Omawianą procedurę obsługi zdarzenia wypełnimy przedstawionym poniżej kodem, co spowoduje, że po naciśnięciu wybranego przycisku eaplikacja zostanie zamknięta. RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP #RRNKECVKQP6GTOKPCVG  GPF Każdy standardowy program Delphi (oparty na formularzu) zawiera pewną zmienną globalną o nazwie Application typu TApplication. W czasie tworzenia nowego pro- jektu Delphi konstruuje obiekt aplikacji i przypisuje mu właśnie zmienną Application. Obiekty klasy TApplication przechowują informacje odnośnie zasad współpracy apli- kacji z systemem operacyjnym. Informacje te dotyczą np. rozpoczynania i kończenia działania aplikacji czy tworzenia okna głównego programu. Istnieje wiele metod kla- sy TApplication. Jedną z nich jest 6GTOKPCVG , umożliwiająca zamknięcie aplikacji. Zajmiemy się teraz zaprojektowaniem procedury obsługi zdarzenia przycisku Button2, który nazwaliśmy Tekst. Po kliknięciu tego przycisku, bezpośrednio na formularzu zostanie wyświetlony prosty tekst. Skorzystamy z tego, iż formularz, będący w istocie też komponentem, posiada swoje własne płótno (ang. canvas), reprezentowane przez klasę TCanvas, posiadającą właściwość Canvas. Procedura obsługi naszego zdarzenia będzie wyglądać następująco: RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP  CPXCU(QPV QNQTEN$NWG  CPXCU(QPV*GKIJV  CPXCU6GZV1WV NKGPV*GKIJVFKX NKGPV9KFVJFKX  2KGTYUCCRNKMCELCY GNRJK  GPF Powyższy przykład ilustruje sposób odwoływania się do obszaru płótna poprzez wła- ściwość Canvas klasy TCanvas z wykorzystaniem właściwości czcionka (Font). Za- stosowana metoda 6GZV1WV : RTQEGFWTG6GZV1WV :;+PVGIGTEQPUV6GZVUVTKPI  Rozdział 4. ♦ Object Pascal w wydaniu Delphi 53 pozwala na umieszczenie dowolnego tekstu identyfikowanego przez stałą Text w miejscu formularza o współrzędnych X, Y (odległość liczona jest w pikselach, na- tomiast lewy górny róg formularza posiada współrzędene 0, 0). Może również zdarzyć się i taka sytuacja, w której zechcemy zamknąć formularz, ko- rzystając bezpośrednio z jego pola zamknięcia (por. rysunek 3.2). Zamykając w ten sposób działającą aplikację, należy mieć na uwadze fakt, iż w Windows 9x bezpo- średni sposób zamknięcia działającego programu może nie działać w pełni poprawnie (nie dotyczy to Win 2000, NT i XP). Aby mieć pewność, że w momencie zamknięcia aplikacji wszystkie jej zasoby zostaną prawidłowo zwolnione, skorzystamy ze zda- rzenia 1P NQUG. Klikając (tylko raz) w obszar formularza w inspektorze obiektów, przejdźmy do zakładki Events (zdarzenia). Zdarzenie 1P NQUG określmy jako (QTO NQ UG (rysunek 4.3) i potwierdźmy klawiszem Enter. Rysunek 4.3. Zdarzenie OnClose W ten sposób Delphi automatycznie wygeneruje proceduerę obsługi zdarzenia (QTO NQUG 5GPFGT61DLGEVXCT#EVKQP6 NQUG#EVKQPO  Zmiennej #EVKQP (akcja) można tutaj przypisać jeden z elementów typue wyliczeniowego V[RG 6 NQUG#EVKQP EC0QPGEC*KFGEC(TGGEC/KPKOKG  gdzie:    EC0QPG oznacza, że formularz nie zostanie zamknięty; EC*KFG oznacza, że formularz nie zostanie zamknięty, lecz ukeryty; EC(TGG oznacza, że formularz zostanie zamknięty z jednoczesenym zwolnieniem wszystkich zasobów pamięci, z których aektualnie korzysta;  EC/KPKOKG oznacza, że formularz zostanie zminimalizowany. 54 ABC Delphi 6 Procedurę obsługi zdarzenia (QTO NQUG wypełnimy następującym kodem: RTQEGFWTG6(QTO(QTO NQUG 5GPFGT61DLGEV XCT#EVKQP6 NQUG#EVKQP  DGIKP ECUG /GUUCIG$QZ  COMPKúEKGCRNKMCELK!  7YCIC  /$A; 501QT/$A+ 1037 56+10 QH + A; 5 #EVKQPEC(TGG + A01 #EVKQPEC0QPG GPF GPF Skorzystaliśmy tutaj z omawianej wcześniej instrukcji CUG1H oraz z funkcji /GU UCIG$QZ , wyświetlającej odpowiedni komunikat w okienku dialeogowym. Projekt aplikacji Projekt_08.dpr, wykorzystującej omawiane zdarzenia, znajduje się w katalogu Kody8, natomiast na wydruku 4.1 zamieszczono kod źródłowy modułu Unit_08.pas. Wydruk 4.1. Moduł Unit_08.pas projektu Projekt_08.dpr WPKV7PKVA KPVGTHCEG WUGU 9KPFQYU/GUUCIGU5[U7VKNU NCUUGU )TCRJKEU QPVTQNU(QTOU$WVVQPU 5VF VTNU V[RG 6(QTOENCUU 6(QTO $WVVQP6$WVVQP $WVVQP6$WVVQP RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG(QTO NQUG 5GPFGT61DLGEVXCT#EVKQP6 ONQUG#EVKQP  RTKXCVG ]2TKXCVGFGENCTCVKQPU_ RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF XCT (QTO6(QTO KORNGOGPVCVKQP ]4  (/_  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP Rozdział 4. ♦ Object Pascal w wydaniu Delphi 55  CPXCU(QPV QNQTEN$NWG  CPXCU(QPV*GKIJV  CPXCU6GZV1WV NKGPV*GKIJVFKX NKGPV9KFVJFKX  2KGTYUCCRNKMCELCY GNRJK  GPF  RTQEGFWTG6(QTO(QTO NQUG 5GPFGT61DLGEVXCT#EVKOQP6 NQUG#EVKQP  DGIKP ECUG /GUUCIG$QZ  COMPKúEKGCRNKMCELK!  7YCIC  /$A; 501QT/$A+ 1037 56+10 QH + A; 5 #EVKQPEC(TGG + A01 #EVKQPEC0QPG GPF GPF  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP #RRNKECVKQP6GTOKPCVG  GPF  GPF Zajrzyjmy teraz do katalogu, w którym został zapisany nasz projekt. Oprócz plików, wymienionych w rozdziale 1, pojawiły się tam 3 dodatkeowe:  .dpp — plik Diagram Delphi Page. Można w nim zapisać diagramy będące wizualizacją logicznych relacji pomiędzy widocznymie i niewidocznymi komponentami, składającymi się na całość projektu. Reelacje takie można uzyskać, korzystając z zakładki Diagram.  .dfm — plik zawierający opis formularza. Dyrektywa kompilateora ]4_ lub ]4 5174 _ dołącza do projektu zewnętrzny plik zasobów, zawiereający opis formularza. Plik zasobów jest włączany do końcoweego pliku wynikowego .exe w czasie łączenia projektu.  .res — plik zasobów Windows. Żadnego z nich nie powinnyśmy utracić. Plik projektu Delphi .dpr środowiska graficznego różni się nieco od swojego odpowied- nika aplikacji konsolowych. Programy Delphi są bardzo krótkie. Wynika to z faktu, iż aplikacje z interfejsem graficznym zazwyczaj wywołują procedurę inicjalizacyjną #R RNKECVKQP+PKVKCNKG , następnie tworzony jest formularz (lub formularze) Applica- tion.CreateForm(TForm1,Form1), w którym uruchamiane są procedury obsługi zdarzeń #RRNKECVKQP4WP . Aplikacja zamykana jest poprzez główny formularz w odpowiedzi na wywołanie procedury obsługi odpowiedniego zdarzenia #RRNKECVKQP6GTOKPCVG (patrz wydruk 4.1). Typowy plik kodu źródłowego projektu Delphi przedstawiony jest na wydruku 4.2. 56 ABC Delphi 6 Wydruk 4.2. Typowy plik programu Delphi RTQITCO2TQLGMVA WUGU (QTOU 7PKVAKP 7PKVARCU ](QTO_ ]4 4 5_ DGIKP #RRNKECVKQP+PKVKCNKG #RRNKECVKQP TGCVG(QTO 6(QTO(QTO  #RRNKECVKQP4WP GPF Deklaracja WUGU tworzy listę modułów wchodzących w skład programu. Nazwa modułu może być poprzedzona dyrektywą KP, specyfikującą nazwę pliku. Moduły bez dyrek- tywy KP są modułami bibliotecznymi i nie stanowią części koedu źródłowego projektu. Wykorzystujemy własne funkcje i procedury Własne procedury i funkcje możemy umieszczać w programie Delphi na parę sposobów. Zapoznamy się teraz z dwoma sposobami — najprostszymi i najczęściej stosowanymi. Definicję funkcji lub procedury umieszczamy bezpośrednio w kodzie programu w sekcji implementacji modułu: XCT (QTO6(QTO KORNGOGPVCVKQP ]4 FHO_ RTQEGFWTG2QYGTVQ0 XCTZ+PVGIGT[+PVGIGT  XCT K+PVGIGT DGIKP  HQTKVQ[FQ DGIKP  Z (QTO/GOQ.KPGU#FF +PV6Q5VT Z FQRQVúIK +PV6Q5VT K  +PV6Q5VT  GPF GPF Wyświetlanie kolejnych liczb całkowitych, będących kolejnymi potęgami całkowitego parametru x, dokonywane jest w komponencie edycyjnym Memo1, będącym reprezen- tantem klasy TMemo z karty Standard. Ponieważ nasza procedura nie została zadeklaro- Rozdział 4. ♦ Object Pascal w wydaniu Delphi 57 wana w definicji klasy formularza, więc odwołanie się w jej wnętrzu do odpowiedniego komponentu edycyjnego wymaga, aby jawnie wskazać, iż komponent ten należy do formularza Form1. Wyświetlanie kolejnych liczb całkowitych dokonywane jest za po- średnictwem funkcji +PV6Q5VT formatującej wartość liczbową (wartość w postaci liczby całkowitej) na odpowiedni łańcuch znaków. Dużo subtelniejszym (ale nie zawsze opłacalnym sposobem) jest uczynienie funkcji lub procedury jawnym obiektem klasy formularza TForm1. Należy wówczas definicję nagłówkową funkcji lub procedury uzupełnić o nazwę klasy, do której ma przynale- żeć. Musimy ponadto omawiane funkcje lub procedury zadeklarować w definicji klasy w jednej z sekcji, np. V[RG 6(QTOENCUU 6(QTO $WVVQP6$WVVQP /GOQ6/GOQ $WVVQP6$WVVQP $WVVQP6$WVVQP RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTKXCVG ]2TKXCVGFGENCTCVKQPU_ RTQEGFWTG2QYGTVQ0 Z[ CTFKPCN  RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF XCT (QTO6(QTO KORNGOGPVCVKQP ]4 FHO_  RTQEGFWTG6(QTO2QYGTVQ0 Z[ CTFKPCN  XCT K CTFKPCN DGIKP  HQTKVQ[FQ DGIKP  Z /GOQ.KPGU#FF +PV6Q5VT Z FQRQVúIK +PV6Q5VT K  +PV6Q5VT  GPF GPF Korzystając z tego sposobu definiowania własnej funkcji lub procedury, możemy we- wnątrz nich bez problemów odwoływać się do innych obiektów formularza. Wszystkie własności, cechy, zdarzenia i metody właściwe tym obiektom będą widoczne w na- szej funkcji lub procedurze. 58 ABC Delphi 6 Metody przeciążane Chociaż można przypuszczać, iż pojęcia procedur lub funkcji przeciążanych (przeła- dowywanych) należy wprowadzać na bardziej zaawansowanym kursie programowa- nia, to jednak wydaje się, iż w sytuacji kiedy środowiska programistyczne stają się coraz bardziej rozbudowane, powinniśmy posiadać pewne wiadomości na ten temat. Jest to szczególnie ważne w momencie, kiedy zechcemy samodzielnie posługiwać się plikami pomocy. Pisząc programy w Delphi, możemy zadeklarować wiele funkcji czy procedur o tej samej nazwie, ale o różnej postaci argumentów. W momencie wywołania danej proce- dury czy funkcji kompilator powinien je rozróżniać. Do deklaracji procedur (funkcji) przeładowywanych służy dyrektywa QXGTNQCF (przeładowanie). Najlepszym (i jedy- nym) sposobem zapoznania się z ideą funkcji (procedur) przeładowywanych jest samo- dzielne napisanie prostej aplikacji, w której funkcje te zostaną wykorzystane. Stworzy- my program wykorzystujący znane nam już procedury obliczające kolejne całkowite potęgi wybranej liczby, ale w ten sposób, by jednocześnie można było korzystać z pro- cedur, których parametry wołane są przez zmienną i przez wartość. Przy okazji zapo- znamy się z podstawowymi własnościami komponentu edeycyjnego TMemo. W skład formularza projektu Kody9Projekt_09.dpr będą wchodzić trzy przyciski będące reprezentantami klasy TButton oraz jeden reprezentant klasy TMemo. Umie- śćmy je na formularzu w sposób pokazany na rysunku 4.4. W inspektorze obiektów właściwość Caption formularza Form1 zmieńmy na Projekt_09. Rysunek 4.4. Podstawowe elementy formularza projektu Projekt_ 09.dpr W inspektorze obiektów własności Caption komponentów Button1, Button2 i Button3 zmieńmy odpowiednio na Oblicz — wywołanie przez zmienną, Zamknij i O blicz — wywołanie przez wartość. Można również skorzystać z ich własności Font, aby dobrać odpowiednią czcionkę. Należy oczywiście pamiętać o uprzednim zaznaczeniu wybranego komponentu, np. poprzez pojedyncze kliknięecie go myszą. Ponieważ należy się spodziewać, iż w komponencie edycyjnym Memo1 będą wyświe- tlane kolejne liczby, musimy zadbać o możliwość pionowego przewijania zawartości tego komponentu. W tym celu w inspektorze obiektów jego właściwość ScrollBars ustalmy jako ssVertical. Jeżeli zechcemy, aby zawartość komponentu mogła być prze- wijana zarówno w pionie, jak i w poziomie, wystarczy wybrać ssBoth. Rozdział 4. ♦ Object Pascal w wydaniu Delphi 59 W momencie wybrania reprezentanta klasy TMemo, w oknie edycji zobaczymy jego nazwę. Aby nie była ona wyświetlana, należy skorzystać z własności Lines i poprzez TStrings w oknie edytora skasować napis Memo1. Kiedy wszystkie potrzebne kom- ponenty zostaną już rozmieszczone na formularzu, możemy jego rozmiary odpowied- nio do nich dopasować. W tym celu w inspektorze obiektów jego własności AutoSize wystarczy przypisać wartość True. Po tych wstępnych czynnościach nie pozostaje nam nic innego jak zaimplementować w programie dwie procedury 2QYGT:VQ; obliczające kolejne całkowite potęgi Y wy- branej liczby całkowitej X. Musimy również wypełnić treści procedur odpowiednich zdarzeń, podobnie jak zostało to pokazane na wydrukue 4.3. Wydruk 4.3. Kod głównego modułu Unit_09.pas projektu Projekt_09.dpjr, wykorzystującego przeciążane procedury WPKV7PKVA KPVGTHCEG WUGU 9KPFQYU/GUUCIGU5[U7VKNU8CTKCPVU  NCUUGU)TCRJKEU QPVTQNU(QTOU  KCNQIU5VF VTNU V[RG 6(QTOENCUU 6(QTO $WVVQP6$WVVQP /GOQ6/GOQ $WVVQP6$WVVQP $WVVQP6$WVVQP RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTKXCVG ]2TKXCVGFGENCTCVKQPU_ RTQEGFWTG2QYGT:VQ; Z[ CTFKPCN QXGTNQCF RTQEGFWTG2QYGT:VQ; XCTZ[+PVGIGT QXGTNQCF RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF XCT (QTO6(QTO KORNGOGPVCVKQP ]4 FHO_ RTQEGFWTG6(QTO2QYGT:VQ; XCTZ[+PVGIGT  XCT K+PVGIGT DGIKP  HQTKVQ[FQ DGIKP  Z 60 ABC Delphi 6 /GOQ.KPGU#FF +PV6Q5VT Z FQRQVúIK +PV6Q5VT K  +PV6Q5VT  GPF GPF  RTQEGFWTG6(QTO2QYGT:VQ; Z[ CTFKPCN  XCT K CTFKPCN DGIKP  HQTKVQ[FQ DGIKP  Z /GOQ.KPGU#FF +PV6Q5VT Z FQRQVúIK +PV6Q5VT K  +PV6Q5VT  GPF GPF  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  XCTCD+PVGIGT DGIKP /GOQ NGCT  CD 2QYGT:VQ; CD Y[YQđCPKGRTGOKGPPæ GPF  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP /GOQ NGCT  2QYGT:VQ;  Y[YQđCPKGRTGYCTVQħè GPF  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP #RRNKECVKQP6GTOKPCVG  GPF GPF Program skompilujemy, korzystając z klawisza F9 lub opcji menu Run, Run. Śledząc kod programu, możemy też zauważyć, iż w celu skasowania zawartości komponentu Memo1 posługujemy się metodą NGCT . Wyjątki Podobnie jak w przypadku metod przeciążanych, ktoś mógłby powątpiewać w celowość wprowadzania pojęcia wyjątku w kursie programowania, przeznaczonym dla osób mniej zaawansowanych. Należy jednak zdawać sobie sprawę z faktu, iż wyjątki jako obiekty pełnią bardzo ważną rolę we wszystkich współczesnych systemach operacyj- nych oraz środowiskach programowania i pewne własności kompilatora, które jeszcze do niedawna uważano za bardzo zaawansowane, obecnie ejuż takimi być przestają. Rozdział 4. ♦ Object Pascal w wydaniu Delphi 61 Wyjątki pozwalają osobie piszącej kod na uwzględnienie sytuacji, w której program w jakimś momencie wykonywania może ulec niekontrolowanemu zakończeniu. Wy- jątek może być umiejscowiony w dowolnej metodzie. W Delphi podstawową klasą, zajmującą się obsługą wyjątków, jest Exception (ang. wyjątek). Klasa ta wywodzi się bezpośrednio z klasy TObject. Z kolei z Exception (chodź nie bezpośrednio) wywodzi się klasa EMathError, będąca z kolei nadklasą (klasą bazową) dla zbioru niezwykle użytecznych klas, obsługujących wyjątki, powstałe przy wykryciu przez kompilator błędów operacji matematycznych na liczbach zmiennopozycyjnych (liczbach dzie- siętnych). Wyjątki dziedziczące z EMathError zostały przedstawione w tabeli 4.1. Tabela 4.1. Klasy dziedziczące z EMathError Klasa wyjątku Znaczenie +PXCNKF#TIWOGPV Przekroczenie zakresu zmienności zadeklarowanego ty pu danych +PXCNKF1R 1XGTHNQY 7PFGTHNQY GTQ KXKFG Nieprawidłowa operacja zmiennoprzecinkowa Przekroczenie zakresu typu zmiennoprzecinkowego Wartość typu zmiennoprzecinkowego jest zbyt mała Zmiennoprzecinkowe dzielenie przez zero Delphi posługuje się dwoma wyrażeniami przeznaczonymi do obsługi wyjątków. Z pierwszym, a zarazem podstawowym z nich, zapoznamy się obecnie. Wyrażenie VT[GZEGRVGPF uaktywnia procedurę obsługi wyjątku przejmującą kontrolę nad dalszym wykonywaniem programu, w przypadku gdy zostanie wykonana jakaś nie- dozwolona operacja. Jako przykład niech nam posłuży prosty algorytm wykonujący operację zmiennopozycyjnego dzielenia dwóch liczb, które wprowadzimy do odpo- wiednich komponentów edycyjnych. Bez trudu możemy przewidzieć, iż wyjątek po- wstanie przy próbie wykonania dzielenia na znakach nie będących liczbami lub przy próbie dzielenia przez zero. Zaprojektujmy bardzo prostą aplikację, wykonującą zmieennopozycyjne dzielenie dwóch liczb, wprowadzanych z klawiatury do dwóch nowoczesnych komponentów edycyj- nych LabeledEdit1 i LabeledEdit2. Wynik będzie przechowywany w komponencie LabeledEdit3. Stwórzmy nowy formularz projektu Projekt_10.dpr, w skład którego wchodzić będą dwa przyciski (reprezentujące klasę TButton) oraz trzy komponenty edycyjne (repre- zentujące klasę TLabeledEdit z karty Additional). W inspektorze obiektów właściwo- ściom Text komponentów LabeledEdit1 i LabeledEdit2 przypiszmy wartości 0,0, aby ich cechy Text nie posiadały wartości nieokreślonej. Cechę Text komponentu Labele- dEdit3 wykasujmy. Komponenty reprezentujące klasę TLabeledEdit posiadają moż- liwość automatycznego ich opisu. Są one jakby połączeniem komponentów z klas TLabel i TEdit. Rozwijając w inspektorze obiektów opcje właściwości EditLabel komponentu LabeledEdit1 (obok nazwy właściwości w inspektorze obiektów pojawi się znaczek „–”) opiszmy jego cechę Caption jako Liczba 1. Podobnie opiszemy wszystkie komponenty edycyjne, tak jak przedstawiono to na rysunku 4.5. 62 Rysunek 4.5. Rozmieszczenie i opis komponentów reprezentujących klasę TLabeledEdit ABC Delphi 6 Bardzo często korzystanie z różnego rodzaju komponentów ułatwiają nam dymki podpowiedzi (ang. hint). Jeżeli zechcemy je zastosować na potrzeby naszych okienek edycji, musimy zamknąć opcje właściwości EditLabel (obok nazwy tej właściwości w inspektorze obiektów pojawi się znaczek „+”). Zaznaczmy myszką wybrany kom- ponent i odszukajmy w inspektorze obiektów jego właściwość Hint, którą opiszemy jako Podaj pierwszą liczbę. Aby dymek podpowiedzi był rzeczywiście widoczny w trak- cie działania programu, właściwości ShowHint należy nadać wartość 6TWG. Analo- gicznie postąpimy z następnym komponentem edycyjnyme. Przystąpmy obecnie do wypełniania głównego modułu Unit_10.pas naszego formula- rza odpowiednim kodem. W sekcji implementacji modułu zadeklarujmy własną klasę EFloatingPointError (wyjątek dzielenia zmiennopozycyjnego) przechwytującą wy- jątki, która będzie dziedziczyć po klasie EMathError. Dodatkowo zastosujmy dwie deklaracje TGUQWTEGUVTKPI, przechowujące odpowiednie komunikaty, informujące o powstaniu wyjątku podczas zmiennopozycyjnego dzieelenia dwóch liczb: KORNGOGPVCVKQP ]4 FHO_ V[RG  (NQCVKPI2QKPV TTQTENCUU /CVJ TTQT  TGUQWTEGUVTKPI /UI $đæFQRGTCELKOKGPPQRQ[E[LP[EJU  /UI 2TÎDCFKGNGPKCRTGGTQU  W tym wypadku znaki formatowania U pozwalają na zduplikowanie komunikatów w języku polskim i angielskim. Procedurę obsługi zdarzenia $WVVQP NKEM , uruchamianego przyciskiem Oblicz, wypełnimy następującym kodem: RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP VT[ .CDGNGF FKV6GZV(NQCV6Q5VT 5VT6Q(NQCV .CDGNGF FKOV6GZV  5VT6Q(NQCV .CDGNOGF FKV6GZV  GZEGRV QP Z +PXCNKF1RFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O QP Z GTQ KXKFGFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O GPF GPF Rozdział 4. ♦ Object Pascal w wydaniu Delphi 63 W klauzuli VT[GZEGRV, przeznaczonej do obsługi błędów, umieściliśmy zapis właści- wej operacji dzielenia dwóch liczb. Funkcje 5VT6Q(NQCV dokonują konwersji ciągu zna- ków, przechowywanych w cechach Text komponentów LabeledEdit1 oraz LabeledE- dit2, na zmiennopozycyjną postać numeryczną, czyli po prostu na liczby z przecinkami. Używając operatora dzielenia zmiennopozycyjnego „/”, te dwie liczby podzielimy przez siebie, natomiast wynik dzielenia zostanie z kolei przypisany cesze Text kom- ponentu edycyjnego reprezentowanego przez LabeledEdit3. Aby postać numeryczna liczby mogła być wyświetlana w oknie edycyjnym, musi zostać zamieniona na łań- cuch znaków (w tym wypadku typu string). Dokonujemy tego, stosując funkcję (NQ CV6Q5VT konwertującą postać numeryczną liczby na odpowiedni ełańcuch znaków. Każde wyrażenie VT[GZEGRVGPF może posiadać jedną lub więcej sekcji on: Z MNCUC Y[LæVMW FQ, z których każda deklaruje odrębną klasę wyjątku. Delphi prze- szukuje sekcję QP w zapisanym porządku (od góry do dołu), poszukując aktualnie pa- sującej klasy wyjątku odpowiadającego występującemu błędowi. Ogólnie rzecz biorąc, każdy kod potencjalnie mogący wygenerować wyjątek (w na- szym przypadku dzielenie zmiennopozycyjne) powinien mieć możliwość przekazania jego obiektu do wyrażenia raise (zakańczać, zbierać). W tym miejscu należy wyko- rzystać własną klasę wyjątku (NQCVKPI2QKPV TTQT TGCVG(OV z konstruktorem konwertującym komunikat egzemplarza wyjątku na łańcuceh znaków EQPUVTWEVQT TGCVG(OV EQPUV/UIUVTKPIEQPUV#TIUOCTTC[QHEQPUV  gdzie argument Args jest tzw. wariantową tablicą otwartą (array of const), pozwalają- cą na przekazywanie niejednorodnych komunikatów (Messages). Może zdarzyć się i taka sytuacja, w której kompilator w sekcji VT[GZEGRVGPF nie znajdzie pasującego obiektu wyjątku. Wówczas należy użyć konstrukcji VT[ GZEGRVGNUGTCKUGGPF: RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP VT[ .CDGNGF FKV6GZV(NQCV6Q5VT 5VT6Q(NQCV .CDGNGF FKOV6GZV  5VT6Q(NQCV .CDGNOGF FKV6GZV  GZEGRV QP Z +PXCNKF1RFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O QP Z GTQ KXKFGFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O GNUG TCKUG GPF GPF Mamy nadzieję, iż przedstawione w poprzednim punkcie rozważania nie są zbyt skomplikowane dla mniej zaawansowanych Czytelników. Jeżeli jednak ktoś czuje się nieco zagubiony pośród tych pojęć, zawsze można przedstawioną wyżej konstrukcję znacznie uprościć poprzez wyświetlanie komunikatu wyjątku poprzez okno dialogo- we MessageBox(): 64 ABC Delphi 6 RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP VT[ .CDGNGF FKV6GZV(NQCV6Q5VT 5VT6Q(NQCV .CDGNGF FKOV6GZV  5VT6Q(NQCV .CDGNOGF FKV6GZV  GZEGRV QP Z +PXCNKF1RFQ /GUUCIG$QZ  $đæFQRGTCELKOKGPPQRQ[E[LP[EJ  7YCIC  /$A1-  QP Z GTQ KXKFGFQ /GUUCIG$QZ  2TÎDCFKGNGPKCRTGGTQ  7YCIC /$A1-  GNUG TCKUG GPF GPF Na wydruku 4.4 przedstawiono kompletny kod źródłowy głównego modułu aplikacji, wykorzystującej obiekty wyjątków powstałych podczas operacji zmiennopozycyjnego dzielenia dwóch liczb. Wydruk 4.4. Kod głównego modułu Unit_10.pas projektu KODY10Projekt_j10.dpr, wykorzystującego przykładowe klasy wyjątków WPKV7PKVA KPVGTHCEG WUGU 9KPFQYU/GUUCIGU5[U7VKNU8CTKCPVU  NCUUGU)TCRJKEU QPVTQNU(QTOU  KCNQIU5VF VTNU ZV VTNU V[RG 6(QTOENCUU 6(QTO $WVVQP6$WVVQP .CDGNGF FKV6.CDGNGF FKV .CDGNGF FKV6.CDGNGF FKV .CDGNGF FKV6.CDGNGF FKV $WVVQP6$WVVQP RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTKXCVG ]2TKXCVGFGENCTCVKQPU_ RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF XCT (QTO6(QTO KORNGOGPVCVKQP ]4 FHO_ V[RG  (NQCVKPI2QKPV TTQTENCUU /CVJ TTQT  TGUQWTEGUVTKPI /UI $đæFQRGTCELKOKGPPQRQ[E[LP[EJU  /UI 2TÎDCFKGNGPKCRTGGTQU  Rozdział 4. ♦ Object Pascal w wydaniu Delphi 65 RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP VT[ .CDGNGF FKV6GZV(NQCV6Q5VT 5VT6Q(NQCV .CDGNGF FKOV6GZV  5VT6Q(NQCV .CDGNGF FKV6GZV  GZEGRV QP Z +PXCNKF1RFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O /GUUCIG$QZ  $đæFQRGTCELKOKGPPQRQ[E[LP[EJ  7YCIC  /$A1-  QP Z GTQ KXKFGFQ TCKUG (NQCVKPI2QKPV TTQT TGCVG(OV /UI= Z/GUUCIG? O /GUUCIG$QZ  2TÎDCFKGNGPKCRTGGTQ  7YCIC /$A1-  GNUG TCKUG GPF GPF  RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP #RRNKECVKQP6GTOKPCVG  GPF GPF Powyższy algorytm najlepiej jest testować, uruchamiając program wynikowy Pro- jekt_10.exe. Operacje na plikach Zarówno w Windows, jak i Linux wszelkie operacje wejścia-wyjścia realizowane są za pomocą czytania z plików lub pisania do plików. Wszystkie urządzenia zewnętrzne, łącznie z końcówką użytkownika, traktowane są jako pliki wchodzące w skład szero- kiego systemu plików. Niniejszy podrozdział poświęcony jest pewnym aspektom re- alizacji przez Delphi różnego rodzaju operacji na pleikach. Większość operacji plikowych, pochodzących ze standardowego Pascala, działa rów- nież w graficznym środowisku Delphi 6. Przypomnijmy, iż standardowo nazwa pliku może być zmienną typu File lub TextFile. Wywołaniem procedury RTQEGFWTG#UUKIP(KNG XCT((KNG0COGUVTKPI  dokonujemy przypisania nazwy pliku do zmiennej plikeowej. Procedura RTQEGFWTG4GUGV XCT(=(KNG4GE5KG9QTF?  otwiera istniejący plik. Tryb otwarcia pliku zależy od przypisania zmiennej FileMode odpowiedniej wartości. Domyślnie przyjmowana jest wartość 2 pozwalająca na od- czyt i zapis do pliku. Przypisanie zmiennej FileMode wartości 0 przed wywołaniem procedury 4GUGV spowoduje otwarcie pliku w trybie tylko do odczytu danych, na- tomiast wartości 1 — w trybie tylko do zapisu. Z kolei procedura RTQEGFWTG4GYTKVG XCT((KNG=4GEUKG9QTF?  66 ABC Delphi 6 tworzy nowy plik z jednoczesnym jego otwarciem. Plik zamykamy, wywołując pro- cedurę: RTQEGFWTG NQUG(KNG XCT(  Zaprojektujmy aplikację, której zadaniem będzie wczytanie pliku tekstowego z dysku oraz jego ponowne zapisanie po ewentualnej modyfikaecji. Umieśćmy na formularzu po jednym reprezentancie klas TRichEdit i TCoolBar z karty Win32. Dodatkowo uzupełnimy go trzema komponentami reprezentującymi klasę TSpeedButton z karty Additional oraz po jednym komponencie z klas TMainMenu i TButton z karty Standard oraz TOpenDialog i TSaveDialog z karty Dialogs. Sposób rozmieszczenia wymienionych komponentów na formularezu obrazuje rysunek 4.6. Rysunek 4.6. Sposób rozmieszczenia komponentów na formularzu projektu Projekt_11.dpr Zaprojektujmy proste menu, dzięki któremu będziemy mogli utworzyć nowy plik, wczytać istniejący i ewentualnie powtórnie zapisać na dysku w wybranym katalogu. Aby dostać się do okna służącego do tworzenia menu głównego, należy zaznaczyć komponent MainMenu1, a następnie dwukrotnie kliknąć myszką pole Items karty zda- rzeń inspektora obiektów (oczywiście, ten sam efekt otrzymamy, klikając dwukrotnie samą ikonę na formularzu). Zmieńmy cechę Caption (nagłówek) na Plik, pojawi się wówczas nowe pole obok naszej opcji. W ten sposób możemy tworzyć nawet bardzo rozbudowane menu, ale o tym wszystkim jeszcze sobie powiemy w dalszej części książki. Teraz jednak wskażmy pole poniżej i cesze Caption przypiszmy Nowy, następnie przejdźmy do karty Events inspektora obiektów i zdarzeniu OnClick przypiszmy NewFileClick. Klikając teraz dwa razy pole Nowy, od razu znajdziemy się wewnątrz procedury obsługi zdarzenia 0GY(KNG NKEM . Powróćmy do okna Form1.MainMenu1 i przejdźmy niżej. Następną opcję zatytułujmy Otwórz. W karcie zdarzeń inspektora obiektów jej cechę Name zmieńmy na OpenFile, natomiast w karcie zdarzeń zdarze- niu OnClick przypiszmy FileOpenClick. Dwukrotnie klikając, dostaniemy się do wnętrza procedury obsługi zdarzenia (KNG1RGP NKEM . Procedurę tę wypełnimy od- powiednim kodem: RTQEGFWTG6(QTO(KNG1RGP NKEM 5GPFGT61DLGEV  XCT +P(KNG6GZV(KNG  CVCUVTKPI Rozdział 4. ♦ Object Pascal w wydaniu Delphi 67 DGIKP 4KEJ FKV.KPGU NGCT  KH1RGP KCNQI ZGEWVGVJGP DGIKP #UUKIP(KNG +P(KNG1RGP KCNQI(KNG0COG  4GUGV +P(KNG  YJKNGPQV 1( +P(KNG FQ DGIKP 4GCF.P +P(KNG CVC  4KEJ FKV.KPGU#FF CVC  GPF  NQUG(KNG +P(KNG  (QTO CRVKQP F[ELC= 1RGP KCNQI(KNG0COG ?  GPF GPF W bardzo podobny sposób zaprojektujmy pozostałe części składowe menu, tak jak pokazano na rysunku 4.7. Rysunek 4.7. Elementy składowe głównego menu projektu Projekt_11.dpr W omawianym programie menu Plik, Otwórz będzie zdublowane jednym z przycisków TSpeedButton. Najpierw na formularzu umieśćmy komponent TCoolBar, natomiast bezpośrednio na nim kolejno komponenty TSpeedButton. Ich cechy Name zmieńmy, posługując się inspektorem obiektów, odpowiednio na FileOpen, CopyText, PasteText, CutText. Korzystając z właściwości Glyph, rozwińmy opcję TBitmap i umieśćmy na każdym z przycisków TSpeedButton odpowiednią mapę bitową, tak jak przedstawio- no na rysunku 4.6. Rysunek taki możemy wykonać samodzielnie, korzystając z Edy- tora Graficznego Delphi (menu Tools, Image Editor), którego obsługa nie różni się w istocie od zasad obsługi programu graficznego, jakeim jest Paint. Aby przycisk FileOpen obsługiwał znaną nam już procedurę obsługi zdarzenia (KNG 1RGP NKEM , wystarczy w karcie zdarzeń inspektora obiektów jego zdarzeniu OnC- lick przypisać FileOpenClick(). Na wydruku 4.5 zamieszczono kompletny kod aplikacji Projekt_11.dpr. W funkcji (QTO TGCVG wykorzystaliśmy właściwość InitialDir obiektów TOpenDialog i TSaveDialog. Właściwość ta już w momencie uruchomienia aplikacji pozwala ustalić odpowiednią ścieżkę dostępu do aktualnego katalogu. Z kolei wykorzystując właściwość Filter (ry- sunek 4.8) tych obiektów, zapewnimy możliwość odczytania plików posiadających wymagane przez nas rozszerzenia. 68 Rysunek 4.8. Właściwość Filter klas TOpenDialog i TSaveDialog ABC Delphi 6 Dymki podpowiedzi do poszczególnych przycisków uzyskamy, korzystając z właści- wości Hint oraz ShowHint. Śledząc poniższy wydruk, zauważymy też, że aby kompo- nenty TOpenDialog i TSaveDialog, niewidoczne przecież w trakcie uruchomienia programu, generowały zdarzenia, polegające na wyświetleniu odpowiednich okien dialogowych, należy w funkcjach odpowiednich zdarzeń skorzystać z metody ZGEW VG . Plik zapisujemy na dysku, korzystając z procedury obsługi zdarzenia 5CXG(KNG #U NKEM . Procedury zdarzeniowe WV6GZV NKEM , 2CUVG6GZV NKEM , QR[6GZV NKEM , zaim- plementowane w odpowiednich przyciskach, zgrupowanych w panelu CoolBar1, ko- rzystają z metody 4KEJ FKV WV6Q NKRDQCTF , 4KEJ FKV 2CUVG(TQO NKRDQCTF , 4KEJ FKV QR[6Q NKRDQCTF , zapewniając możliwość usunięcia fragmentu tekstu, wstawienia fragmentu tekstu znajdującego się w schowku (ang. clipboard) oraz skopio- wania fragmentu tekstu do schowka. Możliwe jest również zaznaczenie całości tekstu przy wykorzystaniu metody 4KEJ FKV5GNGEV#NN . Aby powtórzyć ostatnio wyko- naną (na tekście) operację, należy skorzystać z metody e4KEJ FKV*CPFNG#NNQECVGF , którą możemy już samodzielnie zastosować. Wydruk 4.5. Kod głównego modułu Unit_11.pas projektu Projekt_11.dpr WPKV7PKVA KPVGTHCEG WUGU 9KPFQYU/GUUCIGU5[U7VKNU NCUUGU)TCRJKEU  QPVTQNU(QTOU KCNQIU5VF VTNU QO VTNU (KNG VTN6QQN9KP$WVVQPU/GPWU V[RG 6(QTOENCUU 6(QTO $WVVQP6$WVVQP 4KEJ FKV64KEJ FKV 5CXG KCNQI65CXG KCNQI  QQN$CT6 QQN$CT  QR[6GZV65RGGF$WVVQP 2CUVG6GZV65RGGF$WVVQP  WV6GZV65RGGF$WVVQP /CKP/GPW6/CKP/GPW 1RGP KCNQI61RGP KCNQI 5CXG(KNG#U6/GPW+VGO 1RGP(KNG6/GPW+VGO 0GY(KNG6/GPW+VGO Rozdział 4. ♦ Object Pascal w wydaniu Delphi 69  NQUG#RRNKECVKQP6/GPW+VGO RTQEGFWTG$WVVQP NKEM 5GPFGT61DLGEV  RTQEGFWTG(QTO TGCVG 5GPFGT61DLGEV  RTQEGFWTG QR[6GZV NKEM 5GPFGT61DLGEV  RTQEGFWTG2CUVG6GZV NKEM 5GPFGT61DLGEV  RTQEGFWTG WV6GZV NKEM 5GPFGT61DLGEV  RTQEGFWTG(KNG1RGP NKEM 5GPFGT61DLGEV  RTQEGFWTG0GY(KNG NKEM 5GPFGT61DLGEV  RTQEGFWTG5CXG(KNG#U NKEM 5GPFGT61DLGEV  RTQEGFWTG(QTO NQUG 5GPFGT61DLGEV XCT#EVKQP6 NQUG#EVKQP  RTQEGFWTG(QTO NQUG3WGT[ 5GPFGT61DLGEV XCT CP NQUG$QQNGCP O RTKXCVG ]2TKXCVGFGENCTCVKQPU_ U(KNG5VTKPI RTQEGFWTG(QTO CRVKQP EQPUVU(KNGAU5VTKPI  RWDNKE ]2WDNKEFGENCTCVKQPU_ GPF XCT (QTO6(QTO KORNGOGPVCVKQP ]4  (/_ TGUQWTEGUVTKPI U 7YCIC  U COMPKúEKGCRNKMCELK   RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP ECUG /GUUCIG$QZ 2 JCT U 2 JCT U  /$A; 501QT/$A+ 1037 56+10 QH + A; 5 #RRNKECVKQP6GTOKPCVG  + A01#DQTV  GPF GPF  RTQEGFWTG6(QTO(QTO TGCVG 5GPFGT61DLGEV  DGIKP 1RGP KCNQI+PKVKCN KT ZVTCEV(KNG2CVJ 2CTCO5VT   5CXG KCNQI+PKVKCN KT1RGP KCNQI+PKVKCN KT GPF  RTQEGFWTG6(QTO QR[6GZV NKEM 5GPFGT61DLGEV  DGIKP 4KEJ FKV QR[6Q NKRDQCTF  GPF  RTQEGFWTG6(QTO2CUVG6GZV NKEM 5GPFGT61DLGEV  DGIKP 4KEJ FKV2CUVG(TQO NKRDQCTF  GPF 70 ABC Delphi 6  RTQEGFWTG6(QTO WV6GZV NKEM 5GPFGT61DLGEV  DGIKP 4KEJ FKV WV6Q NKRDQCTF  GPF  RTQEGFWTG6(QTO(QTO CRVKQP EQPUVU(KNGAU5VTKPI  DGIKP U(KNGU(KNGAU  CRVKQP(QTOCV UU = ZVTCEV(KNG0COG U(KNGAU  #RRNKECVKQP6KVNG?  GPF  RTQEGFWTG6(QTO(KNG1RGP NKEM 5GPFGT61DLGEV  XCT +P(KNG6GZV(KNG  CVCUVTKPI DGIKP 4KEJ FKV.KPGU NGCT  KH1RGP KCNQI ZGEWVGVJGP DGIKP #UUKIP(KNG +P(KNG1RGP KCNQI(KNG0COG  4GUGV +P(KNG  YJKNGPQV 1( +P(KNG FQ DGIKP 4GCF.P +P(KNG CVC  4KEJ FKV.KPGU#FF CVC  GPF  NQUG(KNG +P(KNG  (QTO CRVKQP F[ELC= 1RGP KCNQI(KNG0COG ?  GPF GPF  RTQEGFWTG6(QTO0GY(KNG NKEM 5GPFGT61DLGEV  DGIKP (QTO CRVKQP $GPCY[  4KEJ FKV.KPGU NGCT  4KEJ FKV/QFKHKGF(#.5  GPF  RTQEGFWTG6(QTO5CXG(KNG#U NKEM 5GPFGT61DLGEV  XCT 1WV(KNG6GZV(KNG DGIKP KH5CXG KCNQI ZGEWVGVJGP DGIKP #UUKIP(KNG 1WV(KNG5CXG KCNQI(KNG0COG  4GYTKVG 1WV(KNG  9TKVG.P 1WV(KNG4KEJ FKV6GZV   NQUG(KNG 1WV(KNG  (QTO CRVKQP CRKUCP[=  5CXG KCNQI(KNG0COG  ?O  4KEJ FKV/QFKHKGF(#.5  GPF GPF  RTQEGFWTG6(QTO(QTO NQUG 5GPFGT61DLGEV XCT#EVKQP6 NQUG#EVKQP O Rozdział 4. ♦ Object Pascal w wydaniu Delphi 71 DGIKP #EVKQPEC(TGG GPF  RTQEGFWTG6(QTO(QTO NQUG3WGT[ 5GPFGT61DLGEV XCT CP NQUG$QQNGCP  DGIKP ECUG /GUUCIG$QZ 2 JCT U 2 JCT U  /$A; 501QT/$A+ 1037 56+10 QH OT; 5  CP NQUG647  OT01  CP NQUG(#.5  GPF GPF  GPF Strukturalna obsługa wyjątków Być może temat niniejszego podrozdziału może się wydawać mało adekwatny w książ- ce traktującej o podstawach programowania w Delphi, jednak przekonamy się, iż jest on naturalnym rozwinięciem poruszanych uprzednio zagadnień i wcale nie takim trud- nym pojęciowo, jak ktoś mógłby sądzić. Oprócz wyrażenia VT[GZEGRVGPF Delphi może posługiwać się również konstruk- cją VT[HKPCNN[GPF. Różnica pomiędzy nimi polega na tym, iż wyrażenie VT[ HKPCNN[ nie jest traktowane przez kompilator jako jawna konstrukcja obsługująca wyjątki pozwala natomiast na wykonanie części programu, występującego po słowie HKPCNN[, nawet w przypadku wcześniejszego wykrycia jakiegoś wyjątku. W celu wy- jaśnienia przedstawionego problemu posłużymy się przykładem procedury obsługi zdarzenia czytającego określony plik, który powinien znajdować się na dysku. Plik przeczytamy metodą „znak po znaku” za pomocą zmiennej e JCTCEVGT typu JCT. RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  XCT +P(KNG6GZV(KNG (0COGUVTKPI  JCTCEVGT JCT DGIKP 4KEJ FKV.KPGU NGCT  (0COG 2NKMVZV  #UUKIP(KNG +P(KNG(0COG  VT[ 4GUGV +P(KNG  VT[ YJKNGPQV 1( +P(KNG FQ DGIKP 4GCF +P(KNG JCTCEVGT  4KEJ FKV.KPGU#FF JCTCEVGT  GPF HKPCNN[ 72 ABC Delphi 6  NQUG(KNG +P(KNG  GPF GZEGRV QP Z +P1WV TTQTFQ 5JQY/GUUCIG $đæFQVYCTEKCRNKMW5RTCYFļ  E[RNKMKUVPKGLGPCF[UMW  GPF (QTO CRVKQP F[ELC= (0COG ?  GPF Podczas testowania, a następnie analizowania powyższego algorytmu bez trudu zauwa- żymy, iż w pierwszej kolejności zostaną wykonane instrukcje pomiędzy klauzulami VT[ oraz HKPCNN[. W następnej kolejności wykonywane będą instrukcje zawarte po- między HKPCNN[ i GPF (polegające na zamknięciu pliku bez względu na to, czy został on otwarty prawidłowo, czy nie) niezależnie od rezultatu wykonania pierwszej grupy instrukcji czytających znaki z pliku. Najbardziej zewenętrzny blok VT[GZEGRVGPF obrazuje znaną nam już ideę obsługi wyjątków. Pokazany sposób obsługi wyjątków nosi angielską nazwę Structural Exception Handling (w skrócie SEH). Dzięki zasto- sowaniu SEH dokonujemy rozdziału miejsca, w którym może wystąpić wyjątek (np. próba otwarcia nieistniejącego pliku) od miejsca, w którym będzie on obsługiwany. Zastosowany przez nas wyjątek EInOutError jest w rzeczywistości klasą wyjątków obsługujących operacje wejścia-wyjścia. Tablice otwarte W stosunku do standardowego języka Pascal Delphi znacznie rozszerza pojęcie tabli- cy. Jednym z takich rozszerzeń są tablice otwarte, które z reguły występują w roli pa- rametrów procedur lub funkcji i mogą posiadać dowolne rozmiary. W przypadku, gdy procedura lub funkcja nie będzie modyfikować zawartości tablicy otwartej, deklaruje- my ją za pomocą słowa kluczowego EQPUV. Słowa kluczowego XCT używamy w dekla- racji funkcji lub procedury modyfikującej zawartość takiej tablicy. Ponieważ w trak- cie działania program powinien w jakiś sposób kontrolować aktualny rozmiar takiej tablicy, musimy wskazać jej dolną i górną granicę. Do tego celu służą funkcje .QY i *KIJ . Jako przykład rozpatrzmy prostą funkcję 5WO1H NGOGPV , obliczającą sumę elemen- tów jednowymiarowej tablicy otwartej Data: HWPEVKQP5WO1H NGOGPV EQPUV CVCCTTC[QH QWDNG  QWDONG XCT K+PVGIGT DGIKP 4GUWNV HQTK.QY CVC VQ*KIJ CVC FQ 4GUWNV4GUWNV CVC=K? GPF Rozdział 4. ♦ Object Pascal w wydaniu Delphi 73 Widzimy, że deklaracja tablicy otwartej (z elementami np. typu Double) w charakte- rze argumentu funkcji przyjmuje bardzo prostą postać:e EQPUV CVCCTTC[QH QWDNG Wywołanie w programie funkcji z argumentem w postaci tablicy otwartej nie powin- no sprawić żadnego kłopotu nawet początkującemu programiście Delphi. Wyświetlenie wyniku (np. w komponencie edycyjnym TEdit z karty Standard), zwracanego przez funkcję 5WO1H NGOGPV , może nastąpić w procedurze obsługi wybranego zdarzeenia: RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  DGIKP  FKV6GZV(NQCV6Q5VT 5WO1H NGOGPV =?  GPF Widzimy, że w najprostszym wypadku wystarczy wywołać powyższą funkcję z ar- gumentem w postaci kolejnych elementów tablicy, zapisanych w nawiasach kwadra- towych. Tablice dynamiczne Różnica pomiędzy tablicami otwartymi i dynamicznymi jest dosyć subtelna. Polega na tym, iż deklaracja tablicy użyta jako parametr bez typu indeksu jest tablicą otwartą, natomiast tablica bez indeksu, deklarowana jako zmienna lokalna, glo- balna, pole klasy lub nowy typ danych jest tablicą dlynamiczną. Do funkcji (lub procedury) deklarującej swój argument jako tablicę otwartą można przekazywać tablice dynamiczne. Funkcja ma wtedy dostęp do elementów tablicy dy- namicznej, jednak nie ma możliwości zmienić jej rozmiaru. Ponieważ tablice otwarte i dynamiczne są deklarowane identycznie, jedynym sposobem zadeklarowania para- metru jako tablicy dynamicznej jest zadeklarowanie nowego typu identyfikatora dla typu tablicy dynamicznej. Przykład takiego działania został pokazany poniżej, gdzie również wykorzystano funkcję 5WO1H NGOGPV do obliczania sumy wszystkich ele- mentów tablicy dynamicznej Data. Ciąg liczb w prosty sposób czytany jest z pliku: RTQEGFWTG6(QTO$WVVQP NKEM 5GPFGT61DLGEV  XCT  CVCCTTC[QH QWDNGVCDNKECF[PCOKEPCRTGEJQOYWLæEC YCTVQħEKV[RW QWDNG (6GZV(KNG 8CNWG QWDNG ++PVGIGT DGIKP #UUKIP(KNG (  FCPGFCV  4GUGV (  + YJKNGPQV 1( ( FQ DGIKP 4GCF.P (8CNWG  5GV.GPIVJ CVC.GPIVJ CVC   74 ABC Delphi 6  CVC=+?8CNWG 4KEJ FKV.KPGU#FF (NQCV6Q5VT CVC=+?  ++  GPF  NQUG(KNG (   FKV6GZV(NQCV6Q5VT 5WO1H NGOGPV CVC  GPF Typ OleVariant Jako przykład zastosowania w programie typu OleVariant pokażemy, w jaki sposób bardzo szybko można stworzyć klienta OLE, wyświetlającego aktualną wersję zain- stalowanego w systemie PowerPointa, i ewentualnie z poziomu kodu Delphi urucho- mić go. Technologia OLE (ang. Object Linking and Embedding) umożliwia osadzanie, łą- czenie i wzajemną wymianę różnych obiektów danych przy jednoczesnej pracy wie- lu aplikacji Windows (OLE 2). Ole Automation jest częścią standardu OLE 2. Umożliwia zapisywanie w aplikacji sekwencji działań OLE w postaci ciągu poleceń, które dany program ma zinterpre- tować. Component Object Model, w skrócie COM jest standardem, pozwalającym współ- dzielić obiekty pomiędzy wiele aplikacji. Określa też zasady komunikacji pomiędzy obiektami. Obiekty takie muszą być rozróżniane już na poziomie systemu opera- cyjnego. Przejdźmy do karty Servers, zawierającej kilkadziesiąt elastycznych klas, służących do wizualizacji aktualnie dostępnych w systemie serewerów COM. Zaprojektujmy naprawdę prostą aplikację, składającą się z jednego komponentu re- prezentującego klasę TPowerPointApplication, jednego reprezentującego klasę TRi- chEdit oraz trzech TButton, tak jak przedstawiono to na rysunku 4.9. Rysunek 4.9. Aplikacja wykorzystująca przykładowy egzemplarz klasy TPowerPointApplication z karty Servers W najprostszym przypadku w celu ustanowienia połączenia z wybra
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ABC Delphi 6
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ą: