9.9. The Event Loop: Revisited

9.9. The Event Loop: Revisited
	Chapter 9. Widgets and Designer

[ fromfile: eventloop-revisited.xml id: eventloop-revisited ]

QWidgets send QEvents to other QObjects in response to user actions such as mouse events and keyboard events.
A widget can also respond to events from the window manager such as repaints, resizes, or close events.
Furthermore, it is possible to post a custom event directly to any QObject or selectively respond to events that were posted to other objects.
You can delegate the handling of an event to a specially defined handler object.

Figure 9.22 is a screenshot of a QWidget named KeySequenceLabel that captures a QKeySequence and displays it for the user.

Figure 9.22. KeySequenceLabel Widget

In Example 9.13 you can see from the names of the private slots that QtCreator was used to compose the GUI.
Also, we chose the Multiple Inheritance option for embedding the Ui class,

Example 9.13. src/eventloop/keysequencelabel.h

[ . . . . ]
#include "ui_keysequencelabel.h"
#include <QList>
#include <QPair>
class QObjectBrowserAction;

class KeySequenceLabel : public QMainWindow, private Ui::KeySequenceLabel {
    Q_OBJECT
 public:
    explicit KeySequenceLabel(QWidget* parent = 0);
 protected:                         
    void changeEvent(QEvent* e);
    void keyPressEvent(QKeyEvent*);
    void leaveEvent(QEvent*);
    void enterEvent(QEvent*);
    void paintEvent(QPaintEvent*);
    void timerEvent(QTimerEvent*);  
    void updateUi();
 private slots:
    void on_actionShow_ObjectBrowser_triggered(bool checked);
    void on_m_clearButton_clicked();
    void on_actionQuit_triggered();
 private:
    QObjectBrowserAction* m_browserAction;
    QList<QPair<int, int> > m_keys;
    int m_paints;
};
[ . . . . ]

	`QWidget` event handler overrides
	`QObject` event handler override

There is a QLabel in the dialog used for display of a QKeySequence.
The QKeySequence class encapsulates a sequence of up to four keystrokes, typically used as shortcuts to invoke QActions.
The base class keyPressEvent() handler is overridden in the KeySequenceLabel widget. In Example 9.14, you can see that it catches the keystrokes and saves them to a list before the child widgets see them.
In updateUi(), those events convert to a QKeySequence, and then to a QString, which is sent to the QLabel for display via setText().

Example 9.14. src/eventloop/keysequencelabel.cpp

[ . . . . ]

void KeySequenceLabel::keyPressEvent(QKeyEvent* evt) {
    bool doNothing = false;

    if (evt->key() == 0) doNothing = true;
    if (m_keys.size() > 3) doNothing = true;
    if (doNothing) {
        QMainWindow::keyPressEvent(evt); 
        return;
    }
    QPair<int, int> pair = QPair<int, int>(evt->modifiers(), evt->key());
    m_keys << pair;
    evt->accept();
    updateUi();
}

void KeySequenceLabel::updateUi() {
    if (!m_keys.isEmpty()) {
        int keys[4] = {0,0,0,0};
        for (int i=0; i<m_keys.size(); ++i) {
            QPair<int, int> pair = m_keys[i];
            keys[i] = pair.first | pair.second;
        }
        QKeySequence seq = QKeySequence(keys[0], keys[1], keys[2], keys[3]);
        m_label->setText(seq.toString());
    }
    else m_label->clear();
}

QWidget's base class handler responds to ESC for pop-up windows.

We defined mouse event handlers, shown in Example 9.15, that tell you when the mouse pointer enters or leaves the widget.

Example 9.15. src/eventloop/keysequencelabel.cpp

[ . . . . ]

void KeySequenceLabel::enterEvent(QEvent* evt) {

    statusBar()->showMessage(tr("Mouse is in da house"));
    evt->accept();

}

void KeySequenceLabel::leaveEvent(QEvent* evt) {
    statusBar()->showMessage(tr("Mouse has left the building"));
    evt->accept();
}

In Example 9.16 the constructor makes use of the QObject built-in timer and calls QObject::startTimer(), which generates a timer event every 2 seconds.
We handle the timerEvent() by updating a QLCDNumber, once every 2 seconds, with the number of paint events that have been performed so far.
For example, whenever the value of the LCDNumber changes, this indirectly causes the widget to repaint.
You can run this app and try moving and resizing the widget to see how it effects the number of paint events.

Example 9.16. src/eventloop/keysequencelabel.cpp

[ . . . . ]

KeySequenceLabel::KeySequenceLabel(QWidget* parent) :
    QMainWindow(parent), m_browserAction(new QObjectBrowserAction(this)) {

    setupUi(this);
    startTimer(2000); 
    m_paints = 0;
}

void KeySequenceLabel::timerEvent(QTimerEvent*) {
    m_lcdNumber->display(m_paints);
}

void KeySequenceLabel::paintEvent(QPaintEvent* evt) {
    ++m_paints;
    QMainWindow::paintEvent(evt);
}

A timer event occurs every 2 seconds.

From the Tools menu you can select Show ObjectBrowser and see the widget in Figure 9.23.

Figure 9.23. QObjectBrowser Widget

QObjectBrowser is an open source debugging tool that gives a graphic display of properties, signals, and slots of a QObject tree during the execution of a program. ^[47]
One easy way to use it is by adding the QObjectBrowserAction directly to the QMainWindow's menu.

A slightly modified version of this tool is included in src/libs.

Custom Events Versus Signals and Slots

In general, you can think of signals as higher-level messages from objects, with semantics, whereas events are lower-level messages from the user or the system.
Both mechanisms implement the Publish/Subscribe Pattern.

It's possible to define custom events or custom signals and slots.
With custom events, you can publish to any QObject with QObject::postEvent() and subscribe to events intended for any QObject with installEventFilter().
Perhaps you are wondering which mechanism to use if you need to transmit a custom message.

In most situations, if you have a choice, a signal-slot connection is preferable to a custom QEvent because signals and slots are safer, higher-level, and more flexible mechanisms for message passing.
Signals and slots are more flexible because the emit statement does not need a destination object, and the signal can be destined for multiple slots.

Signals and Slots also depend on an event loop, something you notice immediately if you try to connect signals from an object in one thread to slots of objects created in another thread.
Signals can be transmitted (in a blocking or a nonblocking way) to slots within the same thread or in another thread (with its own event loop).

^[47]Contributed by Jeremy Magland, you can follow the development of this utility from its initial posting and see some community suggestions and the author's responses at http://tinyurl.com/2a6qkpy


9.8. Exercise: Input Forms		9.9.1. QTimer