Как вызвать слот из другого виджета

Как вызвать слот из другого виджета

БлогNot. QT: простой обмен сигналами между двумя классами

QT: простой обмен сигналами между двумя классами

Всё основное о сигналах и слотах в QT сказано в этой заметке, и там же приведён пример приложения. Этот пример, наверное, ещё проще и возник как ответ на вопрос о том, как организовать обмен сигналами между виджетом и неким объектом, представленным отдельным классом.

Создадим виджет с формой на основе класса QWidget действуя так же, как в этой статье.

Затем добавим в проект класс MyObject , являющийся потомком базового класса Object . Для этого нажмём правую кнопку мыши на выделенном жирным шрифтом имени проекта, выберем пункт меню Добавить новый. затем слева укажем язык C++, справа — пункт списка C++ Class, нажмём кнопку Выбрать. в новом окне введём имя класса MyObject и выберем из списка базовый класс QObject .

Осталось нажать Далее и Завершить, пустой класс, готовый отправлять и принимать сигналы, создан.

Предусмотрим отправку из виджета сигнала некоторому объекту (другому классу) и слот для приёма информации от объекта. Для этого изменим файл widget.h следующим образом:

#ifndef WIDGET_H #define WIDGET_H #include #include "myobject.h" //заголовочный файл класс объекта namespace Ui < class Widget; >class Widget : public QWidget < Q_OBJECT public: explicit Widget(QWidget *parent = 0); ~Widget(); private: Ui::Widget *ui; MyObject Object; //Объект, с которым будем работать signals: void send_to_object(bool); //будем отправлять величину типа bool private slots: void get_from_object(bool); //и принимать такую же >; #endif // WIDGET_H

Суть механизма сигналов и слотов состоит в том, что виджет может использовать интерфейс сигналов и слотов других виджетов, не вникая в детали их реализации, не заботясь об очередности обработки сигналов и даже «не зная», будет ли сигнал обработан. Объект просто посылает «внешнему миру» сигнал о том, что его состояние изменилось и другие объекты могут это учесть. Заставим наш виджет посылать сигнал классу MyObject , а последнему укажем принимать его в ещё не написанный слот get_from_gui .

Осуществим и обратную связь. Виджет будет принимать в слот get_from_object сигнал send_to_gui , отправленный из объекта Object .

Соединять сигналы со слотами можно в любой точке приложения, для удобства сделаем это в конструкторе виджета, изменив файл widget.cpp следующим образом:

#include «widget.h» #include «ui_widget.h» Widget::Widget(QWidget *parent) : QWidget(parent), ui(new Ui::Widget) < ui->setupUi(this); connect(this,SIGNAL(send_to_object(bool)),&Object,SLOT(get_from_gui(bool))); //Соединение 1 — от виджета к объекту connect(&Object,SIGNAL(send_to_gui(bool)),this,SLOT(get_from_object(bool))); //Соединение 2 — от объекта к виджету > Widget::~Widget()

Ниже этого кода обеспечим реализацию слота виджета.

Чтобы отображать величину типа bool , полученную от объекта, откроем двойным щелчком форму widget.ui и перетащим на неё однострочное тектовое поле lineEdit . Также добавим стандартный переключатель checkBox .

форма виджета

Горячей клавишей Ctrl+W закроем форму и подтвердим её сохранение.

Теперь можно добавить в widget.cpp слот, который будет менять текст, выведенный в lineEdit в зависимости от того, истинная или ложная величина ему передана.

void Widget::get_from_object(bool value) < ui->lineEdit->setText(value==true?tr("true"):tr("false")); >

Перейдём к написанию класса объекта. В файле myobject.h опишем сигнал и слот объекта, а также предусмотрим вектор из величин типа bool , хранящий последовательность состояний объекта.

#ifndef MYOBJECT_H #define MYOBJECT_H #include #include class MyObject : public QObject < Q_OBJECT public: explicit MyObject(QObject *parent = 0); signals: void send_to_gui(bool); private slots: void get_from_gui(bool); private: //данные класса QVector state; >; #endif // MYOBJECT_H

В файле myobject.cpp достаточно будет реализовать код слота.

void MyObject::get_from_gui(bool value) < state->append(value); //запомнить новое состояние emit send_to_gui(value); //и отправить виджету сигнал >

Виджет тоже должен когда-то отправлять сигнал, пусть это будет происходить при изменении состояния чекбокса. Когда оно меняется, чекбокс отправляет встроенный в него сигнал clicked()

Дважды щёлкнем по форме widget.ui , затем нажмём правую кнопку на чекбоксе, щёлкнем пункт меню Перейти к слоту. выберем из списка clicked() и нажмём ОК.

создание слота в режиме дизайна формы

В widget.cpp добавился ещё один слот, запрограммируем его:

void Widget::on_checkBox_clicked() < emit send_to_object(ui->checkBox->isChecked()); >

Объекту отправляется сигнал о текущем состоянии чекбокса, которое он заносит в свой список state .

Теперь виджет работает и обменивается сигналами с объектом.

03.03.2018, 10:07 [6706 просмотров]

Вызов виджета из формы

Я в qt немного новичок, но отчаянно пытаюсь перестать таковым быть и написать хотя бы какую-нибудь примитивную игру. Создал приложение, ситуация стандартная: по нажатию кнопки на одной форме должна открыться другая (QWidget).
Код:
В заголовочном файле первой формы:

1 2 3 4

#include "battleform.h" //подключение заголовочного файла второй формы class BattleForm; BattleForm *location;

и слот с нажатием кнопки

1 2 3 4 5 6

void MainMenuMap::on_button_Accomodation_clicked() { location = new BattleForm(this); location->show(); MainMenuMap::hide(); }

При компиляции по нажатию кнопки первая форма закрывается, как и должна, но больше ничего не происходит. Вторая форма не открывается. Так что не так?

94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:

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

Как навести мышку на x,y внутри виджета относительно 0,0 виджета (левого верхнего угла виджета)?
Как навести мышку на x,y внутри виджета относительно 0,0 этого виджета (левого верхнего угла.

Как добраться до виджета, который находится внутри другого виджета?
Есть QStackWidget, внутри которого на одной из страниц-виджетов находится QTabWidget.

вызов формы из формы как правильно?
Добрый день. Есть MainWindow и EditWindow(parent MainWindow) Как правильней будет сделать вызов.

591 / 395 / 208
Регистрация: 30.04.2017
Сообщений: 730

Сообщение от Какой-то парень

location = new BattleForm(this);

Расположение второго виджета на первом. Когда закрываешь первый закроется и второй.
В качестве родителя можно указать null и манипулировать удалением вручную,
либо указать флаг Qt::Window для второго окна чтобы виджет открывался вне первого окна.

Test::Test(QWidget *parent) : QWidget(parent,Qt::Window)

Регистрация: 14.04.2018
Сообщений: 14
Спасибо большое, заработало
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
Помогаю со студенческими работами здесь

QML — изменение содержимого формы по клику кнопки и виджета
Доброго дня всем. стоит задача — на qml написать прогу, где есть возможность изменения.

Вызов виджета из значения переменной
Возможно ли вызвать виджет используя значение переменной string (смотрите пример) У меня виджеты.

Вставка php-формы в поле виджета
Есть php файл, при вызове которого запускается форма. Нужно эту форму разместить в виджете. Как.

Передача имени формы в процедуру и в процедуре вызов метода объекта формы
Есть несколько форм: FrmMain, Frm2, Frm3. На каждой форме есть RichEdit под именем RchEdtLog. .

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

Почему заголовок виджета показывается ниже чем текст виджета
Создал зону виджетов. Создал шорткод. Шорткод вставляю в текстовый виджет. Заголовок виджета.

Передать сигнал в виджет qt из другого объекта

Qt5 c++. Про сигналы и слоты написано много, но мне так и не понятно как передать значение через сигнал на объект на форме ui. Тот вариант который я прописал сейчас не работает. Что имеем:

#ifndef MAINWINDOW_H #define MAINWINDOW_H #include namespace Ui < class MainWindow; >class MainWindow : public QMainWindow < Q_OBJECT public: explicit MainWindow(QWidget *parent = 0); ~MainWindow(); private slots: void on_pushButtonStart_clicked(); void on_pushButton_clicked(); private: Ui::MainWindow *ui; >; #endif // MAINWINDOW_H #ifndef TRANSPORTMAIL_H #define TRANSPORTMAIL_H #include class TransportMail : public QObject < Q_OBJECT public: explicit TransportMail(QObject *parent = 0); QString transport(QString, QString); QString email_transport (QString, QString); QString transport_email (QString, QString); QString email (int i); private: int pisem = 0; signals: void muttrc_switch (); void sendmail_sig (int); >; #endif // TRANSPORTMAIL_H /// mainwindow.cpp #include "mainwindow.h" #include "ui_mainwindow.h" #include #include "headers.h" #include "configmuttrc.h" #include "transportmail.h" #include "statistics.h" #include MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) < ui->setupUi(this); TransportMail *tm = new TransportMail; QObject::connect(tm, SIGNAL (sendmail_sig(int)), ui->lcdNumberSendMail, SLOT (display(int))); > void MainWindow::on_pushButtonStart_clicked() < TransportMail tm; tm.email_transport ("/home/alexandr/mutt/mail_shablon_dgis.html", ""); >void MainWindow::on_pushButton_clicked() < >MainWindow::~MainWindow() < delete ui; >/// transport.cpp #include "transportmail.h" #include "configmuttrc.h" #include "statistics.h" #include "headers.h" #include #include #include "mainwindow.h" #include "ui_mainwindow.h" TransportMail::TransportMail(QObject *parent) : QObject(parent) < >QString TransportMail::email_transport (QString message, QString subscription) < TransportMail t; int i, j; i = 1, j = 10; while (i> QString TransportMail::email (int i) < --- >QString TransportMail::transport(QString email, QString file) < --- >QString TransportMail::transport_email (QString adress, QString file)

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

Сигналы и слоты используются для коммуникации между объектами. Механизм сигналов и слотов главная особенность Qt и вероятно та часть, которая отличаетcя от особенностей, предоставляемых другими фреймворками.

Введение

В программировании графического интерфейса, когда мы меняем один виджет, мы часто хотим что бы другой виджет получил об этом уведомление. В общем случае, мы хотим что бы объекты любого типа могла общаться с другими. Например, если пользователь нажимает кнопку Закрыть, мы вероятно хотим что бы была вызвана функция окна close().
Другие библиотеки добиваются такого рода общения используя обратный вызов. Обратный вызов это указатель на функцию, таким образом, если мы хотим что бы функция уведомила нас о каких-нибудь событиях, мы передаем указатель на другую функцию (обратновызываемую) этой функции. Функция в таком случае делает обратный вызов когда необходимо. Обратный вызов имеет два основных недостатка. Во-первых, он не является типобезопасным. Мы никогда не можем быть уверены что функция делает обратный вызов с корректными аргументами. Во-вторых, обратный вызов жестко связан с вызывающей его функцией, так как эта функция должна точно знать какой обратный вызов надо делать.

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

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

Механизм сигналов и слотов типобезопасен. Сигнатура сигнала должна совпадать с сигнатурой слота-получателя. (Фактически слот может иметь более короткую сигнатуру чем сигнал который он получает, так как он может игнорировать дополнительные аргументы). Так как сигнатуры сравнимы, компилятор может помочь нам обнаружить несовпадение типов. Сигналы и слоты слабо связаны. Класс, который вырабатывает сигнал не знает и не заботится о том, какие слоты его получат. Механизм сигналов и слотов Qt гарантирует, что если мы подключим сигнал к слоту, слот будет вызван с параметрами сигнала в нужное время. Сигналы и слоты могут принимать любое число аргументов любого типа. Они полностью типобезопасны.
Все классы, наследуемые от QObject или его дочерних классов (например, QWidget) могут содержать сигналы и слоты. Сигналы вырабатываются объектами когда они изменяют свое состояние так, что это может заинтересовать другие объекты. При этом он на знает и не заботится о том что у его сигнала может не быть получателя.
Слоты могут быть использованы для получения сигналов, но они так же нормальные функции-члены. Так же как объект не знает ничего о получателях своих сигналов, слот ничего не знает о сигналах, которые к нему подключены. Это гарантирует что полностью независимые компоненты могут быть созданы с помощью Qt.
Мы можем подключать к одному слоту столько сигналов, сколько захотим, также один сигнал может быть подключен к стольким слотам, сколько необходимо. Так же возможно подключать сигнал к другому сигналу (это вызовет выработку второго сигнала немедленно после появления первого).
Сигналы и слоты вместе составляют мощный механизм создания компонентов.

Небольшой пример

Описание класса на C++ может выглядеть вот так:

1. class Counter
3. public :
4. Counter()
5. int value () const
6. void setValue( int value );
7. private :
8. int m_value;
9. >;

Класс, наследуемый от QObject будет выглядеть следующим образом:

1. #include
2. class Counter : public QObject
4. Q_OBJECT
5. public :
6. Counter()
7. int value () const
8. public slots:
9. void setValue( int value );
10. signals:
11. void valueChanged( int newValue);
12. private :
13. int m_value;
14. >;

Класс, наследованный от QObject имеет то же самое внутреннее состояние и обеспечивает публичные методы для доступа к этому состоянию, но дополнительно у него есть поддержка для использования сигналов и слотов. Этот класс может сообщить внешнему миру что его состояние изменилось выработав сигнал valueChanged() и у него есть слот, в который другие объекты могут посылать сигналы.
Все классы, содержащие сигналы и слоты должны указывать макрос Q_OBJECT в начале их описания. Они также должны быть потомками (прямо или косвенно) QObject.
Слоты реализуются программистом. Возможная реализация слота Counter::setValue() выглядит следующим образом:

1. void Counter::setValue( int value )
3. if ( value != m_value)
4. m_value = value ;
5. emit valueChanged( value );
6. >
7. >

Ключевое слово emit вырабатывает сигнал valueChanged() объекта с новым значением в качестве аргумента.
В следующем примере мы создаем два объекта типа Counter и соединяем сигнал valueChanged() первого со слотом setValue() второго используя статическую функцию QObject::connect():

1. Counter a, b;
2. QObject::connect(&a, SIGNAL(valueChanged( int )),
3. &b, SLOT(setValue( int )));
4. a.setValue(12); // a.value() == 12, b.value() == 12
5. b.setValue(48); // a.value() == 12, b.value() == 48

Вызов a.setValue(12) вырабатывает сигнал valueChanged(12), который получит объект b в свой слот setValue() slot, т.е. будет вызвана функция b.setValue(12). Тогда b вырабатывает такой же сигнал valueChanged(), но так как он не подключен ни к одному слоту, это сигнал будет проигнорирован.
Отмечу что функция setValue() устанавливает новое значение и вырабатывает сигнал только есть value != m_value. Это предотвращает бесконечный цикл в случае кругового соединения (например, если бы b.valueChanged() был бы подключен к a.setValue()).
Сигнал вырабатывается для каждого соединения. Если соединение продублировать, два сигнала будут выработаны. Соединение всегда можно разорвать использовав функцию QObject::disconnect().
Приведенный выше пример показывает как объекты могут работать вместе без необходимости знать что-либо друг о друге. Что бы задействовать это, объекты должны быть соединены вместе и это может быть достигнуто простым вызовом функции QObject::connect() или с помощью свойства автоматического соединения программы uic.

Компилирование примера

Мета-объектный компилятор (meta-object compiler, moc) просматривает описание классов в файлах исходных кодов и генерирует код на C++, который инициализирует мета-объекты. Мета-объекты содержат имена все сигналов и слотов, так же как и указатели на эти функции.
Запуская программу moc для описания класса, содержащего сигналы и слоты, мы получаем файл исходных кодов, который должен быть скомпилирован и слинкован с другими объектными файлами приложения. При использовании qmake, правила для автоматического вызова moc будут добавлены в Makefile проекта.

Сигналы

Сигналы вырабатываются объектами когда они изменяют свое состояние так, что это может заинтересовать другие объекты. Только класс, который определяет сигнал или его потомки могут вырабатывать сигнал.
Когда сигнал вырабатывается, слот, к которому он подключен обычно выполняется немедленно, так же как и нормальный вызов процедуры. Когда это происходит, механизм сигналов и сигналов и слотов полностью независим от любого цикла событий графического интерфейса. Выполнение кода, следующего за выпуском сигнала произойдет сразу после выхода из всех слотов. Ситуация слегка отличается когда используются отложенные соединения (queued connections); в этом случае код после ключевого слова emit продолжает выполнение немедленно, а слоты будут выполнены позже.
Если несколько слотов подключены к одному сигналу, слоты будут выполнены один за другим в произвольном порядке после выработки сигнала.
Сигналы автоматически генерируются программой moc и не должны быть реализованы в исходном коде. Они могут не возвращать значение (т. е., используем тип void).
Замечание по поводу аргументов: опыт показывает, что сигналы и слоты легче повторно использовать при написании программ, если они не используют специальных типов. Например, если бы сигнал QScrollBar::valueChanged() использовал бы специальный тип вроде гипотетического QScrollBar::Range, он мог бы быть подключенным только к слотам, спроектированным специально для него.

Слоты

Слот вызывается когда вырабатывается сигнал, с которым он связан. Слот это обычная функция в C++ и может вызываться обычным способом; единственная его особенность, что с ним можно соединсять сигналы.
Так как слоты это нормальные функции-члены, они следуют обычным правилам C++ при прямом вызове. Тем не менее, как слоты, они могут быть вызваны любым компонентом, независимо от их уровней доступа, через соединение сигнал-слот. Это значит, что сигнал, выработаный объектом произвольного класса может вызвать защищенный (private) слот объекта несвязанного с ним класса.
Слоты так же можно объявлять виртуальными, что иногда бывает довольно удобно.
По сравнению с обратными вызовами, сигналы и слоты слегка медленнее из-за увеличенной гибкости, которую они обеспечивают, хотя разница для реальных приложений незаметна. В общем, выработка сигнала, который подключен к некоторым слотам, в среднем в 10 раз медленнее, чем вызов получателя напрямую, при вызове не виртуальной функции. Эти накладные расходы требуются для нахождения объекта, для безопасного перебора всех его соединений (т. е. проверка что последующий получатель не был уничтожен во время выпуска сигнала) и передачи любых параметров в общем виде. Хотя вызов десяти невиртуальных процедур может показаться дорогим, это менее затратно, чем, например, операция создания или удаления объекта. Пока мы создаем строку, вектор или список, что неявно требует создание объекта, затраты сигналов и слотов отвечают за очень маленькую долю в затратах среди всех вызовов процедур.
То же самое верно делаете ли вы системный вызов в слот или косвенно вызываете более десяти функций. На i586-500, мы можем вырабатывать около 2,000,000 сигналов в секунду, соединенных с одним слотом или 1,200,000 в секунду, при соединении в двумя слотами. Простота и гибкость механизма сигналов и слотов окупает дополнительные затраты, которые пользователь программы даже не заметит.
Следует заметить, что библиотеки, которые определяют переменные с именами signal или slot, могут вызывать предупреждения или ошибки компилятора при компиляции вместе с программой, написанной на Qt. Что бы решить данную проблему, необходимо убрать определение мешающегося символа препроцессора с помощью директивы #undef.

Метаобъектная информация

Метаобъект содержит дополнительную информацию, такую как имя объекта. Можно так же проверить наследует ли объект определенный класс, например:

1. if (widget->inherits( «QAbstractButton» ))
2. QAbstractButton *button = static_cast(widget);
3. button->toggle();
4. >

Метаобъектная информация также испльзуется qobject_cast(), который похож на QObject::inherits(), но менее предрасположен к ошибкам:

1. if (QAbstractButton *button = qobject_cast(widget))
2. button->toggle();

Реальный пример

Ниже приведен простой пример виджета с комментариями.

1. #ifndef LCDNUMBER_H
2. #define LCDNUMBER_H
3. #include
4. class LcdNumber : public QFrame
6. Q_OBJECT

Класс LcdNumber наследует QObject, который обладает большинством информации о сигналах и слотах через классы QFrame и QWidget. Он похож на встроенный виджет QLCDNumber.
Макрос Q_OBJECT указывает препроцессору объявить несколько функций-членов, которые будут реализованы программой moc; если при компилировании среди прочих будет появляется запись «undefined reference to vtable for LcdNumber», то скорее всего забыли запустить moc или добавить результат его работы в команду линковки.

1. public :
2. LcdNumber(QWidget *parent = 0);

Это не явно относится к moc’у, но если мы наследуем класс Qwidget, мы скорее всего захотим иметь аргумент parent (родитель) в конструкторе и передавать его конструктору родительского класса.
Некоторые деструкторы и функции-члены опущены здесь; moc игнорирует функции-члены.

1. signals:
2. void overflow();

LcdNumber вырабатывает сигнал когда его просят показать невозможное значение.
Если мы не заботимся о переполнении или знаем что оно не может произойти, мы может игнорировать этот сигнал, т.е. никуда его не подключать.
С другой стороны, если мы захотим вызвать две разные функции для реакции на эту ошибку, тогда просто подключаем эту функцию к двум разным слотам. Qt вызовет их оба (в произвольном порядке).

1. public slots:
2. void display( int num);
3. void display( double num);
4. void display( const QString &str);
5. void setHexMode();
6. void setDecMode();
7. void setOctMode();
8. void setBinMode();
9. void setSmallDecimalPoint( bool point);
10. >;
11. #endif

Слоты это функции, используемые для получения информации об изменениях состояний других виджетов. LcdNumber использует их, как показано в коде выше, для установки отображаемого числа. Так как функция display() часть интерфейса класса с остальной программой, этот слот публичный.
Стоит отметить что функция display() перегружена. Qt выберет подходящую версию при соединении сигнала и слота. С обратным вызовом нам бы пришлось искать пять разных имен и контролировать типы самостоятельно.
Некоторые незначительные функции-члены были опущены в данном примере.

Продвинутое использование сигналов и слотов

В некоторых случаях может потребоваться информация об отправителе сигнала. Qt предоставляет функцию Qobject::sender(), которая возвращает указатель на объект, пославший сигнал.
Класс QSignalMapper необходим в ситуациях, когда много сигналов подключены к одному и тому же слоту, и этот слот должен реагировать на каждый сигнал по-разному.
Предположим что у нас есть три кнопки, которые определяют, какой файл мы хотим открыть: «Tax File», «Accounts File», or «Report File».
Что бы открыть нужный файл мы соединяем их сигнал QPushButton::clicked() со слотом readFile(). Теперь используем функцию класса QSignalMapper — setMapping() — для преобразования всех сигналов в объект QSignalMapper.

1. signalMapper = new QSignalMapper( this );
2. signalMapper->setMapping(taxFileButton, QString( «taxfile.txt» ));
3. signalMapper->setMapping(accountFileButton, QString( «accountsfile.txt» ));
4. signalMapper->setMapping(reportFileButton, QString( «reportfile.txt» ));
5. connect(taxFileButton, SIGNAL(clicked()),
6. signalMapper, SLOT (map()));
7. connect(accountFileButton, SIGNAL(clicked()),
8. signalMapper, SLOT (map()));
9. connect(reportFileButton, SIGNAL(clicked()),
10. signalMapper, SLOT (map()));

Теперь подключаем сигнал mapped() к слоту readFile() в котором разные файлы будут открыты в зависимости от нажатой кнопки.

1. connect(signalMapper, SIGNAL(mapped( const QString &)),
2. this , SLOT(readFile( const QString &)));

Использование Qt со сторонними сигналами и слотами

Можно использовать Qt со сторонним механизмом сигналов и слотов. Можно использовать несколько механизмов в одном проекте. Для этого надо добавить следующую строку в файл проекта (.pro):

CONFIG += no_keywords

Эта опция говорит Qt не определять ключевые слова moc’a — signals, slots, и emit, так как эти имена будут использованы строронней библиотекой, например, Boost. Что бы использовать сигналы и слоты Qt с установленным флагом no_keywords, надо просто заменить все использования ключевых слов moc’а Qt в исходных файлах на соотствующие макросы — Q_SIGNALS, Q_SLOTS, и Q_EMIT.