Observer Pattern

When writing event-driven programs, GUI views need to respond to changes in the state of data model objects, so that they can display the most recent information possible.

When a particular subject object changes state, it needs an indirect way to alert (and perhaps send additional information to) all the other objects that are listening to state-change events, known as observers. A design pattern that enables such a message-passing mechanism is called the Observer pattern , sometimes also known as the Publish-Subscribe pattern.

There are many different implementations of this pattern. Some common characteristics that tie them together are

1. They all enable concrete subject classes to be decoupled from concrete observer classes.

2. They all support broadcast-style (one to many) communication.

3. The mechanism used to send information from subjects to observers is completely specified in the subject's base class.

Qt's approach is very different from Java's approach, because signals and slots rely on generated code, while Java just renames observer to listener.

[ . . . . ]

int main(int argc, char * argv[]) {
    QApplication myapp(argc, argv);

<-- 1

QWidget rootWidget;
    setGui(&rootWidget);

    rootWidget.show();

<-- 2

return myapp.exec();

<-- 3

};

(1) Every GUI, multithreaded, or event-driven Qt Application must have a QApplication object defined at the top of main().

(2) Show our widget on the screen.

(3) Enter the event loop.

It is important to understand that widgets in a layout are not children of the layoutthey are children of the widget that owns the layout. Only a widget can be the parent of another widget. It may be useful to think of the layout as an older sibling acting as the nanny of its widgets.

[ . . . . ]

QWidget* setGui(QWidget *box) {
    QLayout* layout = new QVBoxLayout;
    box->setLayout(layout);

<-- 1

QTextEdit *te = new QTextEdit;

<-- 2

layout->addWidget(te);

<-- 3

te->setHtml("Some <b>text</b> in the <tt>QTextEdit</tt>"
         "edit window <i>please</i>?");

    QPushButton *quitButton=new QPushButton("Quit");
    layout->addWidget(quitButton);

    QPushButton *shoutButton = new QPushButton("Shout");
    layout->addWidget(shoutButton);

    Messager *msgr = new Messager("This dialog will self-
    destruct.", box);

    QObject::connect(quitButton, SIGNAL(clicked()),
                 qApp, SLOT(quit()));

<-- 4

qApp->connect(shoutButton, SIGNAL(clicked()), msgr, SLOT(shout()));
    return box;
}

(1) box is the parent of layout.

(2) This is the window for qDebug messages.

(3) te is the child of layout.

(4) qApp is a global variable that points to the current QApplication object.

#ifndef MESSAGER_H
#define MESSAGER_H

#include <QObject>
#include <QString>
#include <QErrorMessage>
class Messager : public QObject {
    Q_OBJECT
 public:
    Messager (QString msg, QWidget* parent=0);

 public slots:
    void shout();

 private:
    QWidget* m_Parent;
    QErrorMessage* message;
};

#endif

#include "messager.h"

Messager::Messager(QString msg, QWidget* parent)
        : m_Parent(parent) {
    message = new QErrorMessage(parent);
    setObjectName(msg);
}

void Messager::shout() {
   message->showMessage(objectName());
}

[ . . . . ]
class QSlider;
class QLCDNumber;
class LogWindow;
class QErrorMessage;

class SliderLCD : public QMainWindow {
    Q_OBJECT
 public:
    SliderLCD(int minval = -273, int maxval = 360);
    void initSliderLCD();

 public slots:
    void checkValue(int newValue);
    void showMessage();

 signals:
    void toomuch();
 private:
    int m_Minval, m_Maxval;
    LogWindow* m_LogWin;
    QErrorMessage *m_ErrorMessage;
    QLCDNumber* m_LCD;
    QSlider* m_Slider;
};
#endif
[ . . . . ]

[ . . . . ]

SliderLCD::SliderLCD(int min, int max) : m_Minval(min),
m_Maxval(max) {
    initSliderLCD();
}

void SliderLCD::initSliderLCD() {
    m_LogWin = new LogWindow();

<-- 1

QDockWidget *logDock = new QDockWidget("Debug Log");
    logDock->setWidget(m_LogWin);
    logDock->setFeatures(0);

<-- 2

setCentralWidget(logDock);

    m_LCD = new QLCDNumber();
    m_LCD->setSegmentStyle(QLCDNumber::Filled);
    QDockWidget *lcdDock = new QDockWidget("LCD");
    lcdDock->setFeatures(QDockWidget::DockWidgetClosable);

<-- 3

lcdDock->setWidget(m_LCD);
    addDockWidget(Qt::LeftDockWidgetArea, lcdDock);

    m_Slider = new QSlider( Qt::Horizontal);
    QDockWidget* sliderDock = new QDockWidget("How cold is it
today?");
    sliderDock->setWidget(m_Slider);
    sliderDock->setFeatures(QDockWidget::DockWidgetMovable);
    /* Can be moved between doc areas */
    addDockWidget(Qt::BottomDockWidgetArea, sliderDock);

    m_Slider->setRange(m_Minval, m_Maxval);
    m_Slider->setValue(0);
    m_Slider->setFocusPolicy(Qt::StrongFocus);
    m_Slider->setSingleStep(1);

<-- 4

m_Slider->setPageStep(20);

<-- 5

m_Slider->setFocus();

<-- 6

connect(m_Slider, SIGNAL(valueChanged(int)),  /*SliderLCD is a
    QObject so
        connect does not need scope resolution. */
            this, SLOT(checkValue(int)));
    connect(m_Slider, SIGNAL(valueChanged(int)),
            m_LCD, SLOT(display(int)));

    connect(this, SIGNAL(toomuch()),
            this, SLOT(showMessage()));

<-- 7

m_ErrorMessage = NULL;
}

(1) a class defined in the utils library

(2) cannot be closed, moved, or floated

(3) can be closed

(4) Step each time left or right arrow key is pressed.

(5) Step each time PageUp/PageDown key is pressed.

(6) Give the slider focus.

(7) Normally there is no point in connecting a signal to a slot on the same object, but we do it for demonstration purposes.

[ . . . . ]

void SliderLCD::checkValue(int newValue) {
    if (newValue> 120) {
        emit toomuch();

<-- 1

}
}

/* This slot is called indirectly via emit because
   of the connect */
void SliderLCD::showMessage() {
    if (m_ErrorMessage == NULL) {
        m_ErrorMessage = new QErrorMessage(this);
    }
    if (!m_ErrorMessage->isVisible()) {
        QString message("Too hot outside! Stay in. ");
        m_ErrorMessage->showMessage(message);

<-- 2

}
}

(1) Emit a signal to anyone interested.

(2) This is a direct call to a slot. It's a member function.

#include "sliderlcd.h"
#include <QApplication>
#include <QDebug>

int main(int argc, char ** argv) {
    QApplication app(argc, argv);
    SliderLCD slcd;
    slcd.show();
    qDebug() << QString("This is a debug message.");
    return app.exec();
}

Synchronous or Asynchronous?

In single-threaded applications, or in multithreaded applications where the emitting and receiving QObject s are in the same thread, signals are sent in a synchronous manner. This means the thread blocks (suspends execution) until the code for the slots has completed execution (see Section 12.2).

In multi-threaded applications, where signals are emitted by an object in one thread and received by an object in another, it is possible to have signals queued, or executed in an asynchronous way, depending on the optional Qt::ConnectionType passed to connect() .

Modify the sliderlcd program as follows :

• Make the lcd display show the temperatures as hexadecimal integers.

• Make the lcd display characters have a different ("flat") style.

• Give the slider a vertical orientation.

• Give the slider and the lcd display more interesting colors.

• Add a push button that the user can click to switch the lcd display from decimal mode to hexadecimal mode.

• Make the push button into a toggle that allows the user to switch back and forth between decimal and hexadecimal modes.

Write an application, similar to the one in Section 9.3, but that has four buttons. The first one, labeled Advice, should be connected to a slot that randomly selects a piece of text (such as a fortune cookie) and displays it in the QTextEdit window. The second one, labeled Weather, randomly selects a sentence about the weather and displays it in the QTextEdit window. The third one, labeled Next Meeting, pops up a message dialog with a randomly generated (fictitious) meeting time and descriptive message in it. The fourth one, labeled Quit, terminates the program. Use signals and slots to connect the button clicks with the appropriate functions.