Entwicklung von Applikationen in Qt 4.0

Von Jacek Surazki

Dann legen wir ein QLabel an, das einen Text enthalten wird, und ein QPushButton, der das Programm schließen wird. Diese beiden Widgets werden als Kinder unseres Fensters erstellt. Die Positionen bezüglich der linken oberen Ecke des Elternobjektes setzen wir mit Hilfe von QWidget::setGeometry(). Argumente dieser Methode sind Koordinaten der linken oberen Ecke des Kindes, die Breite und die Höhe.

Nach dem Erstellen der Schaltfläche schließen wir deren Signal clicked() an den Slot close() unseres Fensters an. Ein Aufruf von close() bewirkt, dass das Fenster geschlossen wird.

Das Widget ist nicht sichtbar, solange die Methode show() nicht aufgerufen wird. Diese Funktion müssen wir nur für das Hauptfenster der Applikation aufrufen. Das Fenster ruft die Funktion für alle ihren Kinder auf.

Zum Schluss rufen wir QApplication::exec() auf. Dies ist die Hauptschleife der Applikation, unser Programm bleibt in dieser Funktion bis zum Ende. Das Programm springt aus der Funktion heraus, wenn das letzte Fenster der Applikation geschlossen wird. Das Beenden des Programms kann man auch mit Hilfe von QApplication::quit() realisieren.

Unsere Applikation Hello World ist noch nicht ideal - wenn der Benutzer die Fenstergröße ändert, bleiben das Label und die Schaltfläche in der vorherigen Größe. Deshalb plazieren wir Widgets am besten nicht per Hand, sondern übergeben diese Aufgabe den Layouts.

QLayout

Layouts sind Objekte vom Typ QLayout, die für die Platzierung von Widgets innerhalb des durch das Elternobjekt belegten Bereiches zuständig sind. Die einfachsten davon sind QHBoxLayout, das Kinder horizontal nebeneinander plaziert, und QVBoxLayout, das Kinder aufeinander vertikal plaziert. Layouts kann man einbetten, indem man beliebig komplizierte Formulare erstellt.

Listing 6. layout.cpp: Implementierung des Programms Hello World!

#include <QtGui/QApplication>
#include <QtGui/QPushButton>
#include <QtGui/QLabel>
#include <QtGui/QFont>
#include <QtGui/QVBoxLayout>
int main(int argc, char *argv[])
{
 QApplication app(argc, argv);
 QWidget window;
 QVBoxLayout layout(&window);
 QLabel label("Hello World!", &window);
 label.setAlignment(Qt::AlignCenter);
 label.setFont(QFont("Arial", 20, QFont::Bold));
 layout.addWidget(&label);
 QPushButton button("Close", &window);
 QObject::connect(&button, SIGNAL(clicked()), &window, SLOT(close()));
 layout.addWidget(&button);
 window.show();
 return app.exec();
}

Listing 6 zeigt das Programm Hello World!, das mit Hilfe von Layouts geschrieben wurde. Wir legen ein QVBoxLayout an und übergeben ihm einen Zeiger auf das Fenster im Konstruktor. Dies hat doppelte Folgen. Erstens ist das Layout, das ein QObject ist, ein Kind des Fensters. Das Entfernen des Fensters hat das Entfernen des Layouts zur Folge. Natürlich haben wir in diesem Fall alle Objekte auf dem Stack angelegt, deshalb erfolgt die Deallokation automatisch. Aber am meisten verwendet man in Applikationen dynamisch allokierte Objekte, in solchen Fällen ist es gut zu beachten, wer wessen Kind ist. Die zweite Folge ist, dass das Layout sich mit Kindern des ihm im Konstruktor übergebenen Widgets beschäftigt.

Ein Layout beschäftigt sich nicht mit der Platzierung aller Kinder seines Elternobjektes, sondern nur von solchen, die zum Layout mit Hilfe von QLayout::addWidget() hinzugefügt wurden. Widgets kann man auch vom Layout mit Hilfe von QLayout::removeWidget() entfernen. Zum Hinzufügen und Entfernen von eingebetteten Layouts verwenden wir die Methoden QLayout::addLayout() und QLayout::removeLayout().

Nach der erneuten Kompilation und Ausführung stellt sich heraus, dass das Label und die Schaltfläche sich an die sich ändernde Größe des Fensters anpassen.

Ereignisbehandlung

Die Klasse QWidget besitzt ein Mechanismus zur Bedienung von asynchronen Ereignissen. Jedes Widget hat die virtuelle Funktion

bool QWidget::event(QEvent *event);

Informationen über ein Ereignis werden im Parameter vom Typ QEvent* übergeben. Dies ist die Basisklasse für verschiedene Ereignisse, die wichtigsten davon sind:

QPaintEvent
Beauftragung des Zeichnens eines ganzen Widgets oder eines Teils davon: QMouseEvent
Ereignisse, die durch Mausbewegungen bzw. Drücken von Maustasten verursacht werden: QKeyEvent
Ereignisse, die durch Tastaturtasten verursacht werden: QDropEvent
auf einem Widget wurde etwas mit der Maus fallen gelassen: QResizeEvent
die Widgetgröße hat sich geändert

Um festzustellen, mit welchem Ereignis wir es zu tun haben, überprüfen wir den Wert, der durch die Methode QEvent::type() zurückgegeben wurde, dann casten wir ihn auf eine entsprechende Klasse. Die Funktion QWidget::event() gibt true zurück, wenn der Parameter event erkannt wurde, sonst wird false zurückgegeben.

Wenn QObject::event() false zurückgibt, werden einige Ereignisarten dem Elternobjekt übergeben. Dies betrifft u.a. QMouseEvent und QKeyEvent. Normalerweise müssen wir aber QWidget::event() nicht überladen. Die Standardimplementation in der Klasse QWidget stellt die Ereignisart selbst fest und ruft die zugehörige virtuelle Methode auf:

paintEvent(QPaintEvent*);
keyPressEvent(QKeyEvent*);
keyReleaseEvent(QKeyEvent*);
mousePressEvent(QMouseEvent*);
mouseReleaseEvent(QMouseEvent*);
mouseMoveEvent(QMouseEvent*);
dropEvent(QDropEvent*);
resizeEvent(QResizeEvent*);

Widgets können mit Hilfe von QApplication::postEvent (QObject *receiver, QEvent *event) miteinander kommunizieren. Diese Funktion stellt dem Objekt receiver das Ereignis event im nächsten Zyklus der Ereignisschleife bereit.