Napisz wieloplatformowe programy w C++
* Jak korzystać z bibliotek wxWidgets oraz Qt?
* W jaki sposób implementować obsługę zdarzeń w aplikacjach?
* Jak budować aplikacje sieciowe i bazodanowe?
Okres dominacji jednego systemu operacyjnego i przeznaczonych dla niego rozwiązań powoli odchodzi do historii. Fenomen popularności różnych dystrybucji Linuksa i coraz mocniejsza pozycja komputerów Mac sprawiają, że wiele firm produkujących oprogramowanie decyduje się na tworzenie rozwiązań wieloplatformowych. W przypadku ogromnych korporacji stworzenie zespołów programistycznych pracujących równolegle nad kilkoma wersjami jednej aplikacji dla różnych systemów operacyjnych nie stanowi problemu, ale w mniejszych firmach jest to niemożliwe. Tu z pomocą przychodzą biblioteki pozwalające na tworzenie kodu źródłowego prawidłowo kompilującego się na każdej platformie, na której je zainstalowano.
Książka „C++. Wykorzystaj potęgę aplikacji graficznych” opisuje tworzenie oprogramowania z wykorzystaniem dwóch takich właśnie bibliotek - wxWidgets oraz Qt. Czytając ją, dowiesz się, jak wykorzystać język C++ i środowisko Dev-C++ do pisania programów, z których korzystać będą mogli użytkownicy systemu Windows, Linuksa i Mac OS. Nauczysz się stosować kontrolki i komponenty, budować menu i interfejsy użytkownika, obsługiwać zdarzenia i implementować operacje graficzne. Przeczytasz także o aplikacjach bazodanowych i sieciowych. Każde z zagadnień omówiono zarówno w kontekście biblioteki wxWidgets, jak i biblioteki Qt, dzięki czemu poznasz dwie metody rozwiązywania tych samych zadań programistycznych - by wybrać sobie tę, która bardziej Ci odpowiada.
* Instalacja środowiska programistycznego i bibliotek
* Struktura aplikacji i podstawowe komponenty
* Stosowanie komponentów
* Obsługa zdarzeń myszy i klawiatury
* Budowanie menu aplikacji
* Komunikacja sieciowa
* Operacje graficzne
* Połączenia z bazami danych
* Drukowanie z poziomu aplikacji
Dzięki tej książce stworzysz aplikacje, które docenią użytkownicy wszystkich systemów operacyjnych.
1. C++. Wykorzystaj potêgê
aplikacji graficznych
Autor: Janusz Ganczarski,
Mariusz Owczarek
ISBN: 978-83-246-1473-8
Format: 158x235, stron: 448
Napisz wieloplatformowe programy w C++
• Jak korzystaæ z bibliotek wxWidgets oraz Qt?
• W jaki sposób implementowaæ obs³ugê zdarzeñ w aplikacjach?
• Jak budowaæ aplikacje sieciowe i bazodanowe?
Okres dominacji jednego systemu operacyjnego i przeznaczonych dla niego rozwi¹zañ
powoli odchodzi do historii. Fenomen popularnoœci ró¿nych dystrybucji Linuksa
i coraz mocniejsza pozycja komputerów Mac sprawiaj¹, ¿e wiele firm produkuj¹cych
oprogramowanie decyduje siê na tworzenie rozwi¹zañ wieloplatformowych.
W przypadku ogromnych korporacji stworzenie zespo³ów programistycznych
pracuj¹cych równolegle nad kilkoma wersjami jednej aplikacji dla ró¿nych systemów
operacyjnych nie stanowi problemu, ale w mniejszych firmach jest to niemo¿liwe.
Tu z pomoc¹ przychodz¹ biblioteki pozwalaj¹ce na tworzenie kodu Ÿród³owego
prawid³owo kompiluj¹cego siê na ka¿dej platformie, na której je zainstalowano.
Ksi¹¿ka „C++. Wykorzystaj potêgê aplikacji graficznych” opisuje tworzenie
oprogramowania z wykorzystaniem dwóch takich w³aœnie bibliotek – wxWidgets
oraz Qt. Czytaj¹c j¹, dowiesz siê, jak wykorzystaæ jêzyk C++ i œrodowisko Dev-C++
do pisania programów, z których korzystaæ bêd¹ mogli u¿ytkownicy systemu Windows,
Linuksa i Mac OS. Nauczysz siê stosowaæ kontrolki i komponenty, budowaæ menu
i interfejsy u¿ytkownika, obs³ugiwaæ zdarzenia i implementowaæ operacje graficzne.
Przeczytasz tak¿e o aplikacjach bazodanowych i sieciowych. Ka¿de z zagadnieñ
omówiono zarówno w kontekœcie biblioteki wxWidgets, jak i biblioteki Qt, dziêki czemu
poznasz dwie metody rozwi¹zywania tych samych zadañ programistycznych – by
wybraæ sobie tê, która bardziej Ci odpowiada.
• Instalacja œrodowiska programistycznego i bibliotek
• Struktura aplikacji i podstawowe komponenty
• Stosowanie komponentów
Wydawnictwo Helion • Obs³uga zdarzeñ myszy i klawiatury
ul. Koœciuszki 1c • Budowanie menu aplikacji
44-100 Gliwice • Komunikacja sieciowa
tel. 032 230 98 63 • Operacje graficzne
e-mail: helion@helion.pl • Po³¹czenia z bazami danych
• Drukowanie z poziomu aplikacji
Dziêki tej ksi¹¿ce stworzysz aplikacje,
które doceni¹ u¿ytkownicy wszystkich systemów operacyjnych.
2. Spis tre�ci
Rozdzia� 1. Opis i instalacja bibliotek ................................................................. 9
Wst�p ................................................................................................................................ 9
Biblioteka wxWidgets ...................................................................................................... 9
Instalacja �rodowiska wxDev-C++ ........................................................................... 10
Elementy wxDev-C++ .............................................................................................. 10
Tworzenie projektu aplikacji w wxDev-C++ ........................................................... 11
Biblioteka Qt .................................................................................................................. 12
Instalacja Dev-C++ .................................................................................................. 12
Instalacja bibliotek Qt .............................................................................................. 12
Konfiguracja Dev-C++ do wspó�pracy z Qt ............................................................. 13
Tworzenie szablonu projektu aplikacji Qt ................................................................ 15
Rozdzia� 2. Struktura aplikacji wxWidgets ........................................................ 19
Cz��ci sk�adowe aplikacji ............................................................................................... 19
Zgodno�� ze standardem Unicode .................................................................................. 22
Tworzenie kontrolek ....................................................................................................... 23
Zdarzenia ........................................................................................................................ 24
Wizualne tworzenie aplikacji w �rodowisku wxDev-C++ .............................................. 26
Struktura projektu wykorzystywana podczas budowy aplikacji za pomoc� IDE ..... 27
Nazwy parametrów u�yte w ksi��ce ............................................................................... 28
Test ................................................................................................................................. 28
Rozdzia� 3. Podstawowe komponenty aplikacji ................................................. 31
Okno wxFrame ............................................................................................................... 31
Style okna ................................................................................................................. 32
Ikona w oknie aplikacji ............................................................................................ 33
Czcionki w aplikacji ................................................................................................. 34
Panele wxPanel ............................................................................................................... 35
Przyciski wxButton ........................................................................................................ 36
Etykieta wxStaticText ..................................................................................................... 38
Pola wyboru i przyciski opcji ......................................................................................... 40
Komponent wprowadzania i edycji tekstu wxTextCtrl ................................................... 44
Test ................................................................................................................................. 48
Rozdzia� 4. Wi�cej o zdarzeniach ...................................................................... 49
Rodzaje zdarze� .............................................................................................................. 49
Dynamiczna obs�uga zdarze� ......................................................................................... 49
Rozpoznawanie obiektu generuj�cego zdarzenie w metodzie obs�ugi ............................ 53
3. 4 C++. Wykorzystaj pot�g� aplikacji graficznych
Obs�uga zdarze� myszy .................................................................................................. 56
Obs�uga zdarze� klawiatury ........................................................................................... 58
Test ................................................................................................................................. 61
Rozdzia� 5. Zastosowania menu ....................................................................... 63
Podstawy menu ............................................................................................................... 63
Obs�uga menu za pomoc� tabeli zdarze� ........................................................................ 66
Obs�uga menu za pomoc� metody Connect() ................................................................. 68
Tworzenie menu podczas dzia�ania aplikacji .................................................................. 70
Menu kontekstowe .......................................................................................................... 73
Skróty klawiaturowe w opcjach menu ............................................................................ 75
Paski narz�dzi ................................................................................................................. 77
Pasek statusu ................................................................................................................... 81
Test ................................................................................................................................. 85
Rozdzia� 6. Okna dialogowe ............................................................................. 87
Okna komunikatów ........................................................................................................ 87
Okno z mo�liwo�ci� wprowadzania danych ................................................................... 89
Zwyk�e okno do wprowadzania tekstu ..................................................................... 89
Okno has�a ................................................................................................................ 90
Okna zapisu i otwarcia pliku .......................................................................................... 92
Okno wyboru czcionki .................................................................................................... 94
Paleta kolorów ................................................................................................................ 96
Test ................................................................................................................................. 98
Rozdzia� 7. Podstawy aplikacji sieciowych ...................................................... 101
Protokó� FTP ................................................................................................................ 101
Logowanie do serwera i wy�wietlanie zawarto�ci katalogu ................................... 101
Operacje na folderach i plikach .............................................................................. 105
Pobieranie plików z serwera ................................................................................... 107
Wysy�anie plików z dysku lokalnego ..................................................................... 109
Protokó� HTTP ............................................................................................................. 111
Pobieranie stron Web ............................................................................................. 111
Wy�wietlanie stron w postaci graficznej — komponent wxHtmlWindow ............. 113
Prezentacja wyników dzia�ania aplikacji w postaci HTML .................................... 115
Komórki wxHtmlCell ............................................................................................. 118
Test ............................................................................................................................... 122
Rozdzia� 8. Grafika ......................................................................................... 125
Mapy bitowe wxBitmap ............................................................................................... 125
Kontekst urz�dzenia — klasa wxDC ............................................................................ 126
Rysowanie w oknie — kontekst wxClientDC .............................................................. 128
Obs�uga zdarzenia Paint — kontekst wxPaintDC ......................................................... 132
Rysowanie w pami�ci — wxMemoryDC ..................................................................... 134
Kontekst ekranu — wxScreenDC ................................................................................. 136
Pióro wxPen ................................................................................................................. 138
P�dzel wxBrush ............................................................................................................ 141
Podstawy obs�ugi biblioteki OpenGL w wxWidgets .................................................... 143
Rysowanie obiektów trójwymiarowych ................................................................. 147
Animacje ................................................................................................................ 149
Test ............................................................................................................................... 151
4. Spis tre�ci 5
Rozdzia� 9. Aplikacje baz danych .................................................................... 153
Bazy danych a wxWidgets ............................................................................................ 153
Instalacja PostgreSQL .................................................................................................. 153
Inicjalizacja bazy .......................................................................................................... 155
Organizacja i typy danych w bazach PostgreSQL ........................................................ 156
J�zyk SQL .................................................................................................................... 158
Po��czenie aplikacji wxWidgets z baz� danych ............................................................ 158
Dodawanie tabel do bazy .............................................................................................. 161
Zapis danych do tabeli .................................................................................................. 165
Wyszukiwanie i odczyt danych z tabeli ........................................................................ 167
Zmiana warto�ci w rekordach ....................................................................................... 171
Test ............................................................................................................................... 172
Rozdzia� 10. Drukowanie w wxWidgets ............................................................. 175
Drukowanie na ró�nych platformach ............................................................................ 175
Drukowanie tekstu ........................................................................................................ 175
Drukowanie tekstu z formatowaniem ..................................................................... 178
Podgl�d wydruku tekstu ......................................................................................... 180
Drukowanie grafiki ....................................................................................................... 181
Obiekt wydruku wxPrintout ................................................................................... 181
Urz�dzenie drukarki — klasa wxPrinter ................................................................. 183
Okno podgl�du drukowania grafiki ........................................................................ 185
Skalowanie wydruku graficznego .......................................................................... 187
Test ............................................................................................................................... 191
Rozdzia� 11. Elementy aplikacji wielow�tkowych .............................................. 195
Wielow�tkowo�� .......................................................................................................... 195
Sekcje krytyczne .................................................................................................... 196
Wzajemne wykluczenia .......................................................................................... 196
Semafory ................................................................................................................ 196
Klasa wxThread ............................................................................................................ 196
Sekcja krytyczna — wxCriticalSection ........................................................................ 198
Wykluczenie wxMutex ................................................................................................. 199
Semafor wxSemaphore ................................................................................................. 199
Prosta aplikacja z kilkoma w�tkami ............................................................................. 200
Przekazywanie danych z w�tku poprzez zdarzenia ...................................................... 204
Ograniczenie ilo�ci w�tków za pomoc� semafora ........................................................ 205
Test ............................................................................................................................... 207
Rozdzia� 12. Struktura aplikacji Qt ................................................................... 209
Korzystamy z szablonu ................................................................................................. 209
Pierwszy program krok po kroku .................................................................................. 211
Wy�wietlamy polskie znaki .......................................................................................... 212
Podstawy hierarchii elementów interfejsu u�ytkownika ............................................... 214
Tworzenie w�asnej klasy okna ...................................................................................... 216
Qt Designer ................................................................................................................... 218
Integracja Qt Designer i Dev-C++ ................................................................................ 221
Wykorzystanie formularzy w programach .................................................................... 222
Test ............................................................................................................................... 228
5. 6 C++. Wykorzystaj pot�g� aplikacji graficznych
Rozdzia� 13. Podstawowe komponenty aplikacji ............................................... 229
Klasa QMainWindow ................................................................................................... 229
Rozpoczynamy budow� edytora tekstu ........................................................................ 229
Rodzaje okien ............................................................................................................... 232
Ikona aplikacji i zasoby ................................................................................................ 234
Menu ............................................................................................................................. 236
Klawisze skrótu ...................................................................................................... 238
Komunikaty na pasku statusu ................................................................................. 239
Pasek statusu ................................................................................................................. 241
Pasek narz�dzi .............................................................................................................. 242
Wygl�d paska narz�dzi ........................................................................................... 242
Dodajemy w�asne gniazda ............................................................................................ 244
Edytor tekstu — formularz w Qt Designer ................................................................... 247
Klasa QString ............................................................................................................... 250
Test ............................................................................................................................... 253
Rozdzia� 14. Wi�cej o zdarzeniach .................................................................... 255
Sygna�y i gniazda ......................................................................................................... 255
Metaobiekty ............................................................................................................ 255
Definiowanie gniazd .............................................................................................. 256
Definiowanie oraz emitowanie sygna�ów ............................................................... 257
Kompilator MOC ................................................................................................... 257
Definiowanie po��cze� ........................................................................................... 258
Usuwanie po��cze� ................................................................................................. 260
Dynamiczna obs�uga po��cze� ............................................................................... 260
Program przyk�adowy ............................................................................................ 261
Obs�uga zdarze� ........................................................................................................... 262
Rodzaje zdarze� ..................................................................................................... 263
Informacje przekazywane przy zdarzeniach ........................................................... 263
Selektywna obs�uga zdarze� ................................................................................... 267
Test ............................................................................................................................... 269
Rozdzia� 15. Zastosowania menu ..................................................................... 271
Menu wielopoziomowe ................................................................................................ 271
Zmiana parametrów czcionki w menu .......................................................................... 273
W�a�ciwo�ci elementów menu, sygna�y i gniazda ........................................................ 276
Grupowanie elementów menu ...................................................................................... 279
Menu podr�czne programu ........................................................................................... 282
Dynamiczne tworzenie elementów menu ..................................................................... 284
Test ............................................................................................................................... 285
Rozdzia� 16. Okna dialogowe ........................................................................... 287
Okna komunikatów ...................................................................................................... 287
Okna pobierania danych ............................................................................................... 296
Okna narz�dziowe ........................................................................................................ 299
Okno wyboru koloru .............................................................................................. 300
Okno wyboru czcionki ........................................................................................... 302
Obs�uga plików i folderów ..................................................................................... 303
Test ............................................................................................................................... 306
Rozdzia� 17. Podstawy aplikacji sieciowych ...................................................... 307
Obs�uga protokó�u FTP ................................................................................................ 307
Operacje na serwerze FTP ...................................................................................... 307
Sygna�y klasy QFtp ................................................................................................ 309
6. Spis tre�ci 7
Adresy zasobów internetowych .............................................................................. 309
Program przyk�adowy ............................................................................................ 311
Obs�uga protokó�u HTTP ............................................................................................. 319
Operacje na serwerze HTTP ................................................................................... 319
Sygna�y klasy QHttp .............................................................................................. 321
Program przyk�adowy ............................................................................................ 321
Test ............................................................................................................................... 326
Rozdzia� 18. Grafika ......................................................................................... 329
System graficzny w bibliotece Qt ................................................................................. 329
Uk�ad wspó�rz�dnych i rasteryzacja prymitywów .................................................. 330
Podstawowe zasady rysowania ............................................................................... 332
Obs�uga plików graficznych ................................................................................... 332
Parametry pióra ...................................................................................................... 339
Parametry p�dzla .................................................................................................... 346
Prymitywy graficzne .............................................................................................. 348
Rysowanie napisów ................................................................................................ 350
Jako�� renderingu ................................................................................................... 353
OpenGL ........................................................................................................................ 354
SVG .............................................................................................................................. 359
Test ............................................................................................................................... 364
Rozdzia� 19. Wykorzystanie komponentów baz danych ...................................... 365
Bazy danych w bibliotece Qt ........................................................................................ 365
Obs�ugiwane bazy .................................................................................................. 365
Instalacja i konfiguracja bazy danych Firebird 2.0 ....................................................... 366
Instalacja ................................................................................................................ 366
Kompilacja sterownika ........................................................................................... 367
Utworzenie bazy ..................................................................................................... 368
Po��czenie z baz� danych ............................................................................................. 369
Obs�uga b��dów ...................................................................................................... 370
Tworzenie tabel ............................................................................................................ 372
Podstawowe elementy j�zyka SQL ........................................................................ 372
Wybrane typy danych ............................................................................................. 372
Obs�uga zapyta� ..................................................................................................... 372
Dodawanie danych do tabel .......................................................................................... 375
Wyszukiwanie danych .................................................................................................. 376
Modyfikacja i usuwanie danych ................................................................................... 380
Test ............................................................................................................................... 389
Rozdzia� 20. Drukowanie pod Qt ....................................................................... 391
Urz�dzenie graficzne do druku ..................................................................................... 391
Klasa QPrinter ........................................................................................................ 391
Uk�ad wspó�rz�dnych ............................................................................................. 392
Podzia� na strony .................................................................................................... 393
Okna dialogowe obs�uguj�ce drukowanie .................................................................... 393
Drukowanie tekstu ........................................................................................................ 394
Drukowanie rysunków .................................................................................................. 395
Drukowanie do plików PDF ......................................................................................... 397
Podgl�d wydruku .......................................................................................................... 399
Test ............................................................................................................................... 405
7. 8 C++. Wykorzystaj pot�g� aplikacji graficznych
Rozdzia� 21. Programowanie wielow�tkowe ...................................................... 407
Podstawowe zagadnienia programowania wielow�tkowego ........................................ 407
W�tki w bibliotece Qt ................................................................................................... 408
Uruchamianie i kontrola w�tków ........................................................................... 409
Przerwanie i zatrzymanie w�tku ............................................................................. 410
Sygna�y klasy QThread .......................................................................................... 410
Funkcja oczekuj�ca ................................................................................................ 411
Synchronizacja w�tków ................................................................................................ 411
Muteksy .................................................................................................................. 413
Semafory ................................................................................................................ 414
W�tki w aplikacji GUI .................................................................................................. 415
Test ............................................................................................................................... 422
Dodatek A Odpowiedzi do testów .................................................................. 423
Skorowidz .................................................................................... 425
8. Rozdziaä 12.
Struktura aplikacji Qt
W pierwszym rozdziale po wi conym bibliotece Qt poznasz podstawowe zasady do-
tycz ce struktury aplikacji w tej e bibliotece. Utworzymy gáówne okno aplikacji, umie-
cimy na nim pierwsze elementy graficznego interfejsu u ytkownika (GUI), zmierzymy
si z problemem polskich znaków, aby w ko cu poznaü podstawy obsáugi zdarze
w bibliotece Qt. Nast pnie po krótkim wprowadzeniu do Qt Designera wykonamy tak
sam prac ponownie, ale stosuj c to znakomite narz dzie z biblioteki Qt. Do tworzenia
programów b dziemy korzystaü z szablonu opisanego w rozdziale 1.
Korzystamy z szablonu
Przykäad 12.1. Pierwszy program w Qt
— wykorzystanie szablonu aplikacji
1. Aby skorzystaü z szablonu, wybierz z menu opcj PlikNowy Projekt i dalej
w zakáadce GUI wska szablon aplikacji Qt, tak jak to przedstawiamy na
rysunku 12.1. Do ewentualnej zmiany pozostaje nazwa projektu. rodowisko
Dev-C++ przyjmuje, e nowy projekt nazywa si po prostu Projekt i do tej
nazwy dodaje mu kolejny numer.
2. Po wybraniu szablonu pliki projektu zapisz w wybranym folderze i w efekcie
powiniene uzyskaü program analogiczny do przedstawionego na rysunku 12.2.
Musisz jeszcze zapisaü plik ródáowy programu, ewentualnie zmieniaj c
przy tym jego nazw z domy lnego main.cpp.
Warto wspomnieü jeszcze o jednej wa nej zasadzie obowi zuj cej przy zapisie
projektów. Z uwagi na generowanie przy ka dym projekcie pliku Makefile.win
zawieraj cego instrukcje dla narz dzia make, koniecznie zapisuj pliki projektów
w odr bnych katalogach. W przeciwnym wypadku mo e doj ü do przypadkowej
utraty zawarto ci tego pliku.
9. 210 C++. Wykorzystaj potögö aplikacji graficznych
Rysunek 12.1.
Okno wyboru nowego
projektu z szablonem
aplikacji Qt 4.3.1
Rysunek 12.2. Widok rodowiska Dev-C++ po wygenerowaniu szablonu programu Qt
3. Oto tekst ródáowy caáego programu:
#include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app (argc, argv);
10. Rozdziaä 12. i Struktura aplikacji Qt 211
QPushButton button ("Hello world!");
button.resize (100, 30);
button.show();
return app.exec();
}
4. Kompilacja programu wymaga wybrania z menu opcji ProjektKompiluj
i uruchom lub u ycia klawisza F9. W efekcie otrzymamy okno przedstawione
na rysunku 12.3. Program nawi zuje do klasycznej postaci pierwszego
programu, który w swojej karierze napisaáo wielu programistów. Efekt jego
dziaáania wprawdzie nie jest imponuj cy, ale pokazuje pot g biblioteki Qt,
która w kilku wierszach kodu umo liwia wy wietlenie okna z przyciskiem.
Rysunek 12.3.
Pocz tkowy wygl d
okna pierwszego
programu
Pierwszy program krok po kroku
Przeanalizujemy teraz krok po kroku kod ródáowy programu wygenerowanego przez
szablon. Dwa pocz tkowe wiersze programu:
#include <QApplication>
#include <QPushButton>
wá czaj pliki nagáówkowe biblioteki Qt zawieraj ce definicje klas QApplication
i QPushButton. Pierwszej z nich u ywa ka dy program, który korzysta z graficznych
elementów biblioteki Qt. Jej zadaniem jest inicjalizacja i zako czenie dziaáania pro-
gramu, przetwarzanie p tli zdarze i umo liwienie ich obsáugi przez elementy graficz-
nego interfejsu. Klasa ta dziedziczy po klasie QCoreApplication, która z kolei jest klas
bazow dla programów pracuj cych w trybie konsoli (tekstowym). Klasa ta jest po-
tomkiem klasy QObject, która jest baz wszystkich klas w bibliotece Qt. Druga klasa
wykorzystywana w programie reprezentuje przycisk. Warto zauwa yü, e nazwa pliku
nagáówkowego odpowiada nazwie danej klasy. Zasada ta obowi zuje dla ka dej klasy
biblioteki Qt nale cej do tzw. publicznej cz ci biblioteki i trzeba przyznaü, e zna-
komicie uáatwia prac .
Jak wy ej wspominali my, QApplication jest bazow klas dla wszystkich programów
korzystaj cych z biblioteki Qt, które pracuj w trybie graficznym. Parametry u ytego
w programie konstruktora tej klasy:
QApplication app (argc, argv);
odpowiadaj standardowym argumentom funkcji main:
int main(int argc, char *argv[])
Tak e w ostatnim wierszu programu korzystamy z klasy QApplication:
return app.exec();
11. 212 C++. Wykorzystaj potögö aplikacji graficznych
Metoda exec przekazuje obsáug p tli zdarze , a tym samym dalsze sterowanie pro-
gramem, do biblioteki Qt. Poza takimi wyj tkami jak okna komunikatów generowane
przy u yciu klasy QMessageBox, wywoáanie exec jest niezb dne do wy wietlenia gra-
ficznych elementów programu, czyli najcz ciej caáego interfejsu aplikacji.
Klasa QPushButton reprezentuje standardowy przycisk. Przycisk mo e, oprócz tekstu,
zawieraü tak e ikon . W programie tworzony jest przycisk zawieraj cy tekst wskazany
jako parametr konstruktora klasy:
QPushButton button ("Hello world!");
Po utworzeniu przycisku zmieniamy jego wymiary tak, aby napis w nim zawarty byá
w caáo ci widoczny w wy wietlanym oknie:
button.resize (100, 30);
Metoda resize, która to wykonuje, pochodzi z klasy QWidget b d cej baz wszystkich
wizualnych elementów GUI w bibliotece Qt. Z tej samej klasy pochodzi metoda show,
która wy wietla bie c kontrolk i wszystkie elementy pochodne:
button.show();
Z obiektów klas dziedzicz cych po rednio lub bezpo rednio po klasie QWidget b dziemy
wielokrotnie korzystaü. Ich cech charakterystyczn , któr przedstawimy jeszcze w tym
rozdziale, jest zdolno ü zarówno do samodzielnej pracy jako okno aplikacji (jak ma to
miejsce w pierwszym przykáadzie), jak te jako jeden z elementów podrz dnych
okna. W tym drugim przypadku za wy wietlenie caáego okna odpowiedzialny jest
obiekt b d cy najwy ej w hierarchii elementów okna. Warto tak e wiedzieü, e ka dy
obiekt klasy pochodnej po QWidget dziedziczy mo liwo ü peánej obsáugi zdarze gene-
rowanych przez u ytkownika, w tym — oczywi cie — obsáug myszy i klawiatury.
Wy wietlamy polskie znaki
Niezb dn cech programów jest poprawna obsáuga znaków charakterystycznych dla
j zyka polskiego. Niestety, prosta zamiana napisu na przycisku z pierwszego przykáadu
z angielskiego Hello world na polski odpowiednik Witaj wiecie da efekt przedsta-
wiony na rysunku 12.4, na którym widoczny jest brak polskich liter.
Rysunek 12.4.
Przykáad nieprawidáowego
kodowania polskich znaków
Brak polskich znaków spowodowany jest sposobem obsáugi napisów przez bibliotek
Qt, a szczególnie metod konwersji znaków. Napisy w bibliotece Qt obsáuguje specjali-
zowana klasa QString (przedstawimy j bli ej w nast pnym rozdziale), która przecho-
wuje dane, korzystaj c ze standardu Unicode 4.0. Jednak przy konwersji napisów klasa
ta domy lnie u ywa standardu Latin 1, znanego tak e jako norma ISO 8859-1, który
nie zawiera polskich znaków.
12. Rozdziaä 12. i Struktura aplikacji Qt 213
Zmiana domy lnego standardu kodowania wymaga u ycia statycznej metody setCodec
´ForCStrings klasy QTextCodec:, której parametrem jest nazwa wybranego standardu
kodowania znaków. W przypadku j zyka polskiego najwa niejsze s dwa standardy
kodowania znaków: Windows-1250 stosowany w systemach z rodziny Microsoft Win-
dows oraz ISO 8859-2 u ywany w systemach Linux/Unix. Wybór jednego z tych dwóch
standardów kodowania wygl da nast puj co:
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("Windows-1250"));
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("ISO-8859-2"));
Biblioteka Qt obsáuguje wiele standardów kodowania znaków, oprócz tak wa nych
standardów jak ISO z rodziny 8859 (poza alfabetem tajskim) oraz standardów systemów
z rodziny Windows, Qt obsáuguje tak e standard Unicode w wersjach kodowania
UTF-8 i UTF-16. Dzi ki tak obszernej liczbie obsáugiwanych standardów kodowania
znaków biblioteka Qt umo liwia tworzenie programów wykorzystuj cych wszystkie
najwa niejsze j zyki u ywane przez ludzko ü. Peány wykaz obsáugiwanych standardów
kodowania znaków z ewentualnymi ograniczeniami dotycz cymi niektórych platform
znajduje si w dokumentacji biblioteki.
Powy sz wiedz wykorzystamy w kolejnym przykáadzie.
Przykäad 12.2. Wy wietlenie polskich znaków w bibliotece Qt
1. Utwórz nowy projekt, korzystaj c z szablonu aplikacji Qt, tak jak w poprzednim
przykáadzie.
2. List plików nagáówkowych uzupeániamy tak, aby mo na byáo u yü klasy
QTextCodec:
#include <QTextCodec>
3. Wybór standardu kodowania polskich znaków najlepiej umie ciü bezpo rednio
po utworzeniu obiektu app:
QApplication app (argc, argv);
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("Windows-1250"));
4. W nast pnym wierszu programu mo emy ju wpisaü nowy tekst przycisku:
QPushButton button ("Witaj wiecie!");
5. Po kompilacji i uruchomieniu programu pojawi si okno, takie jak
na rysunku 12.5.
Rysunek 12.5.
Program poprawnie
wy wietlaj cy polskie
znaki
13. 214 C++. Wykorzystaj potögö aplikacji graficznych
Podstawy hierarchii elementów
interfejsu u ytkownika
W typowym programie korzystaj cym z graficznego interfejsu u ytkownika okna apli-
kacji zawieraj wiele ró nego rodzaju elementów. Biblioteka Qt jest tak skonstruowana,
e elementy GUI stanowi ce cz ü okna uáo one s w odpowiedniej hierarchii. W pierw-
szej kolejno ci tworzony jest obiekt gáówny, potem budujemy obiekty klas b d cych
cz ci skáadow danego okna. W dwóch pierwszych programach rol gáównego i za-
razem jedynego elementu GUI stanowiá przycisk — obiekt klasy QPushButton. Ide
hierarchii obiektów w bibliotece Qt najlepiej zilustruje nast pny przykáad.
Przykäad 12.3. Hierarchia elementów GUI
1. Tradycyjnie utwórz nowy projekt, korzystaj c z szablonu aplikacji Qt
(mo esz tak e wykorzystaü projekt utworzony w drugim przykáadzie).
2. Dodaj plik nagáówkowy klasy QMainWindow, która b dzie klas bazow
dla wi kszo ci naszych programów przykáadowych:
#include <QMainWindow>
3. Po wierszach tworz cych obiekt klasy QApplication i definiuj cych obsáug
wybranego standardu polskich znaków:
QApplication app (argc, argv);
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("Windows-1250"));
umie ü obiekt klasy QMainWindow reprezentuj cy okno aplikacji:
QMainWindow window;
Klasa QMainWindow potrafi obsáugiwaü wszystkie typowe elementy gáównego
okna aplikacji, w tym menu, paski narz dziowe oraz pasek statusu, ale mo na
j tak e zastosowaü do utworzenia innych rodzajów okien. W programie
u yli my warto ci domy lnych konstruktora, który ma nast puj c postaü:
QMainWindow::QMainWindow (QWidget * parent = 0, Qt::WindowFlags flags = 0)
Pierwszy parametr — parent — okre la wska nik do obiektu nadrz dnego
(rodzica) w hierarchii elementów GUI. Domy lna warto ü oznacza, e dany
obiekt jest gáównym obiektem w hierarchii. Drugi parametr, czyli flags,
opiszemy dokáadniej w nast pnym rozdziale.
4. Dalej okre l rozmiar i poáo enie okna oraz podaj jego tytuá:
window.setGeometry (400,300,300,200);
window.setWindowTitle ("Przyk ad 3");
Obie powy sze metody pochodz z klasy QWidget. Krótkiego wyja nienia
wymaga tylko setGeometry, której dwa pierwsze parametry okre laj
poáo enie lewego górnego naro nika kontrolki wzgl dem elementu nadrz dnego.
Gdy tworzymy gáówne okno, b d to wspóárz dne poáo enia okna na pulpicie.
Dwa ostatnie parametry okre laj rozmiary okna lub innego elementu GUI.
14. Rozdziaä 12. i Struktura aplikacji Qt 215
Zwróü jeszcze uwag , e w poprzednich programach tytuá okna okre laáa
automatycznie biblioteka Qt na podstawie nazwy pliku wykonywalnego
programu.
5. Nast pnie utwórz przycisk i umie ü go we wcze niej utworzonym oknie:
QPushButton button ("Wyj cie",&window);
button.setGeometry (100,120,100,40);
Je eli spojrzymy na definicj u ytego w tym przypadku konstruktora klasy
QPushButton:
QPushButton::QPushButton (const QString & text, QWidget * parent = 0)
to zobaczymy, e drugi parametr jest odpowiednikiem pierwszego parametru
konstruktora klasy QMainWindow. W dwóch pierwszych programach przyciski
byáy elementami gáównymi, st d drugi parametr konstruktora QPushButton
miaá warto ü domy ln , jednak w tym przypadku tworzymy element podrz dny
i w tym miejscu podajemy wska nik do gáównego okna. Oczywi cie, tak e
poáo enie przycisku okre lone jest we wspóárz dnych okna nadrz dnego,
a nie pulpitu.
6. Aby napis przycisku odpowiadaá wykonywanej przez niego funkcji, musisz
jeszcze odpowiednio poá czyü sygnaá (zdarzenie) generowany po naci ni ciu
przycisku z odpowiednim gniazdem (ang. slot), czyli metod , która b dzie
wywoáana w wyniku naci ni cia przycisku. Sáu y do tego metoda connect
klasy QObject. W naszym przykáadzie naci ni cie przycisku zako czy prac
programu poprzez wywoáanie metody quit klasy QApplication:
QObject::connect (&button,SIGNAL (clicked()),&app,SLOT (quit()));
Parametry tej funkcji tworz dwie pary. Pierwsza para okre la ródáo i rodzaj
sygnaáu (w naszym przykáadzie obiekt button i jego metod clicked), druga
— jego odbiorc i wywoáywane gniazdo (w przykáadzie obiekt app i jego
metod quit). Bli ej mechanizm sygnaáów i gniazd opiszemy w rozdziale 15.
7. Ostatni czynno ci zwi zan z oknem jest jego wy wietlenie, co realizuje
poznana ju wcze niej metoda show:
window.show ();
Zauwa , e wykonujemy metod show dla gáównego obiektu w hierarchii
elementów okna, czyli w tym przypadku dla obiektu klasy QMainWindow.
Zadanie wy wietlenia elementów podrz dnych wykona gáówny element
w hierarchii.
8. Po uzupeánieniu o znane ju z poprzednich programów zako czenie:
return app.exec();
caáo ü tekstu ródáowego programu wygl da nast puj co:
#include <QApplication>
#include <QPushButton>
#include <QTextCodec>
#include <QMainWindow>
15. 216 C++. Wykorzystaj potögö aplikacji graficznych
int main(int argc, char *argv[])
{
QApplication app (argc, argv);
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("Windows-1250"));
QMainWindow window;
window.setGeometry (400,300,300,200);
window.setWindowTitle ("Przyk ad 3");
QPushButton button ("Wyj cie",&window);
button.setGeometry (100,120,100,40);
QObject::connect (&button,SIGNAL (clicked()),&app,SLOT (quit()));
window.show ();
return app.exec();
}
Po kompilacji i uruchomieniu otrzymamy okno przedstawione na rysunku 12.6.
Rysunek 12.6.
Przycisk umieszczony
w oknie aplikacji
Tworzenie wäasnej klasy okna
Ostatnim krokiem do poznania struktury aplikacji Qt jest utworzenie wáasnej klasy okna.
Podobnie jak w poprzednim przykáadzie, jako klas bazow wykorzystamy QMainWindow,
ale nic nie stoi na przeszkodzie, aby elementy GUI tworzyü na bazie klasy QWidget.
Wybór QMainWindow podyktowany jest gáównie jej przygotowaniem do obsáugi standar-
dowych elementów gáównych okien programów. Je eli taka funkcjonalno ü nie jest
potrzebna, klas , któr poni ej opisujemy, mo na tak e zbudowaü na bazie QWidget.
Popatrzmy zatem na kolejny przykáad.
Przykäad 12.4. Wäasna klasa okna
1. Ponownie skorzystaj z szablonu aplikacji Qt i zapisz projekt w nowym folderze.
2. Pliki nagáówkowe pozostaj takie, jak w poprzednim przykáadzie:
#include <QApplication>
#include <QPushButton>
#include <QTextCodec>
#include <QMainWindow>
3. Klas reprezentuj c okno nazwij MyWindow. Zawiera ona jedynie konstruktor,
destruktor oraz jedno prywatne pole button — wska nik na obiekt klasy
QPushButton:
16. Rozdziaä 12. i Struktura aplikacji Qt 217
class MyWindow: public QMainWindow
{
public:
MyWindow ();
~MyWindow ();
private:
QPushButton *button;
};
4. Konstruktor klasy MyWindow realizuje takie same zadanie jak program
z poprzedniego przykáadu. Tworzone okno ma rozmiary 300 na 200 pikseli
i zawiera jeden przycisk, którego naci ni cia zamyka okno i ko czy dziaáanie
caáego programu:
MyWindow::MyWindow (): QMainWindow ()
{
setGeometry (400,300,300,200);
setWindowTitle ("Przyk ad 4");
button = new QPushButton ("Wyj cie",this);
button -> setGeometry (100,120,100,40);
connect (button,SIGNAL (clicked()),qApp,SLOT (quit()));
}
Warto zwróciü uwag na to, e obiekt reprezentuj cy przycisk tworzymy
dynamicznie, a wska nikiem do obiektu klasy bazowej wzgl dem przycisku
jest this. Drug zmian jest wykorzystanie w wywoáaniu funkcji connect jako
trzeciego parametru makra qApp, które przekazuje wska nik do obiektu klasy
QApplication. Specjalne mechanizmy zawarte w bibliotece Qt uniemo liwiaj
utworzenie wi cej ni jednego obiektu tej klasy.
5. Destruktor klasy MyWindow pozostaw pusty. Usuni cie elementów GUI tworzonych
dynamicznie zostanie zrealizowane automatycznie przez obiekt b d cy najwy ej
w hierarchii.
MyWindow::~MyWindow ()
{
}
6. Prezentowana poni ej funkcja main osi gn áa postaü, któr b dziemy stosowaü
w wi kszo ci programów przykáadowych:
int main (int argc, char *argv[])
{
QApplication app (argc, argv);
QTextCodec::setCodecForCStrings (QTextCodec::codecForName ("Windows-1250"));
MyWindow window;
window.show ();
return app.exec();
}
Po wpisaniu caáo ci, kompilacji i uruchomieniu programu uzyskamy efekt
niemal identyczny z efektem w poprzednim przykáadzie. Jedyna ró nica to
inny tytuá okna. Okno programu przedstawiamy na rysunku 12.7.
17. 218 C++. Wykorzystaj potögö aplikacji graficznych
Rysunek 12.7.
Przycisk
umieszczony w oknie
reprezentowanym
przez now klas
Qt Designer
Filozofia pracy i ogólny wygl d Qt Designera s zbli one do innych wizualnych edyto-
rów graficznego interfejsu u ytkownika. Osoby znaj ce takie rodowiska jak Borland
Delphi czy Microsoft Visual Basic znajd tu wiele podobie stw.
Przy uruchomieniu Qt Designer standardowo wy wietla okno kreatora rodzaju tworzo-
nego formularza — tak jak to przedstawiamy na rysunku 12.8. Mo emy wybraü okna
dialogowe z przyciskami lub bez przycisków, okno gáówne oparte na klasie QMainWindow
oraz dowoln kontrolk GUI na bazie klasy QWidget. Je eli wyá czymy opcj wy wie-
tlania kreatora nowego formularza, mo na go uruchomiü z opcji menu FileNewForm.
Rysunek 12.8. Qt Designer z otwartym oknem wyboru rodzaju tworzonego formularza
18. Rozdziaä 12. i Struktura aplikacji Qt 219
Po wyborze odpowiedniego rodzaju tworzonego formularza (w naszym przykáadzie
jest to Main Window) otrzymujemy gotowy do pracy graficzny edytor interfejsu u yt-
kownika, którego przykáadowy wygl d przedstawiony jest na rysunku 12.9. Warto po-
wi ciü chwil czasu na wygodne ustawienie elementów edytora. Na pocz tku mo na
zamkn ü cz ü okien — proponuj pozostawiü Widget Box, Property Editor oraz Object
Inspector.
Rysunek 12.9. Qt Designer w trakcie edycji formularza typu Main Window
Przedstawione na rysunku 12.10 okno Widget Box zawiera palet elementów GUI (okno
widoczne jest tak e w lewej cz ci rysunku 12.9). Wybran kontrolk przenosimy na
okno formularza, korzystaj c z mechanizmu przeci gnij i upu ü. Widoczna na oknie
siatka punktów uáatwia rozmieszczanie poszczególnych elementów okna.
Wáa ciwo ci wybranego elementu wy wietlane s w oknie Property Editor, które
przedstawiamy na rysunku 12.11. Okno to zawiera informacje o klasie reprezentuj -
cej dany element oraz jej klasach bazowych. Na rysunku 12.12 widzimy, e wybra-
nym elementem jest gáówne okno aplikacji (klasa QMainWindow, która dziedziczy po
klasach QWidget i QObject). Wszystkie wáa ciwo ci wy wietlane w oknie Property
Editor maj — oczywi cie — swoje odpowiedniki w polach klasy.
19. 220 C++. Wykorzystaj potögö aplikacji graficznych
Rysunek 12.10.
Okno Widget Box
Ostatnim z podstawowych okien Qt Designera jest okno Object Inspector, które przed-
stawiamy na rysunku 12.12. Zawiera ono hierarchi klas bie cego projektu. W oknie
prezentowanym na rysunku 12.12 zamie cili my pocz tkow hierarchi klas szablonu
Main Window. Widzimy tu elementy klasy QMainWindow, takie jak centralna kontrolka
okna (centralwidget), pasek menu (menubar) oraz pasek statusu (statusbar), które
bli ej omówimy w nast pnym rozdziale.
20. Rozdziaä 12. i Struktura aplikacji Qt 221
Rysunek 12.11.
Okno Property Editor
Rysunek 12.12.
Okno Object
Inspector
Integracja Qt Designer i Dev-C++
Qt Designer zapisuje opis formularzy w plikach z rozszerzeniem ui, które wykorzy-
stuj skáadni XML. Biblioteka Qt zawiera specjalne narz dzie — kompilator inter-
fejsu u ytkownika UIC (ang. user interface compiler) — które konwertuje pliki ui do
21. 222 C++. Wykorzystaj potögö aplikacji graficznych
plików nagáówkowych w j zyku C++. Do integracji w rodowisku Dev-C++ kompi-
latora UIC i innych specjalistycznych narz dzi biblioteki Qt wykorzystamy narz dzie
qt-moc-ui-rcc. Plik wykonywalny qt-moc-ui-rcc.exe kopiujemy do folderu C:Dev-Cpp
´bin, a plik qt.mak, zawieraj cy dodatkowe polecenia dla narz dzia make, umiesz-
czamy w folderze z projektem. Ostatnim etapem konfiguracji jest dodanie pliku qt.mak
w opcjach projektu Dev-C++ (menu ProjektOpcje projektu) w zakáadce Makefile, tak
jak to przedstawiamy na rysunku 12.13. W przypadku plików formularzy automa-
tycznie wygenerowany przez UIC plik nagáówkowy b dzie miaá nazw tak sam jak
plik ui (bez rozszerzenia) uzupeánion dodatkowo o przedrostek ui_.
Rysunek 12.13.
Dodanie pliku qt.mak
do projektu
Wykorzystanie formularzy
w programach
Wygenerowane za pomoc Qt Designera pliki formularzy mo na w stosunkowo áatwy
sposób wykorzystaü w aplikacji. Dwa sposoby najcz ciej stosowne w praktyce prze-
üwiczymy na przykáadach. Pierwszym z nich b dzie u ycie wielodziedziczenia.
Przykäad 12.5. Formularz doäñczony za pomocñ wielodziedziczenia
1. Korzystaj c z szablonu aplikacji Qt, utwórz nowy projekt. Funkcja main b dzie
miaáa tak sam zawarto ü jak w poprzednim przykáadzie. Mo esz tak e
wykorzystaü pliki z tego przykáadu. Klas MyWindow ogranicz do minimum:
class MyWindow: public QMainWindow
{
public:
MyWindow ();
~MyWindow () {}
};
22. Rozdziaä 12. i Struktura aplikacji Qt 223
Podobnie ograniczona do minimum jest implementacja konstruktora:
MyWindow::MyWindow ():
QMainWindow (0,Qt::Window)
{
}
2. W Qt Designerze utwórz nowy projekt formularza oparty na szablonie Main
Window. Korzystaj c z edytora wáa ciwo ci (okno Property Editor), zmodyfikuj
nazw klasy (wáa ciwo ü objectName) na Window, rozmiary okna (wáa ciwo ü
geometry) do 300 na 200 pikseli oraz dobierz odpowiedni tytuá okna (wáa ciwo ü
windowTitle). Wst pnie przygotowany projekt zapisz pod nazw window.ui
w folderze z projektem. Okno Property Editor z wáa ciwo ciami naszej klasy
Window przedstawiamy na rysunku 12.14. Warto jednocze nie zauwa yü, e te
wáa ciwo ci klasy, których warto ü po modyfikacji odbiega od stanu pocz tkowego,
wyró niane s w oknie Property Editor pogrubion czcionk .
Rysunek 12.14.
Oko Property Editor
z wyró nionymi
zmianami wáa ciwo ci
objectName, geometry
i windowTitle
23. 224 C++. Wykorzystaj potögö aplikacji graficznych
3. Na formularzu okna umieszczamy przycisk — obiekt klasy PushButton. Jego
nazw zmieniamy na button, rozmiary i poáo enie to kolejno: 100, 120, 100
i 40, a wy wietlany tekst (wáa ciwo ü text) to Wyj cie. Struktura klasy
formularza powinna wygl daü tak, jak na rysunku 12.15.
Rysunek 12.15.
Struktura klas
formularza
zawieraj cego
okno z jednym
przyciskiem
4. Do uko czenia prac nad pierwszym formularzem pozostaáo jeszcze wyá czenie
niepotrzebnego paska statusu oraz paska menu. Wybierz odpowiednie klasy
w oknie Object Inspector i wáa ciwo ü enabled ustaw na false. Dodatkowo
dla paska statusu musisz wyá czyü jeszcze brzeg dla áapki kursora myszy
(wáa ciwo ü sizeGripEnabled). W efekcie otrzymali my projekt formularza
dokáadnie odpowiadaj cy oknu z poprzedniego przykáadu.
Plik window.ui wygl da nast puj co:
<ui version="4.0" >
<class>Window</class>
<widget class="QMainWindow" name="Window" >
<property name="geometry" >
<rect>
<x>0</x>
<y>0</y>
<width>300</width>
<height>200</height>
</rect>
</property>
<property name="windowTitle" >
<string>QtDesigner - test</string>
</property>
<widget class="QWidget" name="centralwidget" >
<property name="enabled" >
<bool>true</bool>
</property>
<widget class="QPushButton" name="button" >
<property name="geometry" >
<rect>
<x>100</x>
<y>120</y>
<width>100</width>
<height>40</height>
</rect>
</property>
<property name="text" >
<string>Wyj ›cie</string>
</property>
</widget>
24. Rozdziaä 12. i Struktura aplikacji Qt 225
</widget>
<widget class="QMenuBar" name="menubar" >
<property name="enabled" >
<bool>false</bool>
</property>
<property name="geometry" >
<rect>
<x>0</x>
<y>0</y>
<width>300</width>
<height>23</height>
</rect>
</property>
</widget>
<widget class="QStatusBar" name="statusbar" >
<property name="enabled" >
<bool>false</bool>
</property>
<property name="sizeGripEnabled" >
<bool>false</bool>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>
5. Do projektu doá cz plik window.ui, a w opcjach projektu umie ü plik qt.mak
i nast pnie skompiluj caáo ü. Przy pierwszej kompilacji w folderze z projektem
zostanie utworzony dodatkowy plik ui_window.h, który zostaá wygenerowany
przez kompilator UIC. Plik ten doá cz do projektu.
Plik ui_window.h zawiera jednocze nie deklaracj i implementacj klasy
Ui_Window:
class Ui_Window
{
public:
QWidget *centralwidget;
QPushButton *button;
QMenuBar *menubar;
QStatusBar *statusbar;
void setupUi(QMainWindow *Window)
{
if (Window->objectName().isEmpty())
Window->setObjectName(QString::fromUtf8("Window"));
Window->resize(300, 200);
centralwidget = new QWidget(Window);
centralwidget->setObjectName(QString::fromUtf8("centralwidget"));
centralwidget->setEnabled(true);
button = new QPushButton(centralwidget);
button->setObjectName(QString::fromUtf8("button"));
button->setGeometry(QRect(100, 120, 100, 40));
Window->setCentralWidget(centralwidget);
menubar = new QMenuBar(Window);
25. 226 C++. Wykorzystaj potögö aplikacji graficznych
menubar->setObjectName(QString::fromUtf8("menubar"));
menubar->setEnabled(false);
menubar->setGeometry(QRect(0, 0, 300, 23));
Window->setMenuBar(menubar);
statusbar = new QStatusBar(Window);
statusbar->setObjectName(QString::fromUtf8("statusbar"));
statusbar->setEnabled(false);
statusbar->setSizeGripEnabled(false);
Window->setStatusBar(statusbar);
retranslateUi(Window);
QMetaObject::connectSlotsByName(Window);
} // setupUi
void retranslateUi(QMainWindow *Window)
{
Window->setWindowTitle(QApplication::translate("Window", "QtDesigner - test",
´0, QApplication::UnicodeUTF8));
button->setText(QApplication::translate("Window", "Wyj305233cie", 0,
´QApplication::UnicodeUTF8));
Q_UNUSED(Window);
} // retranslateUi
};
Dodatkowo plik ten zawiera przestrze nazw Ui z klas Ui_Window:
namespace Ui {
class Window: public Ui_Window {};
} // namespace Ui
6. W definicji klasy dodaj dziedziczenie prywatne klasy wygenerowanej
Ui::Window:
class MyWindow: public QMainWindow, private Ui::Window
Oczywi cie, na pocz tku pliku mywindow.h trzeba jeszcze doá czyü
odpowiedni plik nagáówkowy:
#include "ui_window.h"
7. W konstruktorze naszej klasy wywoáaj metod setupUi znajduj c si
w klasie Ui::Window:
setupUi (this);
Parametrem tej metody jest wska nik do obiektu klasy QMainWindow, czyli
w naszym przypadku this.
à czymy tak e sygnaá wysyáany przez przycisk button w dokáadnie taki sam
sposób jak w poprzednim przykáadzie.
connect (button,SIGNAL (clicked()),qApp,SLOT (quit()))
8. Po kompilacji projektu i uruchomieniu programu uzyskamy okno, takie jak
na rysunku 12.16.
26. Rozdziaä 12. i Struktura aplikacji Qt 227
Rysunek 12.16.
Okno QMainWindow
wygenerowane przy
u yciu Qt Designera
Drugim obok wielodziedziczenia typowym sposobem wykorzystania w programie for-
mularzy wygenerowanych przez Qt Designer jest doá czenie pola b d cego obiektem
klasy wygenerowanej przez kompilator UIC. Ró nice w stosunku do wielodziedzi-
czenia poka emy na przykáadzie.
Przykäad 12.6. Formularz doäñczony jako pole klasy
1. Skopiuj wszystkie pliki z poprzedniego przykáadu i otwórz plik projektu
w Dev-C++.
2. W definicji klasy MyWindow dodaj pole window b d ce obiektem klasy
Ui::Window. Jednocze nie usu dziedziczenie po klasie Ui::Window:
class MyWindow: public QMainWindow
{
public:
MyWindow ();
~MyWindow () {}
private:
Ui::Window window;
};
3. Konstruktor klasy MyWindow, podobnie jak w poprzednim przykáadzie, musi
wywoáaü metod setupUi klasy Ui::Window. Jedyna ró nica polega na innym
sposobie dost pu do tej metody. Metod , zamiast bezpo rednio, wywoáujemy
za po rednictwem pola window:
window.setupUi (this);
Analogicznie modyfikujemy pierwszy parametr funkcji connect:
connect (window.button,SIGNAL (clicked()),qApp,SLOT (quit()))
4. Po kompilacji i uruchomieniu programu otrzymujemy efekt analogiczny
do efektu z przykáadu 12.5.
Z dwóch przedstawionych metod wykorzystania formularzy generowanych przez Qt
Designer najbardziej uniwersalna jest metoda druga. W przeciwie stwie do wielodzie-
dziczenia, pozwala ona na bezproblemowe doá czenie do jednej klasy aplikacji wielu
formularzy. Jednak w typowych sytuacjach zastosowanie wielodziedziczenia jest naj-
wygodniejsz metod , gáównie dzi ki bezpo redniemu dost powi do wszystkich elemen-
tów formularza.
27. 228 C++. Wykorzystaj potögö aplikacji graficznych
Test
W ród pyta testowych dotycz cych powy szego rozdziaáu poprawna jest co najmniej
jedna odpowied .
1. Bazow klas okna aplikacji mo e byü:
a) QPushButton,
b) QMainWindow,
c) QWidget,
d) QApplication.
2. Ile obiektów klasy QApplication mo e wyst piü w programie:
a) dowolna ilo ü,
b) tylko jeden,
c) ilo ü obiektów zale y od ilo ci kontrolek.
3. Jakie domy lne kodowanie znaków obsáuguje klasa QString:
a) Latin 1,
b) Windows 1250,
c) ICO 8859-2.
4. à czenie sygnaáów i gniazd umo liwia metoda connect klasy:
a) QWidget,
b) QMainWindow,
c) QApplication,
d) QObject,
e) QString.
5. Domy lna nazwa obiektu klasy QMainWindow formularza tworzonego przez
Qt Designer to:
a) MyWindow,
b) MainWindow,
c) Window,
d) Widget.