Rozdział 4.
Środowisko zintegrowane (IDE)

Pierwszym krokiem w poznawaniu nowego środowiska programistycznego jest zapoznanie się z ogólną filozofią działania tego środowiska, ze strukturą menu oraz znaczeniem poszczególnych opcji. Jeżeli spotykasz się z Object Pascalem po raz pierwszy, masz utrudnione zadanie: musisz poznać nowy program (Delphi IDE) oraz jednocześnie nauczyć się nowego języka. Może to być czasem bardzo trudne. Ze swojej strony uczynię wszystko, żeby nauka IDE była dla Ciebie przyjemnością. Będzie to przede wszystkim nauka na przykładach, co uczyni ją, mam nadzieję, interesującą i efektywną.

Delphi IDE

Jeżeli masz już doświadczenie z Delphi, możesz uznać ten rozdział za mało interesujący. Jeżeli tak jest, przejrzyj go przynajmniej pobieżnie. Może znajdziesz w nim coś, czego akurat nie wiedziałeś, szczególnie jeśli chodzi o nowości wprowadzone dopiero w wersji 4.

Na Delphi IDE składają się z następujące elementy:

• Menu główne i paski narzędzi

• Paleta komponentów

• Projektant Formularzy

• Edytor Kodu

• Inspektor Obiektów

• Eksplorator Kodu

• Menedżer Projektów

Rysunek 4.1. Środowisko zintegrowane Delphi 4

Omówienie tych wszystkich części składowych zajmie mi kilka następnych rozdziałów. W tym rozdziale omówię projekty i sposoby ich używania przy pisaniu aplikacji Delphi. Następnie zajmiemy się paskami narzędzi i Paletą Komponentów. Szczegółowe omówienie formularzy zostawiam na koniec.

Czytając ten rozdział będziesz jednocześnie pisał przykładowe programy ilustrujące poszczególne zagadnienia. Przyjrzysz się także bliżej Inspektorowi Obiektów. Będzie to rozgrzewka do rozdziału 6. „Praca z Projektantem Formularzy i Projektantem Menu”, w którym poznasz Projektanta Formularzy od podszewki. Pod koniec bieżącego rozdziału dowiesz się, co to są okna dokowalne IDE. Pozwalają one dostosować IDE do własnych potrzeb i stylu pracy.

Projekty

Jak już wiesz, cała masa rzeczy dzieje się w tle podczas pisania aplikacji w Delphi. Jest tego dużo więcej, niż mogłeś przypuszczać wnioskując z dotychczasowej lektury. Znajomość szczegółów nie jest konieczna, jeżeli chodzi o tworzenie aplikacji, jednak dobrze jest mieć ogólne pojęcie o tych wszystkich ukrytych mechanizmach.

Projekt jest to zestaw plików wzajemnie ze sobą powiązanych, które po kompilacji składają się na program wykonywalny albo bibliotekę DLL.

Oprócz pojedynczych projektów, Delphi umożliwia tworzenie tzw. grup projektów. Grupa projektów jest to zestaw powiązanych projektów Delphi.

Grupa projektów służy do zarządzania projektami Delphi, które składają się na określony produkt software'owy (pakiet). Grupy projektów omówię bardziej szczegółowo w rozdziale 9. „Projekty, Edytor Kodu i Eksplorator Kodu”. Na razie trzeba Ci wiedzieć, że Delphi przy każdym uruchomieniu tworzy nową (bez nazwy) grupę projektów (jeżeli nie włączyłeś opcji zachowywania obszaru roboczego przy wyjściu z Delphi). Każdy nowy projekt automatycznie włączony będzie do tej grupy. Jeżeli chcesz, możesz tę grupę projektów zapisać na dysk.

Pliki używane w projektach

Delphi zarządza projektami używając do tego kilku plików pomocniczych. Żeby zobaczyć, co się dzieje w czasie tworzenia nowego pliku wykonywalnego, stwórzmy prostą aplikację:

1. Utwórz na dysku nowy katalog, gdzie będą zapisywane wszystkie pliki projektu (nadaj mu dowolnie wybraną nazwę).

2. Wybierz z menu File | Close All żeby się upewnić, że nie ma żadnych otwartych plików ani projektów. Następnie wybierz File | New Application, aby utworzyć nową aplikację.

3. Wybierz opcję File | Save All. Otworzy się okienko z pytaniem o nazwę pliku źródłowego modułu. W polu „Zapisz w” wskaż utworzony przed chwilą katalog.

4. W polu „Nazwa pliku” wpisz MojModul. i naciśnij przycisk „Zapisz”.

5. Teraz musisz podać nazwę projektu. W polu „Nazwa pliku” wpisz Test i ponownie naciśnij przycisk „Zapisz”.

6. Wybierz z menu Project | Build Test. Delphi skompiluje program (zajmie to kilka sekund).

7. Wybierz File | Close All.

8. Uruchom teraz Eksploratora Windows i wyszukaj katalog z plikami projektu. Znajdziesz ich tam kilka.

W katalogu tym powinno być około ośmiu plików (dokładna ich liczba zależy od ustawień IDE). Pozwól, że najpierw powiem, co się dokładnie dzieje w czasie kompilacji projektu. Potem objaśnię, jakie znaczenie mają poszczególne pliki.

Pliki z rozszerzeniem rozpoczynającym się od znaku tyldy (∼) są kopiami zapasowymi. Delphi może utworzyć kilka kopii zapasowych zależnie od liczby plików źródłowych w projekcie i od ustawień poszczególnych opcji projektu. Opcje projektu opisane są w rozdziale 9.

Przy tworzeniu nowego projektu Delphi zakłada minimum 4 pliki (jeżeli jest to typowa aplikacja GUI):

• Plik źródłowy projektu

• Moduł formularza głównego

• Plik zasobów formularza głównego

• Plik zasobów projektu

Plik źródłowy projektu zawiera kod, który jest wykonywany przy uruchamianiu aplikacji. Plik ten można wyświetlić wybierając opcję Project | View Source z menu głównego. Moduł formularza głównego zawiera deklarację i definicję klasy formularza głównego. Dla każdego stworzonego przez Ciebie formularza Delphi utworzy dodatkowy plik modułu. Plik. Plik zasobów formularza głównego oraz plik zasobów projektu są to pliki binarne zawierające opis formularza głównego i ikony aplikacji.

Po wydaniu polecenia kompilacji projektu, Delphi kompiluje plik źródłowy projektu, moduł formularza głównego i wszystkie pozostałe moduły włączone do projektu. Proces ten można podzielić na kilka etapów. W pierwszym etapie kompilator Object Pascala kompiluje moduły do plików binarnych .OBJ. Następnie kompilator zasobów kompiluje wszystkie zasoby, m. in. ikonę programu i pliki formularzy, do postaci binarnych plików zasobów. W następnym etapie wkracza do akcji konsolidator („linker”). Łączy on pliki binarne utworzone przez kompilator z potrzebnymi bibliotekami i generuje ostateczny plik wykonywalny, który może być uruchamiany przez użytkownika komputera.

Tabela 4.1 zawiera listę typów plików używanych przez Delphi wraz z opisem roli, jaką każdy z nich odgrywa w procesie budowania aplikacji.

Oprócz powyższych, istnieją w Delphi także inne typy plików. Na przykład, rozszerzenie .bpg oznacza grupę projektów, .dpk używane jest do oznaczenia pliku źródłowego pakietu, natomiast .bpl oznacza skompilowany pakiet. Pakiety omówione są szerzej w rozdziale 8. „Tworzenie aplikacji”, natomiast grupy projektów omówione są w rozdziale 9.

Wszystkie te typy plików można podzielić na dwie kategorie: pliki, które zawierają dane wejściowe dla aplikacji oraz pliki, które tworzone są przez Delphi podczas różnych etapów kompilacji. Gdybyś chciał przenieść pliki źródłowe aplikacji na inny komputer, wystarczyłoby jedynie przenieść pliki zawierające dane wejściowe. Są one z reguły objętościowo mniejsze od tych drugich, więc ich archiwizacja na przykład na dysku nie zajęłaby wiele miejsca.

Niezbędne są tylko pliki .pas, .dfm i .dpr. Wszystkie pozostałe zostaną odtworzone podczas ponownej kompilacji. Oprócz tego, jeżeli chcesz zachować ustawienia obszaru roboczego, musisz również zabezpieczyć plik .dsk.

Tabela 4.1. Typy plików używanych w Delphi

Rozszerzenie	Opis
.pas	Plik źródłowy modułu. Zawiera jego kod źródłowy (każdy moduł ma swój plik źródłowy)
.dfm	Plik formularza. Jest to właściwie zakamuflowany binarny plik zasobów (.res). Zawiera opis formularza i umieszczonych na nim komponentów. Każdy formularz posiada swój własny plik .dfm
.dsk	Plik obszaru roboczego projektu. Zawiera on informacje na temat wyglądu obszaru roboczego podczas ostatniego zachowywania lub zamykania projektu. Zapisywane są w nim rozmiary i umiejscowienie wszystkich okien, dzięki czemu projekt po ponownym otwarciu wygląda dokładnie tak, jak w momencie zamykania. Plik ten jest tworzony tylko wtedy, gdy opcja zachowywania obszaru roboczego jest włączona
.dof	Plik opcji projektu. Zawiera ustawienia wszystkich opcji z okna dialogowego Project Options
.exe	Wynikowy program wykonywalny
.cfg	Plik konfiguracyjny projektu. Zawiera głównie ustawienia kompilatora i konsolidatora
.dcu	Binarne pliki wynikowe kompilatora (skompilowane moduły)
.dpr	Plik źródłowy projektu
.res	Skompilowany binarny plik zasobów

Oprócz plików źródłowych, o których wspomniałem wcześniej, istnieją także skrypty zasobów (mają one rozszerzenie .rc). Są to pliki tekstowe używane do definiowania takich zasobów jak bitmapy, ikony lub kursory. Jeżeli używasz takich plików, zachowuj je razem z innymi plikami danych wejściowych. Skrypty zasobów są raczej rzadko używane w Delphi.

Rysunek 4.2 obrazuje przebieg kompilacji i łączenia plików źródłowych do postaci finalnego programu wykonywalnego.

Jeżeli masz mało miejsca na dysku twardym, możesz skasować część plików z projektów, nad którymi akurat nie pracujesz. Można na przykład usunąć pliki .dcu. Delphi może je w każdej chwili odtworzyć.

Nie kasuj żadnych plików z katalogów, w których zainstalowałeś Delphi, poza katalogiem EXAMPLES. Pamiętaj o zdrowej zasadzie: Jeżeli masz jakieś wątpliwości - nie kasuj.

Rysunek 4.2. Proces kompilacji i łączenia

Pliki źródłowe modułów

Jak już wcześniej wspomniałem, każda aplikacja Delphi (z interfejsem graficznym) posiada kilka plików źródłowych, nazywanych modułami. Za każdym razem, kiedy tworzysz nowy formularz, Delphi wykonuje następujące kroki:

• Tworzy plik formularza (.dfm)

• Tworzy nową klasę - potomek klasy TForm

• Tworzy plik źródłowy (.pas) zawierający definicję tej klasy

• Dodaje informacje o nowym formularzu do pliku źródłowego projektu

Delphi nadaje nowo utworzonemu formularzowi domyślną nazwę Form1, a plikowi źródłowemu odpowiadającego mu modułu nadaje nazwę Unit1.pas. Następny formularz utworzony w projekcie będzie miał nazwę Form2, itd. Dla każdego nowo utworzonego formularza Delphi tworzy nową parę plików: .pas i .dfm.

Zaraz po utworzeniu nowego projektu dobrze jest zapisać go na dysk nadając mu jakąś znaczącą nazwę. To samo odnosi się do każdego nowo utworzonego formularza. Ułatwia to późniejszą ich lokalizację i identyfikację. Sprawę ułatwia dodatkowo fakt, że moduły mogą mieć długie nazwy.

Pisząc tę książkę często staję przed następującym problemem: aby ułatwić zrozumienie pewnych zagadnień, często muszę przytaczać odpowiednie przykłady. W przykładach tych muszę czasami używać technik czy metod jeszcze nie omawianych. Nie mogę jednak omówić tych metod nie dając przedtem kilku odpowiednich przykładów. I koło się zamyka. Zamierzam więc teraz zboczyć trochę z tematu i omówić menu główne, paski narzędzi i paletę komponentów. To odejście od głównego wątku ma jednak swój cel.

Menu główne i paski narzędzi

Menu główne zawiera wszystkie opcje niezbędne do pracy. Ponieważ jednak programowanie w Delphi jest wysoce „wizualne", nie ma potrzeby używania menu tak często, jak w innych środowiskach programistycznych. Jeżeli mimo to preferujesz używanie menu głównego, znajdziesz tam wszystko, co potrzebne. Nie będę teraz szczegółowo omawiał wszystkich dostępnych opcji. Zetkniesz się z każdą z nich podczas lektury kilku następnych rozdziałów.

Paski narzędzi zawierają bardzo wygodne skróty do często powtarzanych poleceń. Łatwiej odnaleźć przycisk na pasku niż jakąś głęboko ukrytą opcję w menu, nie mówiąc już o tym, że wymaga to mniej ruchów myszą. Paski narzędzi Delphi pokazane są na rysunku 4.3 (Paleta Komponentów została usunięta dla zwiększenia przejrzystości).

Rysunek 4.3. Paski narzędzi

Mnie często zdarza się zapominać o istnieniu tych pasków mimo, że są one naprawdę użyteczne. Stare przysłowie mówi: „Rób tak, jak mówię, a nie tak, jak robię”. Jeżeli teraz poświęcisz trochę czasu na naukę korzystania z pasków, pozwolą Ci one zaoszczędzić mnóstwo czasu w przyszłości. Kupiłeś przecież Delphi między innymi po to, żeby pisać aplikacje Windows naprawdę szybko.

Paski narzędzi można dostosować do swoich upodobań. Można je umieścić w dowolnym miejscu w oknie głównym Delphi, podobnie jak menu główne i Paletę Komponentów.

Można bardzo łatwo dodawać, usuwać i zmieniać kolejność przycisków na pasku narzędzi. W tym celu należy umieścić kursor na pasku i nacisnąć lewy klawisz myszy. Z menu kontekstowego należy wybrać opcję Customize (dostosuj). Po wybraniu tej opcji otworzy się okno dialogowe.

Rysunek 4.4. Dostosowywanie pasków narzędzi

Okno dialogowe Customize posiada trzy karty:

• Na pierwszej karcie, Toolbars, widać listę dostępnych pasków narzędzi z zaznaczonymi wyświetlonymi paskami. Można je dodawać i usuwać z listy, a także przywrócić ich domyślne ustawienia.

• Druga karta - Commands - zawiera wszystkie dostępne przyciski. Żeby umieścić przycisk na pasku narzędzi, wystarczy przeciągnąć go na odpowiednie miejsce. Żeby zaś usunąć przycisk z paska, należy go chwycić i upuścić poza obszarem paska. Na rysunku 4.4 widać umieszczanie przycisku na pasku narzędzi. Jeżeli za mocno sobie namieszasz w tych wszystkich paskach, wystarczy na karcie Toolbars użyć przycisku Reset. Paski narzędzi powrócą wtedy do swej domyślnej postaci.

• Na trzeciej karcie - Options - można włączać i konfigurować podpowiedzi pojawiające się po umieszczeniu kursora nad przyciskiem.

IDE istnieje po to, żeby ułatwiać Ci życie, więc skonfiguruj je sobie stosownie do potrzeb.

Używanie Palety Komponentów

Paleta Komponentów służy do wybierania komponentów albo innych kontrolek (na przykład kontrolek ActiveX)w celu umieszczenia ich na formularzu. Paleta ta składa się z wielu kart. Kliknięcie na odpowiedniej zakładce powoduje otwarcie odpowiadającej jej karty.

Proces umieszczania komponentu na formularzu składa się z dwóch kroków. Pierwszym krokiem jest wybranie odpowiedniego komponentu, drugim zaś jest umieszczenie tego komponentu na formularzu (przy pomocy myszy).

W podstawowym zakresie używałeś Palety Komponentów już wcześniej. Niżej opiszę jej bardziej zaawansowane możliwości.

Umieszczanie wielu kopii danego komponentu na formularzu

Do tej pory umieszczałeś na formularzu komponenty wybierając je z Palety, a następnie przenosząc je w miejsce umieszczenia. Wiele komponentów tego samego typu można umieszczać na formularzu bez konieczności każdorazowego wybierania go z palety. Aby to zrobić, należy podczas wybierania komponentu na palecie nacisnąć klawisz Shift (po wybraniu komponentu można puścić ten klawisz).

Przycisk wybranego komponentu na palecie będzie wciśnięty i będzie miał niebieską ramkę. Kliknij teraz na formularzu. Pokaże się na nim wybrany komponent. Zwróć uwagę, że przycisk na formularzu jest nadal wciśnięty. Możesz teraz pojedynczymi kliknięciami myszy dodawać nowe komponenty. Żeby wyłączyć tę funkcję, trzeba nacisnąć na palecie komponentów przycisk ze strzałką (narzędzie wybierania komponentów). Przycisk komponentu zostanie zwolniony.

Przekonaj się sam, jak to działa. Wykonaj następujące czynności:

1. Utwórz nowy projekt.

9. Naciśnij i przytrzymaj klawisz Shift. Jednocześnie kliknij na komponencie Label na Palecie Komponentów.

10. Trzykrotnie kliknij na formularzu, zmieniając za każdym razem położenie kursora. Przy każdym kliknięciu na formularzu umieszczona zostaje nowa etykieta.

11. Kliknij na przycisku ze strzałką, aby zakończyć ten proces i powrócić do trybu projektowania formularza.

Najszybciej rozmieszcza się komponenty na formularzu stosując właśnie tę technikę. Zawsze potem będzie je można poustawiać i dopasować.

Często zdarza się zapomnieć o naciśnięciu przycisku za strzałką po zakończeniu rozmieszczania komponentów. Jeżeli przypadkowo umieścisz na formularzu więcej komponentów niż zamierzałeś, zawsze możesz skasować te niepotrzebne.

Umieszczanie komponentów na środku formularza

Kolejną sztuczką wykorzystywaną przy projektowaniu formularza jest podwójne kliknięcie na komponencie w Palecie. Komponent ten zostanie wtedy automatycznie umieszczony na środku formularza. Można go będzie oczywiście przesunąć na odpowiednie miejsce.

Jeżeli kilkakrotnie klikniesz podwójnie na danym komponencie w Palecie, w centrum formularza umieszczonych zostanie kilka jego kopii, jeden na drugim, Będą one wszystkie miały domyślny rozmiar, więc czasami możesz sobie nie zdawać sprawy, że pod widocznym komponentem kryją się następne. Jeżeli zdarzy Ci się taka sytuacja, po prostu skasuj niepotrzebne kopie.

Menu kontekstowe palety komponentów

Jeżeli umieścisz kursor na palecie komponentów i naciśniesz prawy klawisz myszy, otworzy się menu kontekstowe Palety Komponentów (patrz rysunek 4.5).

Rysunek 4.5. Menu kontekstowe palety komponentów

Opcja Show Hints włącza i wyłącza podpowiedzi pojawiające się po zatrzymaniu kursora nad poszczególnymi komponentami w Palecie. Powinna ona być włączona, chyba że naprawdę przeszkadzają Ci te podpowiedzi. Opcja Hide ukrywa Paletę Komponentów (powoduje, że staje się ona niewidoczna). Żeby pokazać ponownie Paletę Komponentów, należy wybrać opcję Component Palette z menu kontekstowego pasków narzędzi.

Wybranie opcji Help z menu kontekstowego Palety Komponentów wyświetla na ekranie pomoc Delphi na temat tej palety. Opcja Properties (właściwości) wywołuje okno dialogowe, w którym można zmieniać ustawienia Palety. Można tam dodawać i usuwać poszczególne karty palety komponentów, można także zmieniać uporządkowanie komponentów na poszczególnych kartach. Szczegółowo zajmiemy się tymi ustawieniami w rozdziale 11. „Narzędzia i opcje Delphi”, którego tematem będą m. in. poszczególne ustawienia środowiska.

Poruszanie się po Palecie Komponentów

Jeżeli paleta komponentów jest tak skonfigurowana, że nie widać na ekranie wszystkich jej zakładek, można dostać się do tych niewidocznych przy pomocy przycisków przewijania umiejscowionych w prawym górnym rogu palety. Tak samo jest w przypadku poszczególnych kart - jeżeli komponenty nie mieszczą się na ekranie, kliknięcie na przyciskach przewijania (są to małe trójkąty widoczne blisko krawędzi palety) powoduje przewinięcie karty i wyświetlenie komponentów dotychczas niewidocznych. Rysunek 4.6 pokazuje paletę komponentów z widocznymi dwoma typami przycisków przewijania.

Rysunek 4.6. Przyciski przewijania palety komponentów

Korzystanie z Palety Komponentów nie jest wcale skomplikowane, a jej opanowanie jest niezbędne przy programowaniu w Delphi. Teraz, kiedy mamy już za sobą ten krótki przegląd głównego okna Delphi, możemy wrócić do głównego tematu tego rozdziału.

Aplikacja składająca się
z wielu formularzy

Żeby zilustrować, w jaki sposób właściwie Delphi używa modułów, stwórzmy aplikację posiadającą więcej niż jeden formularz. Aplikacja ta będzie wyświetlać dodatkowy formularz po naciśnięciu przycisku na formularzu głównym:

1. Utwórz nowy projekt wybierając opcję File | New Application z głównego menu.

12. Zmień właściwość Name formularza głównego na MainForm, a właściwość Caption tego formularza na Program testowy wielu formularzy.

13. Zachowaj projekt. Zachowaj moduł jako Main, a projekt jako Multiple.

14. Umieść przycisk na formularzu. Właściwość Name tego przycisku ustaw na ShowForm2, a właściwość Caption na Pokaż drugi.

15. Wybierz z głównego menu File | New Form (albo naciśnij przycisk New Form na pasku narzędzi). Nowo utworzony formularz posiada nazwę Form1 i umieszczony jest dokładnie na formularzu głównym. Zmienimy jego rozmiar tak, żeby był trochę mniejszy od formularza głównego i znajdował się mniej więcej w jego środku.

16. Ustaw rozmiar nowego formularza tak, żeby zajmował on mniej więcej połowę obszaru formularza głównego i ustaw go na jego środku.

17. Zmień właściwość Name nowego formularza na SecondForm, a właściwość Caption zmień na Drugi formularz.

18. Wybierz File | Save z menu głównego (albo kliknij przycisk Save File na pasku narzędzi) i zachowaj ten nowy formularz pod nazwą SecondForm.

19. Umieść na formularzu SecondForm komponent Label. Ustaw właściwość Caption tej etykiety na To jest Drugi formularz. Rozmiar i kolor etykiety ustaw według własnego uznania. Wyśrodkuj tę etykietę na formularzu. Formularz powinien teraz wyglądać mniej więcej jak na rysunku 4.7.

Rysunek 4.7. Wygląd drugiego formularza

20. Kliknij na głównym formularzu. Wysunie się on na pierwszy plan przykrywając drugi formularz. Kliknij podwójnie na przycisku Pokaż drugi. Otworzy się Edytor Kodu z kursorem umieszczonym w procedurze obsługi zdarzenia OnClick tego przycisku.

21. Zmodyfikuj procedurę TMainForm.ShowForm2Click tak, żeby wyglądała ona następująco:

procedure TMainForm.ShowForm2Click(Sender: TObject);

begin

SecondForm.ShowModal;

end;

22. Uruchom program.

Po uruchomieniu programu na ekranie zostanie wyświetlony komunikat: Form 'FormGlowny' references form 'DrugiFormularz' declared in unit 'Drugi' which is not in your USES list. Do you wish to add it? Kliknij „Tak”. Delphi doda moduł Second do listy uses modułu Main. Uruchom program ponownie, tym razem powinien uruchomić się bez problemu. Jeżeli klikniesz teraz na przycisku Pokaż drugi, drugi formularz zostanie wyświetlony na ekranie. Można go będzie zamknąć klikając na ikonie systemowej umieszczonej w prawym górnym rogu formularza.

Dodawanie modułów

Zamiast pozostawiać Delphi obowiązek dodawania odpowiednich modułów do listy uses, lepiej robić to samemu. Można wpisać wprost w Edytorze Kodu nazwę modułu do listy uses, albo można użyć opcji File | Use Unit z głównego menu. W tym drugim przypadku zostanie wyświetlone okno dialogowe Use Unit (pokazane na rysunku 4.8). Okno to pokazuje listę dostępnych modułów. Aby dodać moduł do listy uses, należy wybrać go z listy (kliknąć na jego nazwie) i kliknąć OK. Delphi doda nazwę tego modułu do listy uses bieżącego formularza. Zwróć uwagę, że lista dostępnych modułów zawiera tylko te, które istnieją w bieżącym projekcie i nie zostały jeszcze dodane do listy uses. Modułów, które wcześniej zostały wpisane na listę uses, nie ma w oknie Use Unit.

Rysunek 4.8. Okno dialogowe Use Unit

Jak widzisz, Delphi jest bardzo pomocne w zarządzaniu modułami. Później, kiedy Twoje potrzeby w tym względzie staną się znacznie większe, będziesz musiał robić własnoręcznie trochę więcej, ale na etapie, na którym jesteś obecnie, Delphi robi prawie wszystko za Ciebie.

Spójrzmy teraz na dostępne opcje dotyczące kompilacji dostępne w czasie pisania programów.

Kompilowanie, budowanie i łączenie

Po każdym naciśnięciu przycisku Run, Delphi kompiluje i łączy Twoją aplikację. Nie musi jednak kompilować wszystkich modułów w projekcie. Kompiluje tylko te, które zmieniły się od czasu ostatniej kompilacji. Oszczędza to sporo czasu, gdyż nie jest on niepotrzebnie tracony na kompilowanie w kółko tego samego. Określanie, czy dany moduł zmienił się od ostatniej kompilacji, czy nie, odbywa się całkowicie automatycznie.

Z reguły w czasie pisania programu wprowadzasz jakieś poprawki i chcesz na bieżąco sprawdzać ich efekt. Naciskasz wtedy przycisk Run i program jest kompilowany, łączony i wykonywany. Czasami jednak nie chcesz uruchamiać programu. Na przykład, chcesz tylko sprawdzić, czy w kodzie źródłowym nie ma błędów składniowych.

Oprócz opcji Run Delphi posiada jeszcze trzy dodatkowe opcje, które pozwalają Ci kontrolować proces kompilacji i łączenia. Jeżeli wybierzesz z menu głównego opcję Project, otworzy się podmenu zawierające trzy wyżej wspomniane opcje: Compile (kompiluj), Build (odbuduj) i Syntax Check (sprawdź składnię). Opcje te są uzupełnione nazwą bieżącego projektu - przykładowo, zaraz po uruchomieniu Delphi opcje te będą brzmieć: Compile Project1, Build Project1 i Syntax Check Project1. Są tam także opcje Compile All Projects (kompiluj wszystkie projekty) i Build All Projects (odbuduj wszystkie projekty), jednak omówię je dopiero w rozdziale 9 przy okazji omawiania grup projektów.

Rozważmy te opcje po kolei od najprostszej do najbardziej skomplikowanej (z punktu widzenia kompilatora).

• Opcja Syntax Check jest bardzo wygodna. Po jej wybraniu następuje kompilacja projektu i wypisanie wszystkich błędów i ostrzeżeń. Jest to najszybszy sposób na sprawdzenie, czy w kodzie nie występują błędy składniowe. Delphi tylko kompiluje projekt - nie przeprowadza łączenia - opcja ta działa dzięki temu bardzo szybko.

• Opcja Compile kompiluje te moduły, których zawartość zmieniła się od czasu ostatniej kompilacji (tak jak robi to Syntax Check), a także przeprowadza łączenie całego projektu - dlatego trwa to trochę dłużej niż sprawdzenie składni. Opcji Compile używa się, żeby mieć pewność, że cały projekt prawidłowo się skompiluje i skonsoliduje (nie następuje tu uruchamianie programu).

Skrót klawiaturowy opcji Compile to Ctrl+F9.

• Opcja Build wykonuje się najdłużej. Uruchomienie jej powoduje kompilację każdego modułu źródłowego w projekcie, niezależnie od tego, czy jego zawartość zmieniła się od czasu ostatniej kompilacji, czy też nie. Po skompilowaniu całości, przeprowadzane jest łączenie całego projektu.

Do tej pory pozwalałeś Delphi dodawać moduły do swojego projektu. W miarę jak będziesz stawał się coraz bardziej zaawansowanym użytkownikiem Delphi, będziesz pewnie edytować własnoręcznie pliki źródłowe, np. żeby dodać jakieś dyrektywy kompilatora. Może nawet będziesz ingerować w główny plik źródłowy projektu. Może się wówczas zdarzyć (wszyscy w końcu popełniamy błędy), że za którymś razem projekt nie będzie chciał się skompilować. Przeprowadzenie odbudowywania aplikacji sprawi, że wszystkie pliki zostaną uaktualnione, co może ułatwić zlokalizowanie problemu. Czasami samo wykonanie tej czynności naprawia błędy zgłaszane przez kompilator i konsolidator.

Za każdym razem, kiedy kompilator będzie zgłaszał jakieś nieoczekiwane błędy, spróbuj najpierw uruchomić opcję Build. Wystarczy czasami, że jakiś plik zostanie uaktualniony, i problem znika. Jeżeli jednak ta operacja nie pomaga, jedynym wyjściem jest wówczas analiza kodu i „ręczne” lokalizowanie błędu.

Delphi umożliwia obserwację na bieżąco postępów kompilacji w specjalnym oknie (jego wyświetlanie można włączyć poprzez Tools | Environment Options - karta Preferences - opcja Show compiler progress). Okno statusu kompilacji wyświetla nazwę każdego aktualnie kompilowanego modułu. Jeżeli podczas kompilacji wystąpiły jakieś błędy, widoczny będzie komunikat There are errors wraz z podaną liczbą błędów i ostrzeżeń.

Na rysunku 4.9 pokazane jest okno statusu kompilacji po wykryciu błędów. Delphi kompiluje projekty tak szybko, że okno to nie jest właściwie potrzebne. Włączenie tego okna powoduje tylko wydłużenie czasu kompilacji ze względu na konieczność wyświetlania informacji na ekranie.

Rysunek 4.9. Okno statusu kompilacji

Bez względu na wybraną metodę kompilacji (Compile, Build czy Syntax Check), jeżeli zostały wykryte jakieś błędy, otworzy się Edytor Kodu wraz z oknem Message, w którym wyświetlona będzie lista błędów i ostrzeżeń. Linia kodu zawierająca pierwszy błąd będzie podświetlona.

Kompilacja innych rodzajów programów w Object Pascalu

Cała siła Delphi leży w jego wizualnym środowisku programowania. Jest to środowisko ściśle i nierozdzielnie związane z biblioteką VCL. W Delphi pisze się głównie programy oparte właśnie na VCL. Oprócz tego jednak za pomocą Delphi można tworzyć także inne typy programów.

Biblioteka dołączana dynamicznie (ang. dynamic link library - DLL) jest plikiem zawierającym kod binarny, który może być wywoływany (uruchamiany) z poziomu aplikacji lub innej biblioteki DLL.

Najprawdopodobniej tym „innym” typem programu, który mógłbyś chcieć napisać, byłaby właśnie biblioteka DLL. Nazwa ta brzmi bardzo tajemniczo, ale w istocie rzeczy nie jest to zagadnienie bardzo skomplikowane: jest to po prostu skompilowany kod, który można wywoływać z poziomu innego programu. Po stworzeniu biblioteki DLL, wywołanie funkcji w niej zawartej niczym się nie różni od zwykłego wywołania funkcji. Tak to wygląda w uproszczeniu. Biblioteki DLL omówione są ze szczegółami w rozdziale 19. „Tworzenie i używanie bibliotek DLL”

Innym typem aplikacji, które można tworzyć w Delphi, są aplikacje konsoli Win32.

Aplikacja konsoli jest 32-bitowym programem uruchamianym w oknie MS-DOS systemu Windows 95 albo Windows NT.

Aplikacjami konsoli są zwykle niewielkie programy narzędziowe, serwery (np. TCP/IP albo mail) itp. Każdy program, który nie wymaga graficznego interfejsu użytkownika, jest dobrym kandydatem na aplikację konsoli.

Więcej o formularzach Delphi

Muszę w tym miejscu przerwać na chwilę omawianie IDE i zająć się formularzami. Widziałeś już do tej pory kilka formularzy w akcji, a w rozdziale 6 poznasz dokładnie Projektanta Formularzy. Zanim jednak do tego dotrzesz, chcę Ci przekazać trochę dodatkowych informacji na ten temat.

Formularze okna głównego

Formularze są głównym elementem składowym aplikacji Delphi. Każda aplikacja GUI posiada przynajmniej jeden formularz, który jest jednocześnie oknem głównym tej aplikacji. Formularz okna głównego (zwany po prostu „formularzem głównym”) może być po prostu pusty, może zawierać jakieś kontrolki, lub może na nim być wyświetlona mapa bitowa. Typowe okno główne programu w Windows posiada menu. Może oprócz tego posiadać takie elementy jak pasek narzędzi czy pasek statusu. W oknie głównym spotyka się najróżniejsze elementy, zgodnie z charakterem i potrzebami danej aplikacji.

Formularze okien dialogowych

Innym rodzajem formularzy są okna dialogowe. Użytkownik nie widzi żadnej różnicy między formularzem Delphi wyświetlonym w charakterze okna dialogowego i prawdziwym oknem dialogowym (Przez „prawdziwe okno dialogowe” rozumiem tutaj okno utworzone w tradycyjny sposób za pomocą edytora zasobów i skryptu zasobów. Tak właśnie okna dialogowe są tworzone w innych środowiskach programowania. Delphi nie używa tradycyjnych okien dialogowych, nie będziesz musiał prawdopodobnie mieć do czynienia z oknami dialogowymi na tym poziomie). Okna dialogowe posiadają kilka cech, które odróżniają je od zwykłych okien:

• Okna dialogowe mają stałe wymiary. Nie można zmieniać ich rozmiaru. Mają one do spełnienia ściśle określoną funkcję, więc zmienianie ich rozmiaru nie jest potrzebne, a czasem nawet jest szkodliwe.

• Okna dialogowe prawie zawsze posiadają przycisk OK. Niektóre posiadają przycisk Close (lub Zamknij), który spełnia tę samą funkcję. Najprostsze okna dialogowe (np. typu About), posiadają tylko przycisk OK.

• Okna dialogowe mogą także posiadać przycisk Cancel (lub Anuluj) i Help (lub Pomoc).

• Na pasku tytułowym okna dialogowego jest zwykle tylko jeden systemowy przycisk (Zamknij). Nie posiadają one przycisków Minimalizuj i Maksymalizuj.

• Niektóre okna dialogowe zawierają kilka kart z zakładkami. Po kliknięciu na danej zakładce otwiera się skojarzona z nią karta.

• W większości okien dialogowych do przemieszczania się pomiędzy kontrolkami można używać klawisza Tab.

Jak zwykle, od każdej reguły są jakieś wyjątki. Przeważająca większość okien dialogowych ma podobny charakter, ale zdarzają się też bardzo specyficzne okna służące do specyficznych celów.

Tradycyjne okna dialogowe

W programach dla Windows pisanych w Borland Pascalu albo z użyciem bibliotek takich jak OWL, okna dialogowe tworzyło się za pomocą edytora okien dialogowych. Edytory okien dialogowych w większości przypadków są narzędziami wizualnymi działającymi podobnie jak Projektant Formularzy Delphi. Po zakończeniu projektowania okna dialogowego, reprezentacja graficzna okna była konwertowana na definicję tego okna w pliku skryptowym zasobów. Jako przykład okna dialogowego może posłużyć okno przedstawione na rysunku 4.10.

Plik skryptowy zasobów jest to plik tekstowy kompilowany przez kompilator zasobów do postaci binarnego pliku zasobów.

Na rysunku 4.10 widać typowe okno dialogowe About. Zawiera ono nazwę programu i informację o prawach autorskich. Plik skryptowy dla tego okna przedstawiony jest na listingu 4.1

Rysunek 4.10. Typowe okno dialogowe About

Listing 4.1. Skrypt okna dialogowego

1: IDD_ABOUT DIALOG 58,53,194,119

2: STYLE DS._MODALFRAME or WS_POPUP |

3: WS_VISIBLE or WS_CAPTION or WS_SYSMENU

4: CAPTION 'O programie'

5: FONT 8, 'MS Sans Serif'

6: {

7: DEFPUSHBUTTON 'OK.', IDOK, 72, 96, 50, 14

8: CTEXT 'AudioVideo Player', -1, 48, 22, 128, 8

9: CTEXT 'Copyright © 1996 by NewSoftware', -1, 32, 47, 136, 8

10: CTEXT 'March 15, 1996', -1, 24, 59, 146, 8

11: CONTROL '', 99, 'button', BS_GROUPBOX |

12: WS_CHILD or WS_VISIBLE or WS_GROUP, 12, 4, 176, 70

13: }

Skrypt zasobów zawiera informacje potrzebne do utworzenia okna dialogowego w czasie wykonywania programu. Jest tam podana liczba i typ kontrolek, ich rozmiar, rozmieszczenie, atrybuty itd.

Niektórzy programiści w ogóle nie używają edytora dialogów. Wolą za to ręcznie pisać skrypty w edytorze tekstowym. Nie można co prawda im tego zabronić, ale trzeba powiedzieć, że wydajność takiego sposobu pracy jest dużo mniejsza w porównaniu z projektowaniem graficznym.

Zazwyczaj wszystkie zdefiniowane okna dialogowe aplikacji zawarte są w pojedynczym pliku skryptowym z rozszerzeniem .rc. Na określonym etapie tworzenia aplikacji skrypty te są kompilowane do plików binarnych z rozszerzeniem .res, które później są przez linker włączane do programu wykonywalnego. W czasie wykonywania programu okno to jest wyświetlane jako modalne lub nie w zależności od jego przeznaczenia. Kiedy okno jest wywoływane, Windows ładuje do pamięci odpowiedni zasób z pliku wykonywalnego, generuje okno i wyświetla je na ekranie.

Okna dialogowe Delphi

W Delphi, okna dialogowe są po prostu formularzami. Tworzy się je tak samo jak okno główne lub każde inne. Aby uniemożliwić użytkownikowi zmianę rozmiarów okna, jego właściwość BorderStyle ustawia się na bsDialog albo bsSingle. Jeżeli ustawi się tę właściwość na bsDialog, okno dialogowe będzie posiadało tylko jeden przycisk systemowy (Close) na pasku tytułowym, co jest cechą charakteryzującą tradycyjne okna dialogowe. Oprócz tego nie trzeba robić nic więcej, żeby formularz zachowywał się jak okno dialogowe. Wszystkie formularze Delphi mają wbudowany mechanizm przemieszczania się pomiędzy kontrolkami za pomocą klawisza Tab. Kolejność, w jakiej określone komponenty są zaznaczane, można określić w ich właściwości TabOrder.

Modalne okno dialogowe musi być zamknięte dla umożliwienia dalszego korzystania z aplikacji. Okno główne aplikacji jest nieaktywne, dopóki otwarte jest modalne okno dialogowe. Większość okien dialogowych stanowią okna modalne.

Niemodalne okno dialogowe pozwala użytkownikowi korzystać z aplikacji w czasie, gdy jest ono wyświetlone na ekranie. Przykładem takiego okna jest okno dialogowe Find (lub Znajdź) występujące np. w edytorach tekstu.

Każde okno dialogowe Delphi (właściwiej: każdy formularz) jest albo modalne, albo nie, w zależności od tego, w jaki sposób zostało wyświetlone. Aby wyświetlić modalne okno dialogowe, wywołuje się metodę ShowModal obiektu TForm. Do wyświetlenia niemodalnego okna dialogowego służy metoda Show.

Tworzenie formularza okna dialogowego

Dodajmy teraz okno dialogowe About („O programie”) do aplikacji składającej się z dwóch formularzy, nad którą pracowaliśmy wcześniej. Jeżeli nie masz tego projektu otwartego, wybierz z menu opcję File | Open Project albo kliknij na przycisku Open Project na pasku narzędzi i otwórz ten projekt (zachowałeś go wcześniej pod nazwą Multiple).

Delphi przechowuje listę ostatnio otwieranych plików i projektów. Jest ona dostępna po wybraniu opcji File | Reopen. Lista ta jest podzielona na dwie części. Górna część zawiera ostatnio otwierane projekty, natomiast dolna - ostatnio otwierane pojedyncze pliki. Żeby otworzyć ostatnio używany projekt, wystarczy kliknąć na odpowiedniej pozycji listy.

Najpierw dodaj przycisk na formularzu głównym, którego kliknięcie spowoduje wyświetlenie okna „O programie”:

1. Wyświetl główny formularz. Na palecie komponentów wybierz Button i umieść go na formularzu.

23. Wyrównaj dwa znajdujące się obecnie na formularzu przyciski.

24. Zmień właściwość Name nowego przycisku na AboutButton, a właściwość Caption zmień na O programie.

25. Kliknij podwójnie na przycisku AboutButton. Otworzy się Edytor Kodu. W miejscu, gdzie umieszczony jest kursor, wpisz:

AboutBox.ShowModal;

Nie stworzyłeś na razie jeszcze faktycznie tego formularza, ale gdy to zrobisz, nazwiesz go AboutBox.

Zbuduj teraz to okno dialogowe wykonując następujące kroki:

1. Utwórz nowy formularz (kliknij przycisk New Form na pasku narzędzi). Zmień wielkość tego okienka do rozmiaru typowego okna „O programie” (mniej więcej na wielkość formularza SecondForm stworzonego wcześniej).

26. Zmień właściwość Name tego formularza na AboutBox i jego właściwość Caption na O programie.

27. Znajdź w Inspektorze Obiektów właściwość BorderStyle (powyżej właściwości Caption) i zmień ją na bsDialog.

28. Umieść na formularzu 3 etykiety. Ustaw je i zmień umieszczony w nich tekst tak, żeby okno O programie przypominało to przedstawione na rysunku 4.11 (możesz oczywiście wpisać dowolny tekst). Nazwy etykiet możesz pozostawić domyślne. Nie będą one do niczego potrzebne, więc nie muszą być opisowe.

Rysunek 4.11. Formularz „O programie” z umieszczonymi etykietami

Następnie umieść na formularzu ikonę:

1. Kliknij zakładkę Additional na palecie komponentów i wybierz z niej komponent Image. Umieść go na formularzu po lewej stronie napisów.

Znak Copyright (©) ma w większości czcionek kod ASCII wynoszący 169. Aby wprowadzić ten symbol z klawiatury, na klawiaturze numerycznej wpisz liczbę 0169 trzymając jednocześnie naciśnięty klawisz Alt (upewnij się wcześniej, że NumLock jest włączony). Kiedy zwolnisz klawisz Alt, na ekranie powinien pojawić się symbol ©. W ten sposób można wprowadzać kody ASCII wszystkich znaków (trzeba zawsze wpisywać wszystkie cztery znaki - razem z wiodącymi zerami). Na przykład, żeby wpisać literę A, trzeba nacisnąć klawisz Alt, wpisać z klawiatury numerycznej liczbę 0065 i zwolnić klawisz Alt.

29. Zmień właściwość AutoSize dopiero co umieszczonego komponentu Image na True.

30. Znajdź właściwość Picture i kliknij na przycisku z trzema kropkami. Otworzy się okno dialogowe Picture Editor.

31. Kliknij przycisk Load. Otworzy się okno dialogowe File Open. Znajdź folder Borland\Shared Files\Images\Icons i wybierz jakąś ikonę z listy. Ikona, którą wybrałeś, zostanie wyświetlona w oknie Picture Editor. Kliknij OK, aby zamknąć okno Picture Editor. Wybrana ikona zostanie wyświetlona na formularzu. Zauważ, że rozmiar komponentu Image dostosował się automatycznie do wyświetlanej na nim ikony.

32. Ustaw ikonę w odpowiednim miejscu na formularzu.

W oknie dialogowym „O programie” potrzebny jest także przycisk OK.:

1. Kliknij zakładkę Additional na palecie komponentów. Wybierz z tej karty komponent BitBtn i umieść go na środku na dole formularza.

33. Właściwość Kind komponentu BitBtn ustaw na bkOK. Zauważ, że na przycisku pojawił się zielony „ptaszek”, a jego właściwość Caption zmieniła się na OK. To już wszystko, co trzeba zrobić z tym przyciskiem. Komponent BitBtn zawiera już kod zamykający formularz przy naciśnięciu przycisku OK.

Teraz pozostała już tylko kosmetyka, jeżeli chodzi o okno O programie:

1. Zlokalizuj komponent Bevel na karcie Additional palety komponentów i kliknij na nim.

34. Umieść go na formularzu, lecz nie poprzez kliknięcie, ale obrysowując myszą kształt obejmujący umieszczone wcześniej napisy. Po zakończeniu rysowania ukaże się na formularzu komponent Bevel. Możesz go teraz dokładnie ustawić i dopasować w miarę potrzeby.

35. Właściwość Shape komponentu Bevel ustaw na bsFrame. Masz teraz trójwymiarową ramkę obejmującą napisy.

Formularz powinien teraz wyglądać mniej więcej tak, jak na rysunku 4.12. Zachowaj bieżący moduł (File | Save) pod nazwą About.

Rysunek 4.12. Ukończony formularz „O programie”

Czy można już uruchomić ten program? Jeszcze nie. Trzeba dodać moduł OProgramie do listy uses formularza głównego. Wykonaj w tym celu następujące czynności:

1. Przełącz się do Edytora Kodu (naciśnij F12) i wybierz zakładkę Main.

36. Wybierz z menu File | Use Unit.

37. Wybierz z listy moduł About i kliknij OK.

Teraz program jest już gotowy. Naciśnij przycisk Run. W oknie głównym aplikacji kliknij przycisk O programie. Winieta programu zostanie wyświetlona. Zauważ, że wyświetlone okno dialogowe jest modalne (nie można przełączyć się do okna głównego aplikacji, dopóki okno to jest wyświetlone). Nie można też zmienić jego rozmiaru. Zachowuje się więc tak, jak przystało na okno dialogowe Windows.

Często używane klasy okien dialogowych (TOpenDialog, TSaveDialog, TFontDialog itp.) nie są zwykłymi formularzami Delphi. Bazują one na oknach dialogowych będących częścią Windows (zawartych w pliku COMDLG32.DLL). Klasy VCL reprezentujące te właśnie okna dialogowe są „oprawą” dla okien systemowych, oferując użytkownikowi dużo większą wygodę obsługi.

Delphi zawiera kilka predefiniowanych formularzy, które można wykorzystywać jako bazę do szybkiego projektowania swoich własnych okien dialogowych. Będą one omówione w rozdziale 8.

Okna drugorzędne a okna dialogowe

Okno drugorzędne jest to okno wywołane z poziomu okna głównego. Czy można więc określić, kiedy formularz jest oknem drugorzędnym, a kiedy oknem dialogowym? Otóż w Delphi nie ma właściwie pomiędzy nimi żadnej różnicy. Wszystkie okna są po prostu formularzami i nie ma większego sensu klasyfikować je na okna drugorzędne i okna dialogowe.

W tradycyjnych środowiskach programowania, trzeba było oddzielnie tworzyć okna dialogowe i oddzielnie okna drugorzędne. Delphi uwalnia programistę od tego ograniczenia i umożliwia traktowanie wszystkich okien jednakowo.

Model aplikacji wielodokumentowej

Jak dotąd, budowaliśmy jedynie aplikacje jednodokumentowe (SDI - Single Document Interface). Aplikacja SDI ma pojedyncze okno główne i w razie potrzeby wyświetla okna dialogowe. Nie wyświetla żadnych okien - potomków, nazywanych dokumentami.

Niektóre aplikacje tworzone są według modelu wielodokumentowego. Aplikacje MDI (ang. Multiple Document Interface) składają się z okna głównego (rodzica MDI) i okien podporządkowanych (dokumentów MDI).

Przykładami aplikacji MDI są Word, Excel, Edytor konfiguracji systemu (sysedit) czy Menedżer Programów Windows 3.1.

Jedną z najważniejszych cech charakterystycznych aplikacji MDI jest to, że okna-dokumenty zależne są od okna głównego. Można przesuwać je jedynie w obrębie okna głównego. Aplikacje MDI mają prawie zawsze w menu głównym opcję Window. Opcja ta posiada z kolei prawie zawsze podopcje Kaskada i Sąsiadująco. Kiedy okno podporządkowane jest zminimalizowane, jego ikona widoczna jest w obrębie okna - rodzica. Kiedy natomiast okno aplikacji SDI jest zminimalizowane, jego ikona jest na Pulpicie lub na Pasku Zadań.

Aby utworzyć aplikację MDI w Delphi, trzeba właściwość FormStyle formularza głównego ustawić na fsMDIform. Każde z okien podporządkowanych MDI musi swoją właściwość FormStyle mieć ustawioną na fsMDIchild. Oprócz tego ograniczenia nie ma właściwie żadnych innych.

Najważniejsze właściwości formularzy

Klasa TForm posiada bardzo dużo różnych właściwości. Niektóre z nich są mało znane i bardzo rzadko używane, inne są używane powszechnie. Omówię tutaj tylko te najpopularniejsze. Nie będę omawiał właściwości o oczywistym znaczeniu, jak Caption, Color, Left, Top, Width i Height, jeżeli nie będą posiadały jakiegoś specjalnego znaczenia, o którym powinieneś wiedzieć.

Właściwości ustawiane
w czasie projektowania aplikacji

Właściwości wymienione w tym podrozdziale mogą być ustawiane zarówno w czasie projektowania aplikacji poprzez Inspektor Obiektów, jak również w czasie jej wykonywania z poziomu kodu. Prawie wszystkie z nich mogą być także odczytywane w czasie działania programu.

ActiveControl - właściwość ta oznacza wyróżnienie danego komponentu w momencie aktywacji formularza. Na przykład, chcesz żeby dane pole edycji było aktywne w momencie wyświetlenia okna dialogowego. W czasie projektowania formularza dostępna jest list umieszczonych na nim komponentów, z których jeden można ustawić jako aktywny.

AutoScroll, HorzScrollBar i VertScrollBar - te trzy właściwości odpowiadają za paski przewijania formularza. Jeżeli właściwość AutoScroll ma wartość True (ustawienie domyślne) i formularz jest za mały, żeby pomieścić wszystkie umieszczone na nim komponenty, automatycznie pojawiają się na jego dolnej i prawej krawędzi paski przewijania. Właściwości HorzScrollBar i VertScrollBar mają zestaw własnych właściwości, które określają ich działanie.

BorderIcons - właściwość ta określa, które z systemowych przycisków mają się pojawić na pasku tytułowym formularza podczas działania programu. Do wyboru są: menu systemowe, przycisk minimalizacji, przycisk maksymalizacji i przycisk pomocy.

BorderStyle - za pomocą tej właściwości ustawia się typ ramki, którą będzie posiadał formularz podczas wykonywania programu. Wartość domyślna to bsSizeable co oznacza, że rozmiar i położenie formularza będą mogły być zmieniane przez użytkownika programu. Style ramki, w których zmiana rozmiarów okna nie będzie możliwa, to bsDialog i bsNone.

ClientWidth i ClientHeight - zamiast określać szerokość i wysokość całego formularza, można ustawić wymiary jego obszaru klienckiego (obszaru wewnątrz ramki i poniżej paska tytułowego i paska menu). Przypisanie wartości tym właściwościom powoduje, że wymiary całego okna dopasowują się automatycznie.


Constrains - właściwość ta używana jest do określania minimalnej i maksymalnej szerokości i wysokości formularza. Poszczególne wartości ustala się wpisując je wprost do właściwości MaxHeight, MaxWidth, MinHeight i MinWidth.


DefaultMonitor - właściwość ta używana jest do określenia, na którym monitorze ma być wyświetlony dany formularz (w środowisku z więcej niż jednym monitorem - np. Windows 98).

DockSite - właściwość ta stanowi o tym, czy w danym formularzu można dokować komponenty. Miejsca dokowania i dokowalne komponenty omówione są w rozdziale 13.

Font - właściwość ta określa, jakich czcionek używa dany formularz. Ważne jest to, że właściwość tę dziedziczą wszystkie komponenty umieszczane na formularzu. Oznacza to także, że można zmienić czcionkę wszystkich komponentów na formularzu zmieniając jedynie właściwość Font formularza. Jeżeli „ręcznie” zmieni się właściwość Font któregoś z komponentów na formularzu, nie będzie się ona już zmieniać wraz ze zmianą czcionki formularza.

FormStyle - właściwość ta zwykle ustawiona jest na fsNormal. Jeżeli wymagane jest, aby dany formularz pozostawał zawsze na wierzchu, należy ustawić tę właściwość na fsStayOnTop. Formularze MDI muszą mieć właściwość FormStyle ustawioną na fsMDIForm, a formularze podporządkowane MDI - fsMDIChild. Aplikacje MDI były omówione w rozdziale „Model aplikacji wielodokumentowej”.

HelpContext i HelpFile - właściwość HelpContext używana jest do ustawiania identyfikatora pomocy kontekstowej dla danego formularza. Jeżeli pomoc kontekstowa jest włączona, po naciśnięciu klawisza F1 uaktywni się System Pomocy Windows. Identyfikator jest potrzebny do określenia, która strona pliku pomocy ma być wyświetlona. Właściwość HelpFile zawiera nazwę pliku pomocy użytego po naciśnięciu klawisza F1.

Icon - właściwość ta ustawia ikonę wyświetloną na pasku tytułowym formularza w czasie wykonywania programu oraz na pasku zadań, w czasie gdy program jest zminimalizowany. Czasem jednak właściwość ta jest ignorowana, np. gdy FormStyle ustawiony jest na fsDialog.

KeyPreview - gdy właściwość ta ma wartość True, będzie generowane zdarzenie formularza OnKeyPress i OnKeyDown, gdy użytkownik naciśnie jakiś klawisz w którymkolwiek komponencie na formularzu. Normalnie, formularze nie otrzymują informacji o zdarzeniach pochodzących z klawiatury, kiedy jakiś komponent na formularzu jest aktywny.

Position - właściwość ta określa początkowy rozmiar i pozycję formularza na ekranie. Można wybrać jedną z trzech wartości: poDesigned, poDefault i poScreenCenter:

• ustawienie poDesigned oznacza, że formularz będzie dokładnie tak ustawiony, jak podczas jego projektowania.

• poDefault umożliwia systemowi Windows ustawienie rozmiaru i pozycji formularza według specjalnego algorytmu (Z-ordering) - nowe okno jest wyświetlane trochę poniżej i na prawo względem ostatnio wyświetlonego.

• wartość poScreenCenter oznacza wyświetlanie formularza na środku ekranu.

Visible - właściwość ta określa, czy formularz jest widoczny na ekranie. W czasie działania programu można za pomocą tej właściwości ukrywać albo wyświetlać formularz i sprawdzać aktualny stan.

WindowState - można użyć tej właściwości do odczytania aktualnego stanu formularza (czy jest zmaksymalizowany, zminimalizowany czy normalny). Właściwość ta określa także sposób, w jaki formularz ma być wyświetlony po jego utworzeniu. Dostępne wartości to wsMinimized, wsMaximized i wsNormal.

Właściwości ustawiane w czasie działania programu

Do niektórych właściwości można się odwoływać jedynie z poziomu kodu. Poniżej przedstawione są te najczęściej używane.

ActiveMDIChild - jest to właściwość tylko do odczytu. Zawiera wskaźnik do aktywnego okna podporządkowanego MDI. Jeżeli akurat nie istnieje takie okno, lub aplikacja jest typu SDI, wskaźnik ten ma wartość nil.

Canvas to obszar roboczy formularza (powierzchnia, na której można rysować bitmapy, linie, kształty czy tekst). Zwykle do wypisania tekstu używa się komponentu Label, do wyświetlania grafiki - komponentu Image, a do rysowania różnych figur - komponentu Shape, ale czasem trzeba coś narysować bezpośrednio na formularzu w czasie działania programu. Do tego służy właśnie właściwość Canvas. Właściwość ta może być także użyta do zapisania zawartości graficznej formularza na dysk. Zagadnienie to jest szerzej omówione w rozdziale 12, „Programowanie grafiki i multimediów”.

ClientRect zawiera współrzędne górnej, lewej, prawej i dolnej krawędzi obszaru klienckiego formularza. Jest to informacja użyteczna w wielu sytuacjach. Na przykład, aby umieścić bitmapę na środku formularza, trzeba odczytać szerokość i wysokość jego obszaru klienckiego.

Handle zawiera uchwyt okna (HWND) danego formularza. Jest to użyteczne przy wywołaniach funkcji Windows API.

ModalResult określa, w jaki sposób zostało zamknięte modalne okno dialogowe. Jeżeli posiada ono przycisk OK i Cancel (ew. Anuluj), można właściwości tej przypisać wartość mrOK, żeby zasymulować naciśnięcie klawisza OK i mrCancel, żeby zasymulować naciśnięcie klawisza Cancel. Można także użyć tej właściwości do sprawdzenia, w jaki sposób okno dialogowe zostało zamknięte. Inne możliwe wartości to mrYes, mrNo i mrAbort.

Owner zawiera wskaźnik do właściciela danego formularza. Właściciel formularza jest to obiekt odpowiedzialny za usunięcie tego formularza, gdy nie jest on już potrzebny. Z kolei rodzic danego komponentu jest to okno (formularz albo inny komponent), który zawiera dany komponent. W przypadku okna głównego, obiekt typu aplikacja jest zarówno właścicielem i rodzicem okna. W przypadku komponentów, ich właścicielem jest formularz, na którym są umieszczone, zaś rodzicem może być inny komponent (np. Panel).

Parent zawiera wskaźnik do rodzica danego formularza. Różnica między właścicielem a rodzicem wyjaśniona jest wyżej.

Metody formularzy

Formularze są także komponentami i jako takie, posiadają wspólne z innymi komponentami metody, np. Show, ShowModal i Invalidate. Istnieją jednak metody, które odnoszą się tylko do formularzy. Omówię tu tylko te najczęściej spotykane.

BringToFront - metoda ta powoduje przesunięcie danego formularza na wierzch (ponad inne, przykrywające go).

Close i CloseQuery - metoda Close wywołuje metodę CloseQuery aby się upewnić, że można zamknąć formularz i zamyka go. Funkcja CloseQuery z kolei wywołuje metodę obsługi zdarzenia OnCloseQuery. Jeżeli zmienna typu Boolean przekazana do niej ma wartość False, formularz nie jest zamykany, w przeciwnym przypadku jest. Metodę obsługi zdarzenia OnCloseQuery można wykorzystać np. do wyświetlenia komunikatu dla użytkownika informującego o konieczności zamknięcia wszystkich plików lub do sprawdzenia własnego warunku zamknięcia formularza.

Print - metoda ta służy do drukowania zawartości formularza (ściślej mówiąc obszaru klienckiego - bez paska tytułowego, menu i ramek) na drukarce.

ScrollInView - metoda ta przewija zawartość formularza tak, żeby określony komponent stał się widoczny.

SetFocus - metoda ta powoduje aktywację formularza i przesunięcie go na wierzch. Jeżeli na formularzu jest jakiś komponent wskazany we właściwości ActiveControl formularza, jest on aktywowany.

Show i ShowModal - metody te służą do wyświetlenia formularza na ekranie. Metoda Show wyświetla formularz jako niemodalny (inne formularze mogą być aktywowane w czasie, gdy dany formularz jest wyświetlony), natomiast ShowModal wyświetla formularz jako modalny (modalne okno dialogowe trzeba zamknąć, żeby możliwa była dalsza praca z aplikacją).

Metody MDI

Istnieją specjalne metody przeznaczone do operowania na formularzach MDI. Metoda ArrangeIcons porządkuje ikony zminimalizowanych okien podporządkowanych MDI w oknie-rodzicu. Metoda Cascade wyświetla kaskadowo wszystkie nie zminimalizowane okna podporządkowane MDI. Metoda Tile wyświetla te okna sąsiadująco. Metoda Next aktywuje (umieszcza na wierzchu) następne na liście okno podporządkowane MDI, metoda Previous robi to samo z oknem poprzednim na liście. Metody MDI mają zastosowanie wyłącznie do okien-rodziców.

Zdarzenia formularzy

Formularze mogą odpowiadać na szeroki wachlarz zdarzeń, z których niektóre najczęściej używane opisane są poniżej.

OnActivate - zdarzenie to zachodzi, gdy formularz jest pierwszy raz aktywowany. Formularz może być aktywowany w wyniku jego utworzenia lub kiedy użytkownik przełącza się pomiędzy formularzami. Obiekt typu Application także posiada zdarzenie OnActivate, które generowane jest, gdy użytkownik przełączy się na tę aplikację z innej.

OnClose i OnCloseQuery - kiedy aplikacja jest zamykana, generowane jest zdarzenie OnClose. Zdarzenie to generuje z kolei zdarzenie OnCloseQuery. Jeżeli OnCloseQuery zwraca wartość False, formularz nie jest zamykany.

OnCreate - zachodzi w momencie utworzenia formularza w czasie działania programu. Dla każdego formularza (obiektu klasy tego formularza) zdarzenie to może zajść tylko jeden raz. Zdarzenia tego używa się do przeprowadzenia wszelkich czynności, które są niezbędne do prawidłowego działania formularza.

OnDestroy - zdarzenie to jest przeciwne do OnCreate. (wywoływane jest przy niszczeniu formularza). Używa się go do zwalniania wszelkiej przydzielonej dynamicznie pamięci lub innych końcowych czynności.

OnDragDrop - zdarzenie to generowanie jest, gdy na danym formularzu upuszczany jest jakiś obiekt. Zdarzenie to ma znaczenie przy włączonej obsłudze drag and drop formularza.

OnMouseDown, OnMouseMove i OnMouseUp - zdarzenia te generowane są przy klikaniu lub poruszaniu myszą w obszarze formularza.

OnPaint - zdarzenie to generowane jest, gdy zachodzi potrzeba odświeżenia formularza na ekranie. Zazwyczaj wszystkie komponenty same troszczą się o prawidłowe wyświetlanie, jednak czasem trzeba przerysować jakieś elementy graficzne bezpośrednio umieszczone na formularzu.

OnResize - zdarzenie to generowane jest po każdej zmianie rozmiarów formularza. Może czasami przydać się do korekty położenia komponentów na formularzu lub do jego przerysowania.

OnShow - zdarzenie to zachodzi na moment przed wyświetleniem formularza na ekranie.

Inspektor Obiektów

Inspektor Obiektów jest integralną częścią Delphi IDE. Współpracuje on z Projektantem Formularzy. Projektant formularzy zostanie omówiony szczegółowo w rozdziale 6, lecz przedtem chciałbym wspomnieć właśnie o Inspektorze Obiektów.

Służy on do nadawania wartości na etapie projektowania aplikacji poszczególnym właściwościom komponentów. Inspektor Obiektów składa się z trzech głównych elementów:

• Listy wyboru komponentu

• Karty właściwości

• Karty zdarzeń

Przy tworzeniu formularza generowanych jest wiele zdarzeń, tak jak przy jego niszczeniu. Kolejność zdarzeń przy tworzeniu formularza jest następująca: Wywołanie konstruktora formularza Zdarzenie OnCreate Metoda AfterConstruction Zdarzenie OnShow Zdarzenie OnActivate Kiedy formularz jest niszczony, występują następujące zdarzenia: Zdarzenie OnCloseQuery Zdarzenie OnClose Metoda BeforeDestruction Zdarzenie OnDestroy Wywołanie destruktora formularza W większości przypadków wyżej wymieniona kolejność nie jest taka istotna. Niekiedy jednak może być bardzo ważna. Znajomość tej kolejności może Ci w tych przypadkach bardzo pomóc.

Do tej pory zdążyłeś już zapewne dość dobrze zapoznać się z Inspektorem Obiektów. Podsumuję zatem, co już wiesz i dodam kilka informacji, z którymi się prawdopodobnie jeszcze nie zetknąłeś.

Lista wyboru komponentu

Najprościej jest wybrać komponent, którego właściwości mają być wyświetlone w Inspektorze Obiektów, klikając go na formularzu. Alternatywnym sposobem jest skorzystanie z listy wyboru komponentu. Znajduje się ona w górnej części Inspektora Obiektów.

Zwykle komponent wybiera się klikając na formularzu. Jednak gdy poszukiwany komponent jest przykryty innym komponentem, lub jest poza widocznym obszarem formularza, korzystanie z listy wyboru komponentu staje się uzasadnione.

W polu wybranego elementu listy wyboru wyświetlana jest nazwa obiektu i klasa, do jakiej należy. Na przykład, komponent o nazwie Memo wyświetlony byłby następująco:

Memo: TMemo

Na rozwijanej liście nazwa klasy obiektu nie jest wyświetlana, jest ona widoczna tylko w polu wybranego elementu. Aby wybrać komponent z listy, należy kliknąć przycisk umieszczony po prawej stronie pola wybranego elementu, co spowoduje rozwinięcie się listy. Teraz wystarczy już kliknąć na nazwie odpowiedniego komponentu.

Lista wyboru komponentu zawiera tylko komponenty umieszczone na bieżącym formularzu włącznie z nazwą tego formularza. Nieaktywne formularze i umieszczone na nich komponenty nie są umieszczone na liście.

Jeżeli wybierze się jakiś komponent z listy, na formularzu automatycznie pojawia się jako zaznaczony. Karty Properties i Events są uaktualniane stosownie do wybranego komponentu (formularz także jest komponentem). Na rysunku 4.13 przedstawiony jest Inspektor Obiektów z wyświetloną listą wyboru komponentu.

Rysunek 4.13. Lista wyboru komponentu

Karta Properties

Karta Properties zawiera wszystkie właściwości zaznaczonego komponentu ustawiane w czasie projektowania aplikacji. Karta ta podzielona jest na dwie kolumny. W lewej kolumnie są nazwy właściwości, w prawej zaś wartości tych właściwości.

Jeżeli wszystkie właściwości nie mieszczą się w oknie Inspektora Obiektów, pojawiają się na nim paski przewijania.

Wygląd Inspektora Obiektów z wyświetlonymi właściwościami komponentu Memo przedstawiony jest na rysunku 4.14.

Jeżeli zaznaczyłeś kilka komponentów na formularzu, w Inspektorze Obiektów wyświetlone są tylko właściwości wspólne dla nich wszystkich. Można to wykorzystać do jednoczesnej zmiany właściwości dla kilku komponentów. Na przykład, żeby zmienić szerokość kilku komponentów na raz, trzeba zaznaczyć te komponentu i w Inspektorze Obiektów zmodyfikować odpowiednio właściwość Width.

Rysunek 4.14. Inspektor Obiektów z wyświetlonymi właściwościami komponentu Memo

Właściwości mogą mieć wartości typu całkowitego, wyliczeniowego, zbiorowego, innych obiektów, łańcuchowego i innych typów (właściwości omówione są szczegółowo w następnym rozdziale). Inspektor Obiektów umożliwia wprowadzanie poszczególnych wartości stosownie do ich typu. Delphi posiada kilka wbudowanych edytorów właściwości. Na przykład, właściwość Top może posiadać wartości typu Integer. Ponieważ jest to typ podstawowy, edytor właściwości tego typu jest bardzo prosty. Umożliwia on wpisywanie odpowiednich wartości wprost do kolumny wartości w Inspektorze Obiektów.

W większości przypadków edytor właściwości dokonuje sprawdzenia podanych wartości typu całkowitego. Na przykład, właściwość Width nie może być ujemna. Jeżeli wprowadzisz mimo to liczbę ujemną, Delphi ustawi tę wartość na najmniejszą możliwą (zwykle 0). Jeżeli natomiast do właściwości typu całkowitego wpiszesz łańcuch, pojawi się komunikat o błędzie. Jednym z zadań edytorów właściwości jest właśnie sprawdzanie wprowadzanych wartości.

W wielu przypadkach edytor właściwości zawiera listę dostępnych wartości, z których można wybierać. Po kliknięciu w polu wartości pokazuje się przycisk opuszczanej listy z dostępnymi wartościami.

Podwójne kliknięcie w polu wartości spowoduje cykliczne przechodzenie poprzez kolejne elementy listy dozwolonych wartości. Na przykład, żeby szybko zmienić wartość typu Boolean, wystarczy podwójnie kliknąć na tej wartości (lista możliwych opcji zawiera w tym przypadku tylko dwa elementy - True i False).

W Inspektorze Obiektów przed nazwami niektórych właściwości widać znak +. Oznacza to, że dana właściwość jest klasą albo zbiorem. Nazwa tej właściwości jest węzłem, który można rozwijać, aby dostać się do poszczególnych pod-właściwości. W celu rozwinięcia węzła trzeba kliknąć podwójnie na jego nazwie albo z menu kontekstowego wybrać opcję Expand. Aby zwinąć otwarty węzeł, należy ponownie podwójnie kliknąć na jego nazwie albo z menu kontekstowego wybrać opcję Collapse.

Jako przykład właściwości, której wartości tworzą zbiór (set), weźmy właściwość BorderIcons formularza. Zaznacz formularz, następnie w Inspektorze Obiektów kliknij podwójnie na właściwości BorderIcons. Rozwinie się ona w listę czterech elementów zbioru. Można teraz włączać lub wyłączać każdy z tych elementów.

W przypadku właściwości będących obiektami (realizacjami klas VCL) właściwości można edytować na dwa sposoby. Pierwszym jest kliknięcie w kolumnie wartości a następnie kliknięcie na przycisku oznaczonym znakiem wielokropka (… - ang. ellipsis). Na przykład, kliknij właściwość Font, a następnie kliknij na przycisku z wielokropkiem. Otworzy się odpowiedni edytor do tej właściwości (okno dialogowe wyboru czcionki).

Drugim sposobem na edycję tej właściwości jest rozwinięcie jej węzła. Wyświetlone zostaną właściwości tej właściwości (tak - właściwości też mogą posiadać swoje właściwości) i można je edytować jak każde inne. Zlokalizuj ponownie właściwość Font formularza i kliknij podwójnie na niej. Węzeł rozwinie się ukazując takie właściwości jak Height, Color, Name itd.

Niektóre właściwości można edytować jedynie klikając przycisk z wielokropkiem. Wcześniej używałeś komponentu Image jako ikony dla programu Multiple. Właściwość Picture komponentu Image można było edytować jedynie wywołując edytor właściwości. W tym przypadku jest to Image Editor.

Ogólnie mówiąc, Inspektor Obiektów troszczy się o to, żeby zawsze uruchomić odpowiedni dla danej właściwości edytor, Ty nie musisz się tym przejmować. W trakcie poznawania nowych komponentów będziesz po prostu spotykać się z różnymi edytorami właściwości.

Karta Events

Na karcie tej wyświetlone są wszystkie zdarzenia, które obsługiwane są przez dany komponent. Używanie tej karty jest bardzo proste. Aby utworzyć procedurę obsługi określonego zdarzenia, należy po prostu kliknąć podwójnie w prawej kolumnie karty obok tego zdarzenia. Delphi tworzy automatycznie szkielet procedury wraz ze wszystkimi odpowiednimi parametrami. Otwierany jest Edytor Kodu z kursorem umieszczonym wewnątrz nowo utworzonej procedury. Wystarczy teraz po prostu wpisać odpowiedni kod. Nazwa funkcji generowana jest na bazie właściwości Name komponentu i nazwy obsługiwanego zdarzenia. Na przykład, procedura obsługi zdarzenia OnClick przycisku o nazwie OkBtn będzie nazywać się OKBtnClick.

Możesz pozwolić Delphi wygenerować nazwę procedury obsługi zdarzenia, albo możesz tę nazwę podać samemu. Aby zrobić to drugie, należy wpisać nazwę procedury w polu edycji po prawej stronie nazwy zdarzenia i nacisnąć Enter. Wyświetla się wówczas Edytor Kodu z odpowiednio nazwaną procedurą.

W czasie kompilowania, uruchamiania czy zachowywania modułu na dysku, Delphi usunie automatycznie z kodu źródłowego wszystkie „puste” procedury obsługi zdarzenia. Powiedzmy, że utworzyłeś procedurę obsługi zdarzenia OnCreate, ale nie wpisałeś do niej żadnego kodu. Przy pierwszym uruchomieniu, kompilacji modułu czy zachowaniu go na dysku procedura ta zostanie usunięta. Jest to bardzo przydatna cecha Delphi, jednak niewtajemniczony użytkownik może być nieprzyjemnie zaskoczony. Jeżeli nie chcesz, żeby Delphi usunął daną procedurę, wystarczy wpisać do niej pojedynczą linię komentarza.

Po utworzeniu procedury obsługującej dane zdarzenie, można użyć jej wielokrotnie w różnych komponentach posiadających to samo zdarzenie. Czasami na przykład kilka przycisków umieszczonych na formularzu może mieć taką samą obsługę zdarzenia OnClick. Idąc krok dalej - można utworzyć opcję w menu głównym, opcję w menu kontekstowym i przycisk na pasku narzędzi, które wywołują wspólną procedurę obsługi zdarzenia OnClick. Gdy nabierzesz doświadczenia w programowaniu w Delphi, docenisz te możliwości powtórnego wykorzystania kodu. Na karcie zdarzeń Inspektora Obiektów pola w prawej kolumnie posiadają przyciski opuszczania listy, na której umieszczone są zgodne z danym zdarzeniem procedury obsługi.

Dokowalne okna IDE


Nowością w Delphi 4 są okna dokowalne.

Okno dokowalne jest to okno, które może być przeciągnięte przy pomocy myszy z jego aktualnego położenia i zadokowane w jednym z punktów dokowania.

Miejsce dokowania jest to lokalizacja w IDE, w którym może być zadokowane (zaczepione) okno dokowalne. IDE posiada kilka takich miejsc dokowania.

Prawie każde okno w Delphi jest dokowalne. Dokowalne jest okno Menedżera Projektów, Eksploratora Kodu, Inspektora Obiektów, okno podglądu zmiennych, okno komunikatów i wiele innych.

Największą zaletą okien dokowalnych jest to, że umożliwiają one dostosowanie środowiska do wymagań i preferencji użytkownika, co czyni pracę przyjemniejszą i bardziej efektywną.

Miejsca dokowania

Okna dokowalne można rozmieszczać po całym ekranie w dowolnym jego miejscu. Efektem takiego działania byłoby jednak całe mnóstwo pojedynczych okien rozrzuconych po całym obszarze roboczym. Poruszanie się w tym gąszczu byłoby bardzo trudne. Aby okna dokowalne miały w ogóle sens, potrzebne jest określone miejsce do ich zaczepienia. W Delphi IDE miejscem takim jest najczęściej Edytor Kodu.

Edytor Kodu posiada trzy miejsca dokowania. Pierwsze z nich leży po lewej stronie - zaraz po uruchomieniu Delphi zadokowany jest w nim Eksplorator Kodu. Drugie miejsce dokowania znajduje się przy dolnej krawędzi Edytora Kodu - w domyślnej konfiguracji Delphi umieszczone jest tam okno komunikatów (nie jest ono widoczne, dopóki nie w nim nic do wyświetlenia). Trzecie miejsce dokowania w Edytorze Kodu znajduje się wzdłuż lewej krawędzi jego okna. Te trzy miejsca dokowania w zupełności wystarczają do pełnego skonfigurowania IDE do swoich wymagań.

Oprócz tego jest jeszcze jedno miejsce dokowania, o którym chcę wspomnieć. Jeżeli masz otwarte okno narzędzi (np. Menedżera Projektów), możesz zadokować w tym oknie inne okno narzędzi. Umożliwia to zgrupowanie dwóch albo więcej okien Delphi w jednym oknie narzędziowym. Na przykład w jednym „pływającym” oknie narzędziowym mogą zostać umieszczone: Eksplorator Kodu i Menedżer Projektów. Okno takie posiada pięć miejsc dokowania: krawędź lewa, prawa, górna, dolna i środek.

Po zadokowaniu okna w środku okna narzędzi, okno narzędzi staje się oknem wielostronicowym (posiada zakładki poszczególnych kart). Na każdej z zakładek wypisany jest tytuł odpowiadającego okna. Może wykład ten nie jest zbyt jasny, najlepiej więc będzie przećwiczyć to na przykładzie.

Eksperymentowanie z oknami dokowalnymi

Zaczniemy od najbardziej podstawowych operacji dokowania, przechodząc później do przykładów bardziej skomplikowanych.

Oto pierwsze ćwiczenie:

1. Utwórz nową aplikację i przełącz się do Edytora Kodu. Zwróć uwagę, że Eksplorator Kodu jest zadokowany po lewej stronie Edytora Kodu.

46. Kliknij na uchwycie w górnej części Eksploratora Kodu i przesuń go w prawo. Widoczny będzie przesuwający się wraz z kursorem myszy szary prostokąt. Prostokąt ten wyobraża umiejscowienie Eksploratora Kodu, gdyby zakończyć w tym miejscu przesuwanie.

47. Przeciągnij okno Eksploratora Kodu na środek Edytora Kodu i puść klawisz myszy. Eksplorator Kodu zamienił się w samodzielne, pływające okno narzędziowe.

48. Kliknij na pasku tytułowym Eksploratora Kodu i przeciągnij go z powrotem na lewą stronę Edytora Kodu. Kiedy kursor myszy wraz z szarym prostokątem osiągnie lewą krawędź okna Edytora Kodu, szary prostokąt wyobrażający przesuwane okno Eksploratora Kodu „wskoczy” w odpowiednie miejsce Edytora Kodu. Puść klawisz myszy i Eksplorator Kodu zostanie zadokowany.

49. Przeciągnij jeszcze raz Eksplorator Kodu do dolnej krawędzi okna Edytora Kodu i zadokuj go w miejscu dokowania znajdującym się wzdłuż dolnej krawędzi Edytora Kodu. Rozmiar Eksploratora Kodu dopasuje się automatycznie. Uchwyt Eksploratora Kodu ma teraz orientację pionową i znajduje się po lewej jego stronie.

50. Przeciągnij Eksplorator Kodu do punktu wyjściowego (do miejsca dokowania na lewej krawędzi Edytora Kodu). Edytor Kodu i Eksplorator Kodu powinny teraz wyglądać tak, jak na początku ćwiczenia.

Ćwiczenie to było bardzo proste, ale ilustruje ono ogólną ideę dokowania. Następne będzie trochę bardziej interesujące. Wykonaj następujące czynności:

1. Przeciągnij Eksplorator Kodu z punktu dokowania na prawą stronę Edytora Kodu i upuść go tam.

51. Zmień rozmiar okna Eksploratora Kodu tak, żeby było ono mniej więcej kwadratowe.

52. Wybierz z menu View | Project Manager. Ukaże się na ekranie Menedżer Projektów.

53. Przeciągnij okno Menedżera Projektów na okno Eksploratora Kodu. Kiedy szary prostokąt przesuwany wraz z myszą umiejscowi się na środku okna Eksploratora Kodu, puść klawisz myszy. Okno narzędziowe powinno teraz wyglądać tak, jak na rysunku 4.15. Zwróć uwagę, że okno to posiada teraz dwie karty: Eksploratora Kodu i Menedżera Projektów.

54. Przeciągnij to okno narzędziowe na lewą stronę Edytora Kodu i zadokuj je tam. Masz teraz łatwy i szybki dostęp zarówno do Eksploratora Kodu, jak i do Menedżera Projektów.

Rysunek 4.15. Eksplorator Kodu i Menedżer Projektów zadokowane razem w oknie narzędziowym

Zróbmy teraz jeszcze jedno ćwiczenie. W czasie poprawiania błędów w programie często potrzeba mieć widoczne okno podglądu zmiennych - Watch List (znajdowanie i poprawianie błędów w programach omówione jest szczegółowo w rozdziale 10). Pokażę Ci jak zrobić, żeby okno podglądu zmiennych było cały czas pod ręką:

1. Kliknij prawym klawiszem myszy na Edytorze Kodu i z menu kontekstowego wybierz opcję Message View. W dolnym miejscu dokowania Edytora Kodu ukaże się okno komunikatów.

55. Wybierz z menu głównego View | Debug Windows | Watches. Lista podglądu zmiennych otworzy się jako nowe okno narzędziowe.

56. Przeciągnij okno Watch List na okno komunikatów i zadokuj je w jego środku. W dolnym miejscu dokowania Edytora Kodu będą teraz umieszczone dwie karty: Messages i Watch List.

Możesz teraz zaglądać do listy podglądu zmiennych, kiedy tylko chcesz klikając na zakładkę Watch List. Karta Messages zostanie wyświetlona automatycznie wtedy, gdy pojawią się na niej komunikaty do wyświetlenia. Rysunek 4.16 przedstawia wygląd IDE po przeprowadzeniu ostatniego ćwiczenia.

Wyłączanie dokowania

Możliwość dokowania jest bardzo przydatna i wygodna. Czasami jednak, gdy chcesz umieścić na ekranie jakieś okno nie dokując go, trudno znaleźć odpowiednie miejsce - gdzie się nie ruszyć, zawsze jest jakieś czekające miejsce dokowania. Na szczęście dokowalność okna narzędziowego można wyłączyć.

Każde dokowalne okno narzędziowe ma w swoim menu kontekstowym opcję Dockable. Jeżeli opcja ta jest zaznaczona, okno jest dokowalne. Jeżeli nie jest, okno nie jest dokowalne i można je swobodnie umieszczać w całym obrębie IDE.

Rysunek 4.16. Cztery okna narzędziowe zadokowane w Edytorze Kodu

Przykładowy program MDI

Żeby utrwalić przyswojoną w tym rozdziale wiedzę na temat projektów i formularzy, stwórzmy przykładową aplikację MDI. Będzie to przeglądarka plików graficznych. Jak na ten etap nauki będzie to dość rozbudowana aplikacja, potrzebny więc będzie ogólny plan działania. Oto on:

1. Utworzenie formularza głównego MDI, posiadającego menu.

57. Napisanie kodu obsługującego opcje Plik | Otwórz i Plik | Zapisz.

58. Napisanie kodu obsługującego opcje Uporządkuj Sąsiadująco, Uporządkuj Kaskadowo i Uporządkuj Wszystkie z menu Okno.

59. Utworzenie formularzy podporządkowanych MDI.

60. Utworzenie formularza „O Programie”.

61. Zakończenie pracy połączone z podziwianiem jej efektów.

Bierzmy się więc do roboty.

Utworzenie formularza głównego

Pierwszym krokiem jest utworzenie formularza głównego. Okno główne aplikacji MDI musi mieć właściwość FormStyle ustawioną na fsMDIForm. Następnie trzeba będzie utworzyć menu i okna dialogowe Otwórz i Zapisz. Wykonaj następujące czynności:

1. Uruchom Delphi i wybierz opcję File | New Application z menu głównego.

62. Zmień właściwość Name formularza na MainForm.

63. Zmień właściwość Caption na Przeglądarka plików graficznych.

64. Ustaw właściwość Height na 450, a Width na 575 (albo inne wartości odpowiednie dla ustawionego aktualnie trybu graficznego).

65. Zmień właściwość FormStyle na fsMDIForm.

W porządku, główny szkielet formularza głównego jest już gotowy. Teraz dodaj do niego menu główne. Ponieważ nie omawiałem jeszcze Projektanta Menu, ułatwimy sobie sprawę wykorzystując do utworzenia menu predefiniowany szablon:

1. Kliknij na zakładce Standard na Palecie Komponentów i kliknij na komponencie MainMenu.

66. Kliknij na formularzu, aby umieścić na nim menu główne. Można je umieścić w dowolnym miejscu formularza, ponieważ komponent menu w czasie działania programu nie będzie widoczny.

67. Zmień właściwość Name menu na MainMenu.

68. Kliknij podwójnie na umieszczonym na formularzu komponencie MainMenu. Otworzy się Projektant Menu (szczegółowe omówienie Projektanta Menu znajdziesz w rozdziale 6).

69. Umieść kursor na Projektancie Menu i kliknij prawy klawisz myszy. Z menu kontekstowego wybierz opcję Insert from Template. Otworzy się okno dialogowe Insert Template. Rysunek 4.17 pokazuje to okno dialogowe na tle Projektanta Menu.

Rysunek 4.17. Okno dialogowe Insert Template na tle Projektanta menu

70. Wybierz opcję MDI Frame Menu i kliknij OK.

71. Zamknij Projektanta Menu klikając ikonę systemową umieszczoną w prawym górnym rogu okna.

Teraz powinieneś być z powrotem na formularzu głównym. Zwróć uwagę, że teraz posiada on menu główne. Możesz klikać poszczególne opcje menu głównego, żeby zobaczyć rozwijane listy poszczególnych podopcji. Nie wybieraj ich na razie - zrobisz to za chwileczkę. Sporo jest tam tych opcji, prawda? Nie będziesz potrzebował ich wszystkich - zostaw po prostu nie używane tak, jak są.

Przygotuj teraz okna dialogowe Otwórz i Zapisz:

1. Kliknij na zakładce Dialogs na Palecie Komponentów. Wybierz komponent OpenPictureDialog i umieść go na formularzu. Tak samo jak menu główne, można go umieścić w dowolnym miejscu formularza.

72. Zmień właściwość Name tego okna dialogowego na OpenPictureDialog.

73. Właściwość Title zmień na Otwórz rysunek.

74. Umieść na formularzu komponent SavePictureDialog.

75. Zmień właściwość Name nowo umieszczonego komponentu na SavePictureDialog, a jego właściwość Title na Zapisz Rysunek.

Formularz główny powinien wyglądać, jak na rysunku 4.18.

Rysunek 4.18. Aktualny wygląd formularza głównego

Napisanie kodu obsługującego opcje
File | Open i File | Save as…

Następnym etapem tworzenia naszej aplikacji jest wpisanie kodu obsługującego opcje File|Open i File|Save As. Delphi jak zwykle ułatwia bardzo to zadanie. Nie utworzyliśmy jeszcze okien podporządkowanych MDI, ale wiemy wystarczająco dużo, żeby napisać procedury obsługi wyżej wymienionych opcji. Pamiętaj tylko o tym, że kompilacja aplikacji nie będzie możliwa przed utworzeniem okien podporządkowanych MDI. Wykonaj, co następuje:

1. Na głównym formularzu aplikacji wybierz opcję File|Open. Procedura obsługi tej opcji zostanie utworzona automatycznie, w Edytorze Kodu wystarczy tylko w miejscu umieszczenia kursora wpisać odpowiedni kod.

76. Uzupełnij procedurę TMainForm.Open1Click tak, żeby wyglądała następująco:

procedure TMainForm.Open1Click(Sender: TObject);

var

Child : TChild;

begin

if OpenPictureDialog.Execute then begin

Child := TChild.Create(Self);

with Child.Image.Picture do begin

LoadFromFile(OpenPictureDialog.FileName);

Child.ClientWidth := Width;

Child.ClientHeight := Height;

end;

Child.Caption := ExtractFileName(OpenPictureDialog.FileName);

Child.Show;

end;

end;

W procedurze tej najpierw wywoływane jest okno dialogowe Otwórz Plik, w którym pobierana jest od użytkownika nazwa pliku z rysunkiem. Jeżeli użytkownik naciśnie przycisk Anuluj, okno jest zamykane i żadna akcja nie jest podejmowana. Jeżeli natomiast użytkownik naciśnie klawisz OK, utworzony zostaje nowy obiekt klasy TChild (okno podporządkowane MDI). Następnie plik z rysunkiem jest ładowany do komponentu Image w oknie podporządkowanym MDI i rozmiar tego okna zostaje automatycznie dopasowany do rozmiaru rysunku. Na końcu do właściwości Caption zostaje wpisana nazwa pliku zawierającego rysunek i rysunek zostaje wyświetlony.

W metodzie Open1Click użyta jest funkcja ExtractFileName, która oddziela ścieżkę dostępu od nazwy pliku i zwraca tę ostatnią. Związane tematycznie funkcje to ExtractFilePath, ExtractFileDir, Extract­FileDrive i ExtractFileExt.

77. Naciśnij F12, żeby przełączyć się z powrotem do formularza. Wybierz teraz opcję File|Save as. W Edytorze Kodu wyświetlona zostaje procedura obsługi tej opcji.

Pamiętasz, gdy w poprzednim rozdziale pisałem o wywołaniu funkcji Free przy likwidacji obiektów przydzielanych dynamicznie? Wygląda na to, że łamię tę zasadę w przytoczonej wyżej procedurze. W rzeczywistości jednak zadanie odzyskiwania pamięci alokowanej dla okien podporządkowanych MDI wykonuje biblioteka VCL. Zwróć uwagę, że parametrem konstruktora klasy TChild jest Self. Mówi to VCL, że właścicielem okna podporządkowanego MDI jest okno główne MDI. Kiedy okno główne jest zamykane, następuje automatyczna likwidacja wszystkich okien podporządkowanych.

78. Zmodyfikuj tę procedurę, aby wyglądała jak poniżej:

procedure TMainForm.SaveAs1Click(Sender: TObject);

begin

if SavePictureDialog.Execute then

with ActiveMDIChild as TChild do

Image.Picture.SaveToFile(SavePictureDialog.FileName);

end;

Procedura ta jest krótka i prosta. Najpierw wyświetlone zostaje okno dialogowe Zapisz Plik. Jeżeli użytkownik naciśnie OK, rysunek zostaje zapisany na dysku pod nazwą określoną w metodzie SaveToFile klasy TPicture.

W powyższej procedurze widać w akcji operator as. Właściwość ActiveMDIChild zwraca wskaźnik na obiekt klasy TForm. To, czego potrzeba w tej sytuacji to wskaźnik na obiekt klasy TChild, aby mieć dostęp do jego właściwości Image. Operator as konwertuje zmienną ActiveMDIChild na wskaźnik do TChild. Jeżeli z jakichś powodów konwersja nie jest możliwa, następujący po tym wyrażeniu kod nie jest wykonywany.

Zanim będziemy kontynuować, warto zapisać aktualny stan projektu na dysku. Wybierz z menu głównego opcję File | Save All. Zapisz Unit1 (domyślna nazwa nadawana nowemu modułowi) jako PctViewU, a projekt jako PictView.

Napisanie kodu obsługującego opcje menu Window

Teraz można wpisać kod obsługujący opcje menu Window. Jest on bardzo prosty:

1. Przełącz się z powrotem do formularza naciskając klawisz F12. Wybierz opcję Window | Tile.

79. Do procedury obsługującej tę opcję trzeba wpisać tylko jedną linię kodu:

procedure TMainForm.Tile1Click(Sender: TObject);

begin

Tile;

end;

80. Przełącz się do formularza i powtórz to samo dla opcji Window | Cascade. Gotowa procedura powinna wyglądać następująco:

procedure TMainForm.Cascade1Click(Sender: TObject);

begin

Cascade;

end;

81. Powtórz powyższe czynności dla opcji Window | Arrange All. Kod, który trzeba wpisać do procedury to pojedyncza instrukcja:

ArrangeIcons;

Formularz główny jest już gotowy. Teraz przejdziemy do tworzenia okien podporządkowanych MDI.

Utworzenie okna podporządkowanego MDI

Utworzenie takiego okna jest zaskakująco proste. Nie trzeba właściwie w tym celu wpisywać żadnego kodu. Wystarczy wykonać następujące kroki:

1. Utwórz nowy formularz używając przycisku New Form na pasku narzędzi lub opcji File | New Form z menu głównego.

82. Ustaw właściwość Name nowego formularza na Child. Właściwość Caption można zostawić bez zmian, ponieważ ustawiana będzie w czasie wykonywania programu.

83. Zmień właściwość FormStyle na fsMDIChild. Jest to wymagane, żeby okno to było traktowane jak okno podporządkowane MDI.

To wszystko, jeżeli chodzi o sam formularz. Umieść teraz na nim komponent Image. Jego zadaniem będzie wyświetlenie grafiki z pliku wybranego przez użytkownika.

1. Kliknij na zakładce Additional palety komponentów. Następnie kliknij na komponencie Image i umieść go gdziekolwiek na formularzu.

84. Zmień właściwość Name komponentu Image na Image.

85. Zmień właściwość Stretch na True.

86. Zmień właściwość Align na alClient. Rozmiar komponentu Image zostanie dopasowany do obszaru klienckiego formularza.

87. Wybierz z menu głównego opcję File | Save i zapisz moduł formularza na dysku jako MDIChild.

88. Przełącz się do Edytora Kodu (naciśnij F12). Kliknij na zakładce PctViewU. Wybierz z menu głównego opcję File | Use Unit, wybierz moduł MDIChildU i kliknij OK.

Formularz nie wygląda na razie zbyt interesująco, powinien wyglądać mniej więcej jak na rysunku 4.19.

Rysunek 4.19. Formularz okna podporządkowanego MDI z komponentem Image

Pozostało jeszcze utworzyć okno „O Programie”, ale pewnie niecierpliwisz się już, żeby uruchomić program i zobaczyć, jak działa. Kliknij więc na przycisku Run. Po krótkiej chwili program powinien się uruchomić. Możesz wybrać opcję File|Open i otworzyć plik z rozszerzeniem .bmp, .wmf albo .ico.

Zwróć uwagę, że okno podporządkowane MDI dopasowuje swój rozmiar do rozmiaru wyświetlanej grafiki. Otwórz kilka obrazów i wypróbuj opcje Cascade i Tile z menu Window. Jeżeli chcesz, możesz zapisywać grafiki pod inną nazwą korzystając z opcji File | Save As.

Utworzenie okna „O Programie”

Myślę, że potrafisz już wystarczająco dużo, żeby utworzyć formularz O Programie samemu. Zaprojektuj go tak, żeby wyglądał mniej więcej jak na rysunku 4.20. Jeśli nie dasz sobie z czymś rady, możesz wrócić do rozdziału, w którym opisane było tworzenie formularza „O Programie” dla aplikacji Multiple.

Po utworzeniu formularza trzeba wykonać następujące czynności, żeby można było wywoływać to okno poleceniem menu:

1. Zmień właściwość Name formularza na AboutBox.

89. Zapisz moduł jako PVAboutU.

Delphi w pełni obsługuje długie nazwy plików. Ze względu na wymogi publikacji elektronicznej stosuję w tej książce konwencję „8-kropka-3”, ale Ty możesz oczywiście stosować długie nazwy.

Rysunek 4.20. Okno „O Programie”

90. Przełącz się do karty PctViewU w Edytorze Kodu (naciskając F12). Wybierz opcję File | Use Unit z menu głównego i włącz do listy uses bieżącego modułu moduł PVAboutU.

91. Naciśnij F12, żeby przełączyć się z powrotem do głównego formularza. Wybierz z menu głównego opcję Help | About. Wyświetlony zostanie Edytor Kodu z kursorem ustawionym w procedurze OnClick.

92. Wpisz poniższą linię:

AboutBox.ShowModal;

Na razie, to byłoby już wszystko. Naciśnij ikonę Run i wypróbuj opcję About z menu Help. Na rysunku 4.21 przedstawiony jest działający program z wyświetlonymi kilkoma oknami podporządkowanymi MDI.

Rysunek 4.21. Przeglądarka plików graficznych w działaniu

Końcowe poprawki

Mimo, że program jest w pełni funkcjonalny, nie jest jeszcze dopracowany w najdrobniejszych szczegółach. Chociaż, jak na półgodzinne programowanie, nie jest wcale tak źle. Jest jeszcze kilka problemów, które mogą wystąpić w czasie użytkowania programu.
Jeżeli spróbujesz otworzyć plik, który nie zawiera grafiki, wystąpi wyjątek. Wyjątki i sposoby postępowania z nimi omówię w rozdziale 14. „Zaawansowane techniki programowania”. Oprócz tego w menu jest dużo niepotrzebnych opcji, których można by się pozbyć. Pokażę Ci, jak to zrobić, w rozdziale 6 podczas omawiania Projektanta menu.

Z dwoma problemami powinieneś jednak już sobie poradzić, są dość proste. Po pierwsze, po uruchomieniu aplikacji otwierane jest puste okno podporządkowane MDI. Jest
to spowodowane tym, że Delphi automatycznie tworzy wszystkie zaprojektowane wcześniej

formularze zaraz po uruchomieniu programu. W przypadku okna podporządkowanego MDI oznacza to, że jest ono wyświetlane, kiedy okno główne staje się widoczne na ekranie. W tym programie okna podporządkowane tworzone są przez użytkownika w razie potrzeby, nie jest więc konieczne, żeby Delphi tworzyło je automatycznie.

Na szczęście, usunięcie okna podporządkowanego MDI z listy okien tworzonych automatycznie jest bardzo proste. Wykonaj następujące czynności:

1. Wybierz z menu głównego opcję Project | Options. Wyświetlone zostanie okno dialogowe opcji projektu.

93. Jeżeli nie jest aktualnie wyświetlona karta Forms, kliknij jej zakładkę. Zostanie wyświetlona lista formularzy tworzonych automatycznie.

94. Kliknij na formularzu podporządkowanym MDI i naciśnij przycisk >. Spowoduje to usunięcie tego formularza z listy formularzy tworzonych automatycznie, i dodanie go do listy dostępnych formularzy.

Teraz uruchom program ponownie. Tym razem puste okno podporządkowane MDI nie jest wyświetlane.

W Twojej aplikacji jest jeszcze jedna pułapka, o której muszę wspomnieć. Kiedy naciśnie się przycisk zamknięcia okna podporządkowanego MDI, okno to zamiast się zamknąć, zostaje zminimalizowane. Możesz wierzyć lub nie, takie zachowanie się okien jest uznawane przez Microsoft jako standardowe.

		Jeżeli usuniesz jakiś formularz z listy formularzy tworzonych automatycznie, musisz „ręcznie” utworzyć ten formularz przed jego użyciem. Jeżeli nie utworzysz formularza, wskaźnik na niego pozostanie nieokreślony - nie zostanie mu przypisana żadna konkretna wartość (pamiętaj o tym, że wskaźniki tworzone są automatycznie w Delphi). Próba użycia takiego wskaźnika będzie skutkować naruszeniem dostępu lub błędnym działaniem programu.
Rysunek 4.22. Okno dialogowe Project Options

Zachowanie standardowe czy nie, jest na pewno dziwne. Trzeba ten błąd naprawić, tak aby okno zamykało się po naciśnięciu przycisku zamknięcia (tak, jak spodziewa się tego każdy normalny człowiek). Aby to zrobić, wykonaj co następuje:

1. Otwórz okno podporządkowane MDI w Projektancie Formularzy. Upewnij się, że wybrany jest sam formularz, a nie umieszczony na nim komponent Image (jeżeli trzeba, wybierz formularz z listy wyboru komponentu).

95. Kliknij podwójnie w prawej kolumnie karty Events Inspektora Obiektów, obok zdarzenia OnClose. Zmodyfikuj procedurę TChild.FormClose tak, aby wyglądała następująco:

Procedure TChild.FormClose(Sender: TObject; var Action: TCloseAction);

begin

Action := caFree;

end;

Wpisanie wartość caFree do zmiennej Action mówi VCL, żeby zamknęła okno podporządkowane MDI i zwolniła przydzieloną mu pamięć. Teraz okna te powinny zachowywać się tak, jak trzeba.

96. Uruchom program i sprawdź jego działanie.

Podsumowanie

W Delphi IDE można się czasami pogubić, dopóki nie nabierze się trochę doświadczenia. W tym rozdziale sporo się nauczyłeś na temat różnych elementów IDE. Następnie zapoznałeś się z używaniem projektów do tworzenia programów wykonywalnych. Dowiedziałeś się także więcej o formularzach, oknach dialogowych i oknach podporządkowanych MDI. Poznałeś dobrze Inspektora Obiektów i jego użycie przy zmianie wartości właściwości poszczególnych komponentów, poznałeś także okna dokowalne. Na koniec stworzyłeś program, który wykonuje coś pożytecznego i ciekawego.

Warsztat

Warsztat składa się z pytań kontrolnych oraz ćwiczeń utrwalających i pogłębiających zdobytą wiedzę. W razie trudności lub wątpliwości, odpowiedzi do tych pytań zamieszczone są w Dodatku A. „Quiz - odpowiedzi”.

Pytania i odpowiedzi

• Paski narzędzi Delphi nie zawierają przycisków poleceń, których używam najczęściej. Czy mogę modyfikować paski narzędzi?

Oczywiście. Paski narzędzi są w pełni konfigurowalne. Można swobodnie dodawać i usuwać poszczególne ikony.

• Umieściłem na formularzu kilka komponentów Label i próbowałem wybrać je wszystkie poprzez przeciąganie wskaźnika myszy. Zamiast tego dostałem kolejny duży komponent Label. Co zrobiłem nie tak?

Zapomniałeś wyłączyć opcji wielokrotnego umieszczania komponentów. Wyłącza się ją poprzez kliknięcie na narzędziu wyboru komponentu (ikona ze strzałką).

• Usiłuję umieścić jedno z okien IDE poza obszarem Edytora Kodu. Za każdym razem jednak okno to zostaje zadokowane w Edytorze Kodu. Jak mogę temu zapobiec?

Przyciśnij prawy klawisz myszy w obszarze okna i menu kontekstowym wyłącz opcję Dockable.

• Kiedy przez przypadek wpiszę jakąś literę do właściwości Top mojego formularza, zostaje wyświetlony komunikat o błędzie. Zdaję sobie sprawę, że powinienem wpisywać tam cyfry a nie litery, ale skąd właściwie biorą się takie komunikaty?

Inspektor Obiektów wie, jakie wartości są prawidłowe dla poszczególnych właściwości. Litera nie jest prawidłową wartością dla właściwości typu Integer, więc wyświetlany jest komunikat o błędzie. W niektórych przypadkach za kontrolę wprowadzanych danych odpowiedzialne są odpowiednie edytory właściwości.

• Co muszę zrobić, żeby moja aplikacja była aplikacją MDI?

Główny formularz powinien mieć właściwość FormStyle ustawioną na fsMDIForm, a wszystkie okna podporządkowane MDI powinny mieć tę właściwość ustawioną na fsMDIChild.

• Jaka jest różnica między oknem dialogowym i zwykłym oknem aplikacji?

Właściwie nie ma żadnej różnicy. Formularz okna dialogowego może mieć stałe wymiary, zamiast być skalowalne, przyciski OK, Anuluj i Pomoc i może nie mieć ikon minimalizacji i maksymalizacji. Poza tym okno dialogowe jest jak każdy inny formularz.

• Czy mogę sprawdzić, czy w module, nad którym aktualnie pracuję nie ma błędów, bez uruchamiania aplikacji?

Tak. Trzeba wybrać opcję Project | Syntax Check z menu głównego. Delphi skompiluje wszystkie moduły, które zostały zmienione od czasu ostatniej kompilacji i wypisze komunikaty o wszystkich wykrytych błędach.

Quiz

1. Jak wywołuje się okno dialogowe Customize (Dostosuj) głównego okna Delphi?

97. Jeżeli otwarte jest okno Customize, w jaki sposób dodaje się przyciski do paska narzędzi?

98. Jak usuwa się przyciski z paska narzędzi?

99. Jaki jest najprostszy sposób umieszczania na formularzu wielu takich samych komponentów?

100. Jaki jest najprostszy sposób umieszczenia komponentu dokładnie na środku formularza?

101. Wymień typy plików niezbędnych do zbudowania aplikacji w Delphi.

102. Jakiej metody VCL używa się do wyświetlenia formularza niemodalnego?

103. Jakiej metody VCL używa się do wyświetlenia formularza modalnego?

104. Jak można dołączyć do zdarzenia procedurę obsługi, która została już wcześniej zdefiniowana?

105. Jak, używając Inspektora Obiektów, uaktywnić wartości właściwości typu zbiorowego?

Ćwiczenia

1. Usuń z paska narzędzi View przyciski Pause, Step Over i Trace Into. Dodaj zamiast nich przyciski Compile, Build i Syntax Check.

106. Przywróć paskowi narzędzi jest domyślne ustawienia.

107. Poświęć trochę czasu na przyjrzenie się wszystkim komponentom umieszczonym na Palecie Komponentów. Umieść te szczególnie interesujące na formularzu i poeksperymentuj z nimi.

108. Utwórz na dysku twardym nowy katalog. Utwórz w Delphi nową aplikację. Dodaj do projektu 3 nowe formularze (jeśli chcesz, mogą być puste). Zapisz projekt do nowo utworzonego katalogu i uruchom program. Zamknij program. Sprawdź teraz, jakie pliki znajdują się w katalogu aplikacji. Porównaj pliki, które tam są z typami plików z tabeli 4.1.

109. Uruchom program „Przeglądarka plików graficznych”, który utworzyłeś wcześniej. Otwórz kilka plików graficznych. Przeciągaj okna podporządkowane MDI w obrębie okna głównego. Spróbuj wyciągnąć któreś z nich poza obszar okna głównego. Co się dzieje?

110. Poeksperymentuj z dokowaniem różnych okien IDE w Edytorze Kodu.

111. Utwórz nową aplikację. Umieść na formularzu kilka różnych komponentów. Kliknij na każdym z komponentów obserwując jednocześnie uważnie Inspektor Obiektów.

112. Utwórz nowy, pusty formularz. Kliknij podwójnie w Inspektorze Obiektów w prawej kolumnie obok właściwości Color, żeby wywołać okno dialogowe wyboru koloru. Wybierz jakiś kolor i kliknij OK.

148 Część I

Rozdzia³ 4. ♦ Środowisko zintegrowane (IDE) 147

148 C:\Dokumenty\Roboczy\Delphi 4 dla kazdego\04.doc

C:\Dokumenty\Roboczy\Delphi 4 dla kazdego\04.doc 147

---