Darmowy fragment publikacji:
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++
(cid:149) Jak korzysta(cid:230) z bibliotek wxWidgets oraz Qt?
(cid:149) W jaki spos(cid:243)b implementowa(cid:230) obs‡ugŒ zdarzeæ w aplikacjach?
(cid:149) Jak budowa(cid:230) aplikacje sieciowe i bazodanowe?
Okres dominacji jednego systemu operacyjnego i przeznaczonych dla niego rozwi„zaæ
powoli odchodzi do historii. Fenomen popularno(cid:156)ci r(cid:243)¿nych dystrybucji Linuksa
i coraz mocniejsza pozycja komputer(cid:243)w Mac sprawiaj„, ¿e wiele firm produkuj„cych
oprogramowanie decyduje siŒ na tworzenie rozwi„zaæ wieloplatformowych.
W przypadku ogromnych korporacji stworzenie zespo‡(cid:243)w programistycznych
pracuj„cych r(cid:243)wnolegle nad kilkoma wersjami jednej aplikacji dla r(cid:243)¿nych system(cid:243)w
operacyjnych nie stanowi problemu, ale w mniejszych firmach jest to niemo¿liwe.
Tu z pomoc„ przychodz„ biblioteki pozwalaj„ce na tworzenie kodu (cid:159)r(cid:243)d‡owego
prawid‡owo kompiluj„cego siŒ na ka¿dej platformie, na kt(cid:243)rej je zainstalowano.
Ksi„¿ka (cid:132)C++. Wykorzystaj potŒgŒ aplikacji graficznych(cid:148) opisuje tworzenie
oprogramowania z wykorzystaniem dw(cid:243)ch takich w‡a(cid:156)nie bibliotek (cid:150) wxWidgets
oraz Qt. Czytaj„c j„, dowiesz siŒ, jak wykorzysta(cid:230) jŒzyk C++ i (cid:156)rodowisko Dev-C++
do pisania program(cid:243)w, z kt(cid:243)rych korzysta(cid:230) bŒd„ mogli u¿ytkownicy systemu Windows,
Linuksa i Mac OS. Nauczysz siŒ stosowa(cid:230) kontrolki i komponenty, budowa(cid:230) menu
i interfejsy u¿ytkownika, obs‡ugiwa(cid:230) zdarzenia i implementowa(cid:230) operacje graficzne.
Przeczytasz tak¿e o aplikacjach bazodanowych i sieciowych. Ka¿de z zagadnieæ
om(cid:243)wiono zar(cid:243)wno w kontek(cid:156)cie biblioteki wxWidgets, jak i biblioteki Qt, dziŒki czemu
poznasz dwie metody rozwi„zywania tych samych zadaæ programistycznych (cid:150) by
wybra(cid:230) sobie tŒ, kt(cid:243)ra bardziej Ci odpowiada.
(cid:149) Instalacja (cid:156)rodowiska programistycznego i bibliotek
(cid:149) Struktura aplikacji i podstawowe komponenty
(cid:149) Stosowanie komponent(cid:243)w
(cid:149) Obs‡uga zdarzeæ myszy i klawiatury
(cid:149) Budowanie menu aplikacji
(cid:149) Komunikacja sieciowa
(cid:149) Operacje graficzne
(cid:149) Po‡„czenia z bazami danych
(cid:149) Drukowanie z poziomu aplikacji
DziŒki tej ksi„¿ce stworzysz aplikacje,
kt(cid:243)re doceni„ u¿ytkownicy wszystkich system(cid:243)w operacyjnych.
Wydawnictwo Helion
ul. Ko(cid:156)ciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
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
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
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
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
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
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
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Ċ Plik\Nowy 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.
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);
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 Projekt\Kompiluj
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();
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.
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
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.
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
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:
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.
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 File\NewForm.
Rysunek 12.8. Qt Designer z otwartym oknem wyboru rodzaju tworzonego formularza
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.
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.
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
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 Projekt\Opcje 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 () {}
};
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
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
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);
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 , Wyj\305\233cie , 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.
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.
228
Test
C++. Wykorzystaj potögö aplikacji graficznych
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.
Pobierz darmowy fragment (pdf)