Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00450 008691 10464302 na godz. na dobę w sumie
C++BuilderX. Ćwiczenia - książka
C++BuilderX. Ćwiczenia - książka
Autor: Liczba stron: 128
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-676-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ builder - programowanie
Porównaj ceny (książka, ebook, audiobook).

C++BuilderX to narzędzie, które ma umożliwić tworzenie aplikacji w języku C++ dla różnych platform systemowych. Na wszystkich platformach wygląd jego interfejsu jest identyczny, co bardzo ułatwia pracę. Narzędzie to, poza możliwością tworzenia aplikacji w sposób wizualny, udostępnia programistom również rozbudowany edytor kodu źródłowego oraz edytor HTML i XML. C++BuilderX staje się coraz popularniejszym środowiskiem do tworzenia aplikacji wieloplatformowych.

'C++BuilderX. Ćwiczenia' to książka dla tych, którzy chcą poznać to narzędzie i nauczyć się podstaw programowania z użyciem C++BuilderX. Dzięki zawartym w niej wiadomościom dowiesz się, jak korzystać ze środowiska wizualnego i jak stworzyć proste programy dla systemów Windows i Linux.

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

Darmowy fragment publikacji:

C++BuilderX. Æwiczenia Autor: Mariusz Owczarek ISBN: 83-7361-676-4 Format: B5, stron: 128 C++BuilderX to narzêdzie, które ma umo¿liwiæ tworzenie aplikacji w jêzyku C++ dla ró¿nych platform systemowych. Na wszystkich platformach wygl¹d jego interfejsu jest identyczny, co bardzo u³atwia pracê. Narzêdzie to, poza mo¿liwoġci¹ tworzenia aplikacji w sposób wizualny, udostêpnia programistom równie¿ rozbudowany edytor kodu ĥród³owego oraz edytor HTML i XML. C++BuilderX staje siê coraz popularniejszym ġrodowiskiem do tworzenia aplikacji wieloplatformowych. „C++BuilderX. Æwiczenia” to ksi¹¿ka dla tych, którzy chc¹ poznaæ to narzêdzie i nauczyæ siê podstaw programowania z u¿yciem C++BuilderX. Dziêki zawartym w niej wiadomoġciom dowiesz siê, jak korzystaæ ze ġrodowiska wizualnego i jak stworzyæ proste programy dla systemów Windows i Linux. • Podstawy korzystania z C++BuilderX • Podstawowe wiadomoġci o C++ • Aplikacje uruchamiane z poziomu konsoli • Tworzenie aplikacji z interfejsem graficznym • Korzystanie z ró¿nych kompilatorów IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp...................................................z...................................................z.................... .......................................5 Rozdział 1. Pierwsze kroki w środowisku C++BuilderX...................................................z................................7 Co jest potrzebne, aby korzystać z C++BuilderX?...................................................z... 7 Pierwsze spotkanie z C++BuilderX...................................................z.......................... 8 Menu i paski narzędzi...................................................z............................................... 8 Okna ...................................................z...................................................z.................... 10 Podsumowanie...................................................z...................................................z..... 14 Rozdział 2. Aplikacje konsolowe ...................................................z...........................................................................15 Ogólna postać programu pisanego w C++...................................................z................. 15 Dyrektywy ...................................................z...................................................z........... 17 Dyrektywa #include ...................................................z.......................................... 17 Dyrektywa #define...................................................z............................................ 18 Dyrektywa #if — kompilacja warunkowa ...................................................z........ 19 Typy zmiennych ...................................................z...................................................z.. 19 Zmienne typu int ...................................................z............................................... 20 Zmienne typu float ...................................................z............................................ 20 Typ double ...................................................z...................................................z..... 21 Typ char ...................................................z...................................................z......... 21 Modyfikatory typów ...................................................z......................................... 21 Rzutowanie (konwersja) typów...................................................z......................... 22 Typ wyliczeniowy...................................................z............................................. 23 Operatory...................................................z...................................................z............. 24 Zapis danych do plików i odczyt z nich za pomocą operatora i ................ 26 Wskaźniki ...................................................z...................................................z............ 28 Tablice ...................................................z...................................................z................. 30 Operatory new i delete...................................................z............................................ 32 Instrukcje ...................................................z...................................................z............. 33 Instrukcje selekcji (wyboru)...................................................z.............................. 34 Instrukcje iteracyjne...................................................z.......................................... 37 Funkcje ...................................................z...................................................z................ 42 Przeciążanie funkcji ...................................................z.......................................... 43 Niejednoznaczność ...................................................z........................................... 45 Przekazywanie argumentów przez wartość i adres .............................................. 46 Wskaźniki do funkcji ...................................................z........................................ 49 4 C++BuilderX. Ćwiczenia Funkcja main()...................................................z...................................................z..... 50 Przekazywanie parametrów do funkcji main()...................................................z.. 50 Struktury i unie ...................................................z...................................................z.... 52 Struktury ...................................................z...................................................z........ 52 Unie...................................................z...................................................z................ 54 Klasy...................................................z...................................................z....................55 Konstruktory i destruktory ...................................................z................................ 57 Przeładowywanie konstruktorów ...................................................z...................... 59 Dziedziczenie...................................................z...................................................z. 60 Przeciążanie operatorów ...................................................z................................... 64 Wyjątki ...................................................z...................................................z................ 66 Podsumowanie...................................................z...................................................z..... 69 Rozdział 3. Aplikacje okienkowe ...................................................z............................................................................71 Wstęp...................................................z...................................................z................... 71 Pierwszy program GUI — funkcja WinMain() ...................................................z.......... 72 Główne okno aplikacji...................................................z............................................ 76 Podstawy obsługi kontrolek...................................................z.................................... 81 Kalkulator ...................................................z...................................................z............ 84 Najprostszy edytor tekstu ...................................................z....................................... 88 Ulepszamy edytor ...................................................z...................................................z 93 Rysowanie w oknie aplikacji ...................................................z.................................. 96 Odtwarzanie dźwięku z plików .wav...................................................z...................... 99 Podsumowanie...................................................z...................................................z... 103 Rozdział 4. Zarządzanie definicjami obiektów w C++BuilderX...................................................z...........105 Class browser...................................................z...................................................z..... 105 Okno Structure View ...................................................z............................................ 110 Podsumowanie...................................................z...................................................z... 112 Rozdział 5. Użytkowanie kilku kompilatorów i projekty makefile...................................................z.....113 Kompilacja warunkowa ...................................................z........................................ 115 Opcje linii komend ...................................................z............................................... 116 Konfiguracje budowy aplikacji...................................................z............................. 117 Konfiguracje Debug Build i Release Build...................................................z..... 117 Własne konfiguracje budowy aplikacji ...................................................z........... 118 Dodawanie własnych kompilatorów do środowiska................................................ 119 Budowanie aplikacji ze zbiorów makefile...................................................z............... 123 Podsumowanie...................................................z...................................................z... 125 Literatura...................................................z...................................................z............... ................................127 Rozdział 3. Aplikacje okienkowe Wstęp C++BuilderX w przeciwieństwie do C++Buildera 6 nie zawiera elementów VCL. Jesteśmy więc zmuszeni pisać programy z GUI przy użyciu WinAPI. Ma to swoje dobre strony, ponieważ pozwala na lepszą optymalizację kodu, ale jednocześnie zwiększa ilość czasu i pracy potrzebnej do napisania aplikacji. W pierwszej wersji BuilderaX przewidziane jest pisanie aplikacji GUI tylko pod systemem Windows. Dodatkowym utrudnieniem jest brak możliwości tworzenia menu i okien dialogowych w plikach zasobów. Edytor menu i okien dialogowych pojawi się zapewne w drugiej wersji BuilderaX. Tak naprawdę możliwe jest pisanie programów GUI również pod Linuksem, ale należy się w tym celu posłużyć którymś z narzędzi ułatwiających to zadanie. Takim narzędziem jest m.in. pakiet GTK++ dostępny na licencji open source. Ponieważ w drugiej wersji opcja projektów GUI prawdopodobnie będzie dostępna także pod Linuksem, zdecydowałem się nie opisywać tu GTK++ ani innego tego typu pakietu, ale poczekać na rozwiązanie zaproponowanie przez firmę Borland. Jeżeli będziesz, Czy- telniku, zainteresowany środowiskiem GTK, to na stronie projektu (www.gtk.org) znaj- dziesz obszerne opisy i tutoriale. Można się z nich nauczyć pracy z tą biblioteką od samych podstaw do skomplikowanych aplikacji. Mam nadzieję, że także dla Windows ewolucja programu pójdzie w kierunku jakiejś formy biblioteki VCL, która jednak bardzo ułatwia pracę. Na zakończenie wstępu kilka słów o ćwiczeniach w tym rozdziale. Ponieważ aplikacje w WinAPI są dosyć długie, nie jest możliwe napisanie ich w jednym ćwiczeniu. Dlatego ten rozdział podzielony jest na podrozdziały opisujące jedną aplikację (edytor, kalkula- tor itd.). Wszystkie ćwiczenia w danym podrozdziale odnoszą się do tego samego kodu źródłowego, aplikacja jest rozwijana w kolejnych podpunktach. 72 C++BuilderX. Ćwiczenia Pierwszy program GUI — funkcja WinMain() Ćwiczenie 3.1. Aby stworzyć projekt, którego wynikiem ma być aplikacja okienkowa: 1. Wybieramy z menu File opcję New i w oknie Object Gallery wybieramy New GUI Application. Pojawi się kreator projektów GUI. 2. Pierwszym krokiem jest wpisanie nazwy projektu i katalogu, w którym zostaną utworzone pliki programu. W polu nazwy pliku wpiszmy *CNNQ, a następnie kliknijmy Next . 3. Teraz należy wybrać platformę, na której będzie działać nasz projekt. Ponieważ będzie to aplikacja WinAPI, domyślnie wybrany jest Windows. Obowiązują tutaj takie same zasady wyboru kompilatorów, jak dla programów wykonywanych w oknie konsoli. 4. Ostatnim krokiem jest wskazanie, jakie pliki mają wejść w skład projektu. Domyślnie projekt zawiera jeden plik, nazwany untitled1.cpp i zawierający kod programu z funkcją 9KP/CKP . Jest to odpowiednik funkcji OCKP . Aby pik ten został utworzony, musimy zaznaczyć okienko w kolumnie Create obok nazwy pliku. Klikając na przycisk Add, możemy otworzyć okno umożliwiające dołączenie innych plików do projektu, podobnie jak to było w aplikacji konsolowej. Mogą to być pliki nagłówkowe, z obrazami graficznymi czy binarne pliki zasobów. Do odłączania plików od projektu służy przycisk Remove. Do naszego pierwszego projektu wystarczy plik z kodem programu, klikamy więc opisywane wyżej okienko Create, a następnie Finish. 5. Piki projektu zostaną utworzone w wybranym przez nas katalogu, a w oknie Project content zobaczymy ich listę. Będą to: plik projektu Hallo.cbx, plik untitled1.cpp z kodem programu i plik Hallo.exe, który będzie zawierał gotowy program po kompilacji. Z czego składa się projekt GUI Windows? Kliknijmy dwukrotnie plik untitled1.cpp. Jego zawartość pojawi się w oknie kodu źró- dłowego, a w oknie widoku struktury zobaczymy plik nagłówkowy i funkcje istniejące w programie. Na razie jedynym plikiem nagłówkowym jest windows.h, a jedyną funkcją 9KP/CKP. Plik windows.h zawiera funkcje WinAPI. Funkcja 9KP/CKP posiada parametry inne niż funkcja OCKP dla aplikacji konsolowych i na niej się na chwilę zatrzymamy. Oto postać 9KP/CKP : KPV#2+ 064;9KP/CKP *+056#0 J+PUVCPEG*+056#0 J2TGX+PUVCPEG.2564NR OF.KPG KPVP OF5JQY J+PUVCPEG, jest uchwytem do aplikacji, której częścią jest dana funkcja Pierwszy parametr, 9KP/CKP. Drugi parametr to uchwyt do poprzedniego uruchomienia danej aplikacji (jeżeli dwie kopie aplikacji działają w tym samym momencie). W środowisku Windows ten Rozdział 3. (cid:1) Aplikacje okienkowe 73 07... Jeżeli chcemy sprawdzić, czy uruchomiono wcześniej parametr ma zawsze wartość jakieś kopie programu, musimy to zrobić w inny sposób. Trzeci parametr, NR OF.KPG, to łańcuch znakowy zawierający argumenty przekazane do programu w linii komend przy uruchamianiu. Ten mechanizm omówię w dalszej części niniejszego rozdziału. Ostatni parametr zawiera flagi określające sposób wyświetlania głównego okna programu. Funkcja 9KP/CKP jest wywoływana przez system przy uruchamianiu aplikacji i zwykle wartość żadnego z tych parametrów nie jest bezpośrednio zadawana przez programistę. Ćwiczenie 3.2. Pierwszy program GUI: Aby nie przedłużać, zabierzmy się za nasz pierwszy program w WinAPI. Będzie to proste okno dialogowe z napisem Witaj Przygodo. 1. W funkcję 9KP/CKP wpiszmy instrukcję: /GUUCIG$QZ 07..9KVCLRT[IQFQŒVGUVŒ/$A1-^/$A+ 10+0(14/#6+10^/$A6#5-/1 #.  Teraz cały listing naszego programu wygląda tak: KPENWFGYKPFQYUJ KHFGHAA$14.#0 AA RTCIOCCTIUWUGF GPFKH KPV#2+ 064;9KP/CKP *+056#0 J+PUVCPEG*+056#0 J2TGX+PUVCPEG.2564 NR OF.KPGKPVP OF5JQY ] /GUUCIG$QZ 07..9KVCLRT[IQFQŒVGUVŒ/$A1-^/$A+ 10+0(14/#6+10^/$A6#5-/1 #.  TGVWTP _ 2. Wybieramy z menu Run opcję Run Project. 3. Nastąpi kompilacja, a następnie uruchomienie programu. Na ekranie ujrzymy nasze okienko. Powinno wyglądać tak (rysunek 3.1): Rysunek 3.1. Pierwszy program Jeżeli program nie uruchomił się, sprawdźmy, czy kod źródłowy wygląda dokładnie tak, jak na listingu wyżej. Jeżeli wszystko przebiegło bez zakłóceń, to właśnie napisałeś i uruchomiłeś, Czytelniku, swój pierwszy program okienkowy w C++BuilderX. Choć programik jest tak prosty, można wykorzystać go do nauki dwóch rzeczy. Po pierw- sze, przyjrzymy się funkcji /GUUCIG$QZ. Po drugie, poznamy mechanizm przekazywania parametrów w linii komend przy uruchamianiu programu. Funkcja /GUUCIG$QZ, jak już wiemy, tworzy okno komunikatów. Jest to proste okno wy- świetlające tekst wiadomości i dające użytkownikowi możliwość reakcji przez naciśnięcie 74 C++BuilderX. Ćwiczenia przycisku. Można sterować rodzajem wyświetlanych przycisków. Po naciśnięciu przy- cisku okno znika, a funkcja zwraca odpowiednią wartość w zależności od naciśniętego przycisku. Prototyp tej funkcji wygląda następująco: KPV/GUUCIG$QZ *90 J9PF.2 6564NR6GZV.2 6564NR CRVKQP7+06W6[RG Parametr J9PF oznacza uchwyt do okna macierzystego, do tego okna zostanie przesłany komunikat po naciśnięciu przycisku. W naszym przypadku nie ma okna macierzystego, więc ten parametr ma wartość 07... Druga zmienna to łańcuch komunikatu wyświetlany w oknie. NR CRVKQP to również łańcuch znakowy wyświetlany w pasku aplikacji. Ostatni parametr, W6[RG, to flagi określające, jakie przyciski będą dostępne w oknie, jaka będzie ikona i sposób zachowania się okna. Ćwiczenie 3.3. Aby zmienić wygląd okna komunikatów: 1. Zmieńmy ostatni parametr funkcji z /$A1- na /$A1- #0 .: /GUUCIG$QZ 07..9KVCLRT[IQFQŒVGUVŒ/$A1- #0 .^/$A+ 10+0(14/#6+10^/$A6#5-/1 #.  2. Po uruchomieniu programu okno ma dwa przyciski, OK i Anuluj: 3. Zamiast /$A+ 10+0(14/#6+10 wpiszmy /$A+ 105612: /GUUCIG$QZ 07..9KVCLRT[IQFQŒVGUVŒ/$A1-^/$A+ 105612^/$A6#5-/1 #.  4. Po kompilacji otrzymamy okno z ikoną błędu krytycznego systemu. Na szczęście to tylko ikona. Inne możliwe wartości flag zestawiono w tabeli 3.1 i tabeli 3.2. Tabela 3.1. Wybór rodzaju i liczby przycisków Wartość flagi Przyciski /$A1- OK /$A#$1464 64;+)014 Przerwij, Ponów próbę oraz Ignoruj /$A1- #0 . /$A4 64; #0 . /$A; 501 /$A; 501 #0 . OK oraz Anuluj Ponów próbę i Anuluj Tak oraz Nie Tak, Nie i Anuluj Tabela 3.2. Wybór rodzaju ikony z boku wiadomości Wartość Ikona /$A+ 10 : .#/#6+10 /$A+ 10+0(14/#6+10 /$A+ 10#56 4+5- /$A+ 1037 56+10 /$A+ 105612 ostrzegawczy wykrzyknik „dymek” informacyjny „dymek” ze znakiem zapytania błąd krytyczny Rozdział 3. (cid:1) Aplikacje okienkowe 75 Sposób zachowania się okna dialogowego: (cid:1) /$A#22./1 #. — Okno macierzyste komunikatu pozostaje nieaktywne, dopóki użytkownik nie wybierze jednego z przycisków. (cid:1) /$A5;56 //1 #. — Tak samo jak /$A#22./1 #.. Dodatkowo okno komunikatu jest zawsze na pierwszym planie. Ta opcja ma zastosowanie do ważnych komunikatów, wymagających natychmiastowej uwagi użytkownika. (cid:1) /$A6#5-/1 #. — Tak samo jak /$A#22./1 #., ale jeżeli parametr J9PF wynosi 07.., zostaną zablokowane wszystkie okna aplikacji, a nie tylko macierzyste. Zachęcam do eksperymentowania z flagami i obserwacji, jak będzie się zmieniać okno dialogowe. Ćwiczenie 3.4. Uruchomienie programu w C++BuilderX z przekazywaniem argumentów z linii komend: 1. Zmieńmy program tak, aby w oknie wiadomości wyświetlał się parametr przekazany w linii komend. Jak już pisałem, parametry te są przekazywane w parametrze NR OF.KPG funkcji 9KP/CKP. Wystarczy więc podstawić ten parametr za zmienną NR6GZV funkcji /GUUCIG$QZ: /GUUCIG$QZ 07..NR OF.KPGVGUV/$A1-^/$A+ 10+0(14/#6+10^/$A6#5-/1 #.  2. Aby nakazać uruchamianie aplikacji z dodatkową zmienną, wchodzimy w menu Run i wybieramy opcję Configurations. 3. Ukaże się okno Project Properties, wybieramy zakładkę Run (jest ona wybrana domyślnie). W oknie Runtime configurations powinna być zaznaczona konfiguracja dla naszej aplikacji Hello. 4. Klikamy przycisk Edit. Pojawi się okno edycji konfiguracji. 5. Znajdujemy okno Command line argument i wpisujemy tam cokolwiek. Pogram będzie uruchamiany z argumentem, jaki tam wpisaliśmy. 6. Następnie klikamy OK i znowu OK, a następnie kompilujemy i uruchamiamy program tak jak wcześniej. 7. Tekst wpisany jako argument pojawi się w oknie wiadomości. Warto zwrócić uwagę na dolne okno pokazujące proces kompilacji. Podczas działania programu będzie tam komenda uruchamiająca nasz program wraz z argumentem. Wejdźmy jeszcze raz w menu RunConfigurations. Runtime configurations to wygodne narzędzie do testowania różnych opcji uruchamiania programu. Zamiast zmieniać ist- niejącą konfigurację, możemy dodać nową przyciskiem New. Każda konfiguracja może mieć inne opcje. Gdy mamy więcej niż jedną konfigurację, program zostanie urucho- miony w tej, przy której zaznaczymy okienko w kolumnie Default. Do tego narzędzia wrócimy jeszcze w dalszych przykładach. W następnym podrozdziale napiszemy główne okno aplikacji „z prawdziwego zdarzenia”. Będzie ono bazą do umieszczania różnych komponentów. 76 C++BuilderX. Ćwiczenia Główne okno aplikacji Nasz pierwszy program składał się tylko z jednego okna dialogowego. Teraz napiszemy pierwszą „prawdziwą” aplikację, a raczej jej okno główne. Aplikacja Windows składa się z okien, między którymi przesyłane są komunikaty. Główne okno aplikacji otrzymuje ko- munikaty z systemu i odpowiednio na nie reaguje. Z oknem związana jest tzw. funkcja zwrotna (ang. callback function), do której przekazywane są komunikaty. Zawiera ona procedury obsługi tych komunikatów w zależności od ich treści. Okno jest obiektem klasy 90 .#55. Podczas tworzenia nowego okna musimy wygene- rować nowy obiekt. Najpierw zadamy odpowiednie wartości składowych klasy. W naszym przykładzie nazwiemy ją INQYPGAQMPQ. Postaram się maksymalnie krótko objaśnić składowe tej klasy. To ćwiczenie będzie trochę przydługie, ale później będzie nam już łatwiej. Wszystkie linie listingu wpisujemy w funkcję 9KP/CKP . Ćwiczenie 3.5. Aby utworzyć główne okno aplikacji: 1. Pierwsza linia to deklaracja obiektu klasy 90 .#55. Druga to ustawienie składowej UV[NG. 90 .#55INQYPGAQMPQ INQYPGAQMPQUV[NG 5A*4 4#9^ 5A84 4#9 (cid:1) 5A*4 4#9 — oznacza, że okno będzie rysowane od nowa przy zmianie jego szerokości. (cid:1) 5A84 4#9 — zapewnia rysowanie okna przy zmianie wysokości. 2. Składowa NRHP9PF2TQE wskazuje na funkcję, która będzie przetwarzać komunikaty nadsyłane do okna. Zostaną one przesłane do funkcji (nazywanej tutaj )NQYPC(WPMELC), a w niej umieścimy procedury do ich obsługi. INQYPGAQMPQNRHP9PF2TQE)NQYPC(WPMELC Pierwowzorem tej funkcji jest 9KPFQY2TQE (linii podanej poniżej nie wpisujemy do programu): .4 57.6 #..$# -9KPFQY2TQE *90 JYPF7+06W/UI92#4#/Y2CTCO.2#4#/N2CTCO  Komunikat przekazywany jest poprzez zmienną W/UI tej funkcji. W programie możemy nadać jej dowolną nazwę. Mimo, że nie deklarujemy tego jawnie, program będzie zakładał, że funkcja typu .4 57.6 #..$# -, której adres znajduje się w zmiennej NRHP9PF2TQE, ma takie same parametry jak 9KPFQY2TQE, a tylko inną nazwę. Definicje naszej funkcji zwrotnej wpiszemy zaraz po plikach nagłówkowych, przed 9KP/CKP . .4 57.6 #..$# -)NQYPC(WPMELC *90 JYPF7+06OUIG92#4#/Y2CTCO.2#4#/N2CTCO ] TGVWTP GH9KPFQY2TQE JYPFOUIGY2CTCON2CTCO  _ Na razie będzie ona zwracała wartość funkcji GH9KPFQY2TQE. Jest to domyślna wartość zwracana przez funkcję zwrotną. Rozdział 3. (cid:1) Aplikacje okienkowe 77 3. Przenosimy się z powrotem do wnętrza 9KP/CKP . Składowa ED NU ZVTC zawiera liczbę dodatkowych bajtów dodanych do każdej klasy, a ED9PF ZVTC liczbę dodatkowych bajtów dodanych do każdej działającej kopii okna. Obie te wartości ustawiamy na zero. INQYPGAQMPQED NU ZVTCINQYPGAQMPQED9PF ZVTC 4. J+PUVCPEG wskazuje na uchwyt do aplikacji, której częścią jest dane okno. W naszym przypadku uchwyt ten znajduje się w zmiennej AJ+PUVCPEG. INQYPGAQMPQJ+PUVCPEGAJ+PUVCPEG 5. Następna składowa określa ikonę widoczną w pasku aplikacji. Ta składowa musi być inicjalizowana uchwytem do ikony. INQYPGAQMPQJ+EQP.QCF+EQP 07..+ +A#22.+ #6+10  Tutaj posłużymy się funkcją .QCF+EQP. Funkcja ta pobiera ikonę z pliku exe. Posiada ona dwa parametry. Pierwszy to uchwyt do aplikacji, która zawiera ikonę, a drugi to nazwa ikony. Istnieją ikony standardowe. Dla nich parametr pierwszy musi mieć wartość 07... Nazwy ikon standardowych to: + +A#22.+ #6+10 + +A#56 4+5- + +A : . + +A*#0 + +A37 56+10 + +A9+0.1)1 Domyślna ikona aplikacji Asterisk (informacje) Wykrzyknik (ostrzeżenia) Ikona ręki (poważne ostrzeżenia) Znak zapytania (zapytania) logo Windows 6. Zmienna J WTUQT identyfikuje kursor, jaki będzie się pojawiał, gdy wskaźnik znajdzie się w obszarze okna. Funkcja .QCF WTUQT ma takie same parametry jak .QCF+EQP. INQYPGAQMPQJ WTUQT.QCF WTUQT 07..+ A#4419  Tu również występują standardowe kursory (pierwszy parametr 07..): + A#2256#46+0) Strzałka i mała klepsydra + A#4419 + A 4155 + A+$ #/ + A+ 10 + A01 + A5+ + A5+ #.. + A5+ 0 59 + A5+ 05 + A5+ 095  + A5+ 9 + A72#4419 + A9#+6 Strzałka Krzyżyk Kursor tekstowy Pusta ikona (tylko Windows NT) Koło ukośnie przekreślone Strzałka w cztery strony (tylko Windows NT) To samo, co + A5+ , ale dla innych systemów Podwójne strzałki w różnych kierunkach Pionowa strzałka Klepsydra 78 C++BuilderX. Ćwiczenia 7. JDT$CEMITQWPF określa sposób wypełnienia tła okna. Inicjalizujemy go nazwą jednego z kolorów systemowych określonych dla składowych interfejsu systemów. Innymi słowy, możemy zażądać, aby okno miało kolor taki, jak np. paski okien, przyciski czy menu. W naszym przykładzie kolor jest ustawiony na standardowy kolor okna. Nazwy kolorów muszą być konwertowane na typ *$475*. Po zmianie schematu kolorów zmieni się też kolor tła naszego okna. INQYPGAQMPQJDT$CEMITQWPF *$475* 1.14A9+0 19 8. Składowa NRU/GPW0COG wskazuje na menu stowarzyszone z oknem. Nasze okno na razie nie ma menu, więc parametr inicjalizujemy wartością 07... INQYPGAQMPQNRU/GPW0COG07.. 9. NRU NCUU0COG określa nazwę klasy okna. Jako nazwę przypiszemy łańcuch znakowy (tytuł), który oczywiście musimy uprzednio zdefiniować. Najpierw opuszczamy więc funkcję 9KP/CKP i wpisujemy definicję zmiennej V[VWN bezpośrednio po nagłówku programu, przed funkcją )NQYPC(WPMELC: UVCVKEEQPUVEJCTV[VWN=?1MPQINQYPGCRNKMCELK Teraz wracamy do 9KP/CKP i podstawiamy tytuł pod NRU NCUU0COG: INQYPGAQMPQNRU NCUU0COGV[VWN Składowe klasy 90 .#55 mogą przybierać różne wartości, a jako wynik otrzymujemy odpowiedni wygląd i zachowanie okna. Wymienienie wszystkich możliwości przekracza zakres tej książki. Ograniczyłem się tylko do tych, które są w danej chwili potrzebne. 10. Po inicjalizacji składowych klasy należy ją zarejestrować za pomocą funkcji 4GIKUVGT NCUU, a następnie (w przypadku udanej rejestracji) stworzyć okno oparte na naszej klasie. Okno tworzymy za pomocą funkcji TGCVG9KPFQY. W naszym przypadku użyjemy jej w postaci: KH 4GIKUVGT NCUU INQYPGAQMPQ ] OCKPAJYPF TGCVG9KPFQY V[VWNV[VWN 95A18 4.#22 9+0 19^95A .+2 *+. 4 0  9A75 (#7.6 9A75 (#7.6  9A75 (#7.6 9A75 (#7.6 *90 A 5-61207..AJ+PUVCPEG07..  _ GNUG OCKPAJYPF07.. Pierwszy parametr oznacza nazwę klasy reprezentującej okno. Nie jest to nazwa obiektu klasy, ale nazwa wpisana w zmienną NRU NCUU0COG. Drugi parametr to łańcuch znakowy, który będzie wyświetlany w pasku okna. Dla uproszczenia wpiszemy tu ten sam tekst, który oznacza nazwę klasy. Następny parametr określa sposób wyświetlania okna. (cid:1) 95A18 4.#22 9+0 19 — wskazuje, że okno ma posiadać pasek tytułowy i ramkę. (cid:1) 95A .+2 *+. 4 0 — określa, że podczas malowania na oknie nie będzie zamazany obszar ewentualnych okien potomnych tego okna. Następne parametry oznaczają Rozdział 3. (cid:1) Aplikacje okienkowe 79 współrzędne okna oraz jego szerokość i wysokość. Użyjemy tu zmiennej 9A75 (#7.6 przyporządkowującej tym zmiennym wartości standardowe zapisane w systemie. Następny parametr określa uchwyt do okna stojącego wyżej w hierarchii. Ponieważ jest to pierwsze okno w aplikacji, funkcję okna nadrzędnego pełni pulpit. Dlatego podstawiamy tu *90 A 5-612. Kolejny parametr ma dwa znaczenia. Dla okna posiadającego pasek i ramkę (tak jak nasze główne okno) oznacza menu stowarzyszone z oknem. Dla okna potomnego (ang. child window) oznacza uchwyt do tego okna. Wyjaśnię to na przykładach w dalszych podrozdziałach. Ponieważ nasze okno nie ma menu, parametr ten wynosi 07... Przedostatnia zmienna zawiera uchwyt do aplikacji, której częścią jest okno. W naszym przypadku jest to zmienna AJ+PUVCPEG. Ostatni parametr to dodatkowe wartości przekazywane do okna. Na razie ustawimy go na 07... W przypadku powodzenia funkcja TGCVG9KPFQY zwraca uchwyt do gotowego okna. W przypadku błędu zwracana jest wartość 07... 11. Stworzenie okna nie jest równoznaczne z jego wyświetleniem. Aby to zrobić, należy użyć funkcji 5JQY9KPFQY. Wyświetla ona okno o podanym uchwycie. Jako drugi parametr zawiera zmienne określające sposób wyświetlania. W przypadku, kiedy wyświetlamy pierwsze okno aplikacji, za parametr ten należy podstawić zmienną P OF5JQY z funkcji 9KP/CKP. Następnie rysujemy wnętrze okna za pomocą 7RFCVG9KPFQY. 5JQY9KPFQY OCKPAJYPFP OF5JQY  7RFCVG9KPFQY OCKPAJYPF  12. Skompilujmy i wykonajmy nasz program. Okno na chwilkę ukaże się i zniknie. Do poprawnego działania programu brakuje nam jeszcze obsługi komunikatów. Teraz napiszemy główną pętlę programu, która będzie odbierała komunikaty nadsyłane przez system i rozsyłała je do funkcji zwrotnych, a później wypełnimy naszą funkcję )NQYPC(WPMELC procedurami obsługi podstawowych komunikatów. Ćwiczenie 3.6. Przesyłanie i przetwarzanie komunikatów: 1. W dalszym ciągu 9KP/CKP napiszmy: YJKNG )GV/GUUCIG OUI07..   ] 6TCPUNCVG/GUUCIG OUI   KURCVEJ/GUUCIG OUI  _ )GV/GUUCIG przejmuje komunikaty i wpisuje je do zmiennej OUI. Drugi parametr 07.. oznacza, że chcemy przejmować wszystkie komunikaty wysyłane do danej aplikacji. Zamiast 07.. możemy tu podstawić uchwyt do konkretnego okna, wtedy będą odbierane tylko komunikaty dla tego okna. 6TCPUNCVG/GUUCIG i KURCVEJ/GUUCIG zajmują się rozsyłaniem komunikatów do odpowiednich funkcji zwrotnych dla poszczególnych okien. Zauważmy, że pętla będzie działała, dopóki funkcja 80 C++BuilderX. Ćwiczenia )GV/GUUCIG nie zwróci wartości zero. Stanie się to wtedy, jeżeli przechwyci ona komunikat 9/A37+6, który oznacza zakończenie aplikacji. Tutaj kończymy funkcję 9KP/CKP. 2. Pozostało nam jeszcze napisanie funkcji przetwarzającej komunikaty. Na razie będzie ona obsługiwała 9/A2#+06 9/A .15 i 9/A 5641;. .4 57.6 #..$# -)NQYPC(WPMELC *90 JYPF7+06OUIG92#4#/Y2CTCO.2#4#/N2CTCO ] UYKVEJ OUIG ] ECUG9/A2#+06 ] 2#+065647 6RU $GIKP2CKPV JYPFRU  6GZV1WV RUJFE6GUV6GUV6GUVNUVTNGP 6GUV6GUV6GUV   PF2CKPV JYPFRU  TGVWTP _ ECUG9/A .15 ] GUVTQ[9KPFQY JYPF DTGCM_ ECUG9/A 5641;]2QUV3WKV/GUUCIG  TGVWTP_ _ TGVWTP GH9KPFQY2TQE JYPFOUIGY2CTCON2CTCO  _ Instrukcja UYKVEJ wywołuje odpowiednią procedurę w zależności od treści komunikatu. Komunikat 9/A2#+06 wysyłany jest przez system w przypadku, kiedy zachodzi konieczność odświeżenia okna, na przykład w chwili, gdy użytkownik zmieni położenie okna lub jego wymiary. Funkcja $GIKP2CKPV przygotowuje okno do powtórnego narysowania i wypełnia strukturę RU, która określa obszar okna. 6GZV1WV wypisuje w oknie podany ciąg znakowy. Parametrami tej funkcji są kolejno: odnośnik do struktury RU określającej granice okna, współrzędne tekstu w oknie, łańcuch znakowy zawierający tekst i długość tego łańcucha. PF2CKPV kończy malowanie okna. Komunikat 9/A .15 jest wysyłany w przypadku, kiedy użytkownik wydał komendę zamknięcia okna. Wówczas uruchamiana jest funkcja GUVTQ[9KPFQY, która kasuje wskazane okno. Funkcja ta wysyła także komunikat 9/A 5641;. Ten z kolei aktywuje funkcję 2QUV3WKV/GUUCIG, która wysyła komunikat 9/A37+6, który z kolei kończy pętlę przechwytywania wiadomości. 3. Teraz możemy już skompilować i uruchomić nasz program. Ukaże się okno takie jak poniżej (rysunek 3.2). Rysunek 3.2. Główne okno aplikacji Rozdział 3. (cid:1) Aplikacje okienkowe 81 Główne okno aplikacji będzie bazą, którą wykorzystamy do tworzenia aplikacji. W następ- nym podrozdziale stworzymy w naszej aplikacji kontrolki. Są to elementy umożliwiające komunikację użytkownika z aplikacją. Należą do nich przyciski, pola tekstowe itp.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++BuilderX. Ćwiczenia
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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