Книга: Основы программирования в Linux

Сигналы и слоты

Сигналы и слоты

Как вы видели в главе 16, сигналы и их обработка — главные механизмы, используемые приложениями GUI для реагирования на ввод пользователя, и ключевые функции библиотек GUI. Механизм обработки сигналов комплекта Qt состоит из сигналов и слотов или приемников, называемых сигналами и функциями обратного вызова в комплекте инструментов GTK+ или событиями и обработчиками событий в языке программирования Java.

Вот как устроено программирование, управляемое событиями: графический интерфейс пользователя состоит из меню, панелей инструментов, кнопок, полей ввода и множества других элементов GUI, называемых виджетами. Когда пользователь взаимодействует с виджетом, например, активизирует пункт меню или вводит какой-то текст в поле ввода, виджет порождает именованный сигнал, такой как clicked, text_changed или key_pressed. Как правило, вам захочется сделать что-то в ответ на действие пользователя, например, сохранить документ или выйти из приложения, и вы выполняете это, связав сигнал с функцией обратного вызова или слотом на языке Qt.

Применение сигналов и слотов довольно специфично — Qt определяет два новых соответствующим образом описанных псевдоключевых слова, signals и slots для обозначения в вашем программном коде классов сигналов и слотов. Это замечательно с точки зрения читаемости и сопровождения программного кода, но вы вынуждены пропускать свой код через отдельный этап препроцессорной обработки для поиска и замены этих псевдоключевых слов дополнительным кодом на языке С++.

На способы применения сигналов и слотов в Qt есть несколько ограничений, но они не слишком существенные:

? сигналы и слоты должны быть функциями-методами класса-потомка QObject;

? при использовании множественного наследования QObject должен быть первым в списке класса;

? оператор Q_OBJECT должен появляться первым в объявлении класса;

? сигналы нельзя применять в шаблонах;

? указатели на функцию не могут использоваться как аргументы в сигналах и слотах;

? сигналы и слоты не могут переопределяться или обновляться до статуса public (общедоступный).

Поскольку вы должны писать ваши сигналы и слоты как потомков объекта QObject, логично создавать ваш интерфейс, расширяя и настраивая виджет, начиная с QWidget, базового виджета Qt, потомка виджета QObject. В комплекте Qt вы почти всегда будете создавать интерфейсы, расширяя такие виджеты, как QMainWindow.

Типичное определение класса в файле MyWindow.h для вашего GUI будет напоминать приведенное далее:

class MyWindow : public QMainWindow {
 Q_OBJECT
public:
 MyWindow();
 virtual ~MyWindow();
signals:
 void aSignal();
private slots:
 void doSomething();
}

Ваш класс — наследник объекта QMainWindow, который определяет функциональные возможности главного окна в приложении. Аналогичным образом при создании диалогового окна вы определите подкласс QDialog. Первым указан оператор Q_OBJECT, действующий как метка для препроцессора, за которым следуют обычные объявления конструктора и деструктора. Далее даны определения сигнала и слота.

У вас есть один сигнал и один слот, оба без параметров. Для порождения сигнала aSignal() вам нужно всего лишь в любом месте программы вызвать функцию emit:

emit aSignal();

Это означает, что все остальное обрабатывается Qt. Вам даже не потребуется реализация aSignal().

Для применения слотов их нужно связать с сигналом. Делается это соответствующим образом с помощью названного статического метода connect класса QObject:

bool QObject::connect(const QObject * sender, const char* signal,
 const QObject * receiver, const char * member);

Просто передайте объект, владеющий сигналом (отправитель), функцию сигнала, объект, владеющий слотом (приемником), и в завершение укажите имя слота.

В примере MyWindow, если бы вы захотели связать сигнал clicked виджета QPushButton с вашим слотом doSomething, вы бы написали:

connect(button, SIGNAL(clicked()), this, SLOT(doSomething()));

Учтите, что необходимо применять макросы SIGNAL и SLOT для выделения функций сигналов и слотов. Как и в комплекте GTK+, вы можете связать ряд слотов с заданным сигналом и также связать слот с любым количеством сигналов с помощью множественных вызовов функции connect. Если она завершается аварийно, то возвращает FALSE.

Остается реализовать ваш слот в виде обычной функции-метода:

void MyWindow::doSomething() {
 // Код слота
}

Выполните упражнение 17.2.

Теперь, зная основы использования сигналов и слотов, применим их в примере. Усовершенствуйте QMainWindow, вставьте в него кнопку и свяжите сигнал кнопки clicked со слотом.

1. Введите следующее объявление класса и назовите файл ButtonWindow.h:

#include <qmainwindow.h>
class ButtonWindow : public QMainWindow {
 Q_OBJECT
public:
 ButtonWindow(QWidget *parent = 0, const char *name = 0);
 virtual ~ButtonWindow();
private slots:
 void Clicked();
};

2. Далее следует реализация класса в файле ButtonWindow.cpp:

#include "ButtonWindow.moc"
#include <qpushbutton.h>
#include <qapplication.h>
#include <iostream>

3. В конструкторе вы задаете заголовок окна, создаете кнопку и связываете сигнал нажатия кнопки с вашим слотом. setCaption — метод объектов типа QMainWindow, который, что неудивительно, задает заголовок окна:

ButtonWindow::ButtonWindow(QWidget *parent, const char* name) : QMainWindow(parent, name) {
 this->setCaption("This is the window Title");
 QPushButton *button = new QPushButton("Click Me!", this, "Button1");
 button->setGeometry(50, 30, 70, 20);
 connect(button, SIGNAL(clicked()), this, SLOT(Clicked()));
}

4. Qt автоматически удаляет виджеты, поэтому ваш деструктор пуст:

ButtonWindow::~ButtonWindow() {}

5. Затем реализация слота:

void ButtonWindow::Clicked(void) {
 std::cout << "clicked!n";
}

6. И наконец, в функции main вы просто создаете экземпляр типа ButtonWindow, делаете его главным окном вашего приложения и отображаете окно на экране:

int main(int argc, char **argv) {
 QApplication app(argc, argv);
 ButtonWindow *window = new ButtonWindow();
 app.setMainWidget(window);
 window->show();
 return app.exec();
}

7. Прежде чем вы сможете откомпилировать данный пример, необходимо запустить препроцессор для заголовочного файла. Программа этого препроцессора называется Meta Object Compiler (moc, компилятор метаобъекта) и должна быть включена в пакет комплекта Qt. Выполните moc для файла ButtonWindow.h, сохранив результат в файле ButtonWindow.moc:

$ moc ButtonWindow.h -о ButtonWindow.moc

Теперь можно компилировать как обычно, скомпоновав с результатом команды moc.

$ g++ -о button ButtonWindow.срр -I$QTDIR/include -L$QTDIR/lib -lqui

Выполнив программу, вы получите пример, показанный на рис. 17.3.

Рис. 17.3 

Как это работает

В этом примере мы ввели новый виджет и некоторые новые функции, поэтому давайте их рассмотрим. QPushButton — виджет простой кнопки, хранящий метку и растровую графику и способный активизироваться при щелчке пользователя кнопкой мыши или при нажатии клавиш.

Конструктор объекта QPushButton очень прост.

QPushButton::QPushButton(const QString &text, QWidget *parent,
 const char* name=0);

Первый аргумент — текст метки кнопки, далее родительский виджет и последний аргумент — имя кнопки, обычно применяемое Qt для внутренних операций.

Параметр родительского виджета, общий для всех объектов, — QWidget, он управляет отображением и уничтожением и разными другими свойствами. Передача NULL в качестве родительского объекта означает виджет верхнего уровня, при этом создается содержащее его пустое окно. В примере вы передаете текущий объект ButtonWindow с помощью ключевого слова this, что приводит к вставке кнопки в основную область окна ButtonWindow.

Аргумент name задает имя виджета для внутреннего использования Qt. Если комплект Qt обнаружит ошибку, имя виджета будет выведено в сообщении об ошибке, поэтому неплохо выбирать подходящие имена виджетов, поскольку при отладке это сбережет массу времени.

Вы могли заметить, что объект QPushButton очень примитивно вставляется в окно ButtonWindow, с помощью параметра parent конструктора QPushButton, без указания положения кнопки, ее размера, рамки или чего-либо еще. Если вы хотите управлять внешним видом кнопки, что очень важно для создания привлекательного интерфейса, следует применять виджеты компоновки комплекта Qt. Давайте их сейчас рассмотрим,

В Qt есть целый ряд способов размещения и компоновки виджетов. Вы уже видели использование абсолютных координат с помощью вызова setGeometry, но они редко применяются, поскольку виджеты не масштабируются и не меняют размеры при изменении величины окна.

Предпочтительный метод компоновки виджетов — применение классов QLayout или виджетов-контейнеров, которые изменяют свои размеры соответствующим образом после задания им подсказок, касающихся отступов и расстояний между виджетами.

Ключевое различие между классами QLayout и упаковочными контейнерами заключается в том, что объекты класса QLayout не являются виджетами.

Классы компоновки — потомки объектов, типа QObject, а не QWidget, поэтому их применение ограничено. Например, вы не можете создать объект QVBoxLayout — основной виджет объекта QMainWindow.

Виджеты упаковочных контейнеров (такие, как QHBox и QVBox) напротив — потомки объекта типа QWidget следовательно, вы можете применять их как обычные виджеты. Возможно, вас удивляет, что в Qt есть и классы QLayout, и виджеты QBox с дублирующимися функциональными возможностями. На самом деле виджеты QBox существуют только для удобства и по существу служат оболочкой классов QLayout в типе QWidget. Объекты QLayout обладают возможностью автоматического изменения размеров, в то время как размеры виджетов нужно изменять вручную с помощью вызова метода QWidget::resizeEvent().

Подклассы QLayout: QVBoxLayout и QHBoxLayout, — самый распространенный способ создания интерфейса, и именно их вы будете чаще всего встречать в программном коде с применением Qt.

QVBoxLayout и QHBoxLayout — невидимые объекты-контейнеры, хранящие другие виджеты и схемы размещения с вертикальной и горизонтальной ориентациями соответственно. Вы сможете создавать сколь угодно сложные компоновки виджетов, поскольку допускается использование вложенных компоновок, например, за счет вставки как элемента горизонтальной схемы размещения внутрь вертикального упаковочного контейнера.

Есть три конструктора QVBoxLayout, заслуживающих внимания (у объектов QHBoxLayout идентичный API).

QVBoxLayout::QVBoxLayout(QWidget *parent, int margin, int spacing,
 const char *name)
QVBoxLayout::QVBoxLayout(QLayout *parentLayout, int spacing,
 const char * name)
QVBoxLayout::QVBoxLayout(int spacing, const char *name)

Родителем объекта QLayout может быть либо виджет, либо другой объект типа QLayout. Если не задавать родительский объект, вы сможете только вставить позже данную схему размещения в другой объект QLayout с помощью метода addLayout.

Параметры margin и spacing задают пустое пространство в пикселах вокруг схемы размещения QLayout и между отдельными виджетами в ней.

После создания вашей схемы размещения QLayout вы можете вставлять дочерние виджеты или схемы с помощью следующей пары методов:

QBoxLayout::addWidget(QWidget *widget, int stretch = 0, int alignment = 0);
QBoxLayout::addLayout(QLayout *layout, int stretch = 0);

Выполните упражнение 17.3.

В этом примере вы увидите в действии классы QBoxLayout при размещении виджетов QLabel в окне QMainWindow.

1. Сначала введите заголовочный файл LayoutWindow.h:

#include <qmainwindow.h>
class LayoutWindow : public QMainWindow {
 QOBJECT
public:
 LayoutWindow(QWidget *parent = 0, const char *name = 0);
virtual ~LayoutWindow();
};

2. Теперь введите реализацию в файл LayoutWindow.cpp:

#include <qapplication.h>
#include <qlabel.h>
#include <qlayout.h>
#include "LayoutWindow.moc"
LayoutWindow::LayoutWindow(QWidget* parent, const char *name) :
 QMainWindow(parent, name) {
 this->setCaption("Layouts");

3. Необходимо создать фиктивный QWidget для хранения объекта QHBoxLayout, поскольку его нельзя напрямую вставить в объект QMainWindow:

 QWidget *widget = new QWidget(this);
 setCentralWidget(widget);
 QHBoxLayout *horizontal = new QHBoxLayout(widget, 5, 10, "horizontal");
 QVBoxLayout *vertical = new QVBoxLayout();
 QLabel* label1 = new QLabel("Top", widget, "textLabel1");
 QLabel* label2 = new QLabel("Bottom", widget, "textLabel2");
 QLabel* label3 = new QLabel("Right", widget, "textLabel3");
 vertical->addwidget(label1);
 vertical->addwidget(label2);
 horizontal->addLayout(vertical);
 horizontal->addWidget(label3);
 resize(150, 100);
}
LayoutWindow::~LayoutWindow() { }
int main(int argc, char **argv) {
 QApplication app(argc, argv);
 LayoutWindow *window = new LayoutWindow();
 app.setMainWidget(window);
 window->show();
 return app.exec();
}

Как и прежде, перед компиляцией нужно выполнить moc для заголовочного файла:

$ moc LayoutWindow.h -о LayoutWindow.moc
$ g++ -о layout LayoutWindow.cpp -I$QTDIR/include -L$QTDIR/lib -lqui

Выполнив эту программу, вы получите схему размещения ваших меток QLabel (рис. 17.4). Попробуйте изменить величину окна и посмотрите, как расширяются и сжимаются метки, заполняя все доступное пространство.

Рис. 17.4

Как это работает

Программа LayoutWindow.cpp создает два виджета упаковочных контейнеров, горизонтальный и вертикальный контейнер для размещения виджетов. Вертикальный контейнер получает две метки, описанные, соответственно, как Top и Bottom. Горизонтальный контейнер также содержит два виджета, метку, обозначенную Right, и вертикальный контейнер. Вы можете помещать компоновочные виджеты внутрь других компоновочных виджетов, как показано в данном примере.

Попробуйте изменить исходный текст программы в файле LayoutWindow.срр, чтобы поэкспериментировать и лучше понять, как работают компоновочные виджеты.

Мы рассмотрели основы применения Qt — сигналы и слоты, команду moc и средства компоновки. Теперь пора более внимательно изучить виджеты.

Оглавление книги