Класс QObject

Класс QObject является базовым классом всех объектов Qt. Подробнее...

• Список всех членов, включая унаследованные
• Устаревшие члены

Примечание: Все функции в этом классе являются реентерабельными.

Примечание: Эти функции также безопасны для потоков:

• connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
• connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type) const
• connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type)
• connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
• connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type)
• disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)
• disconnect(const char *signal, const QObject *receiver, const char *method) const
• disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

Свойства

• objectName : QString

Публичные функции

Публичные слоты

Сигналы

Статические публичные члены

Защищенные функции

Защищенные переменные

Статические защищенные члены

Связанные нечлены

Макросы

Подробное описание

Класс QObject является базовым классом всех объектов Qt.

QObject — сердце Qt модели объектов. Центральной особенностью этой модели является очень мощный механизм бесшовного взаимодействия объектов, называемый сигналами и слотами. Вы можете подключить сигнал к слоту с помощью connect() и разорвать подключение с помощью disconnect(). Чтобы избежать бесконечных циклов уведомлений, вы можете временно заблокировать сигналы с помощью blockSignals(). Защищенные функции connectNotify() и disconnectNotify() позволяют отслеживать подключения.

QObjects организуются в деревья объектов. Когда вы создаёте QObject с другим объектом в качестве родителя, объект автоматически добавляется в список children() родителя. Родитель получает владение объектом; то есть он автоматически удалит своих детей в своём деструкторе. Вы можете искать объект по имени и, необязательно, типу, используя findChild() или findChildren().

Каждый объект имеет objectName() и его имя класса можно найти через соответствующий metaObject() (см. QMetaObject::className()). Вы можете определить, наследует ли класс объекта другой класс в иерархии наследования QObject, используя функцию inherits().

При удалении объекта он испускает сигнал destroyed() . Вы можете перехватить этот сигнал, чтобы избежать появления висячих ссылок на объекты QObject.

Объекты QObject могут получать события через event() и фильтровать события других объектов. Подробности см. в installEventFilter() и eventFilter(). Удобный обработчик childEvent() можно переопределить для перехвата событий дочерних объектов.

Наконец, QObject предоставляет базовую поддержку таймеров в Qt; для поддержки таймеров высокого уровня см. QTimer.

Обратите внимание, что макрос Q_OBJECT является обязательным для любого объекта, реализующего сигналы, слоты или свойства. Вам также необходимо запустить Meta Object Compiler для исходного файла. Мы настоятельно рекомендуем использовать этот макрос во всех подклассах QObject, независимо от того, используются ли в них сигналы, слоты и свойства, так как отсутствие этого может привести к необычному поведению некоторых функций.

Все виджеты Qt наследуют QObject. Функция удобства isWidgetType() возвращает значение true, если объект является виджетом. Она намного быстрее, чем qobject_cast<QWidget *>(obj) или obj->inherits("QWidget").

Некоторые функции QObject, например children(), возвращают QObjectList. QObjectList — это псевдоним для QList<QObject *>.

Связанность с потоком

У экземпляра QObject есть связанность с потоком или он обитает в определённом потоке. Когда QObject получает посылаемый сигнал или поставленное событие, обработчик слота или события будет выполняться в потоке, в котором обитает объект.

Примечание: Если у QObject нет связанности с потоком (то есть, если thread() возвращает ноль) или если он обитает в потоке без работающего цикла событий, то он не может получать посылаемые сигналы или поставленные события.

По умолчанию QObject обитает в потоке, в котором он создан. Связанность объекта с потоком можно запросить, используя thread(), и изменить, используя moveToThread().

Все QObjects должны обитать в том же потоке, что и их родитель. Следовательно:

• setParent() завершится с ошибкой, если два участвующих QObject обитают в разных потоках.
• Когда QObject перемещается в другой поток, все его дочерние объекты также будут автоматически перемещены.
• moveToThread() завершится с ошибкой, если у QObject есть родитель.
• Если QObjects созданы внутри QThread::run(), они не могут стать дочерними объектами объекта QThread, поскольку QThread не обитает в потоке, вызывающем QThread::run().

Примечание: Члены данных QObject не автоматически становятся дочерними объектами. Связь «родитель-дочерний» должна быть установлена, либо передав указатель на дочерний объект в конструктор, либо вызвав setParent(). Без этого шага члены данных объекта останутся в старом потоке при вызове moveToThread().

Отсутствие копирующего конструктора и оператора присваивания

QObject не имеет ни копирующего конструктора, ни оператора присваивания. Это сделано по дизайну. Фактически, они объявлены, но в разделе private, с использованием макроса Q_DISABLE_COPY(). На самом деле, все классы Qt, производные от QObject (прямо или косвенно), используют этот макрос для объявления их копирующего конструктора и оператора присваивания как закрытых. Обоснование см. в обсуждении Тождество против значения на странице модели объекта Qt Object Model.

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

Автоподключение

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

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

Динамические свойства

Начиная с Qt 4.2, динамические свойства можно добавлять к экземплярам QObject и удалять из них во время выполнения. Динамические свойства не нужно объявлять на этапе компиляции, но они обеспечивают те же преимущества, что и статические свойства, и управляются с помощью того же API — с помощью property() для чтения и setProperty() для записи.

Начиная с Qt 4.3, динамические свойства поддерживаются Qt Designer, и как стандартные виджеты Qt, так и созданные пользователем формы могут иметь динамические свойства.

Локализация (I18n)

Все подклассы QObject поддерживают функции локализации Qt, что позволяет перевести пользовательский интерфейс приложения на разные языки.

Чтобы сделать видимый текст локализацией, его необходимо обернуть в вызовы функции tr(). Подробное описание см. в документе Написание исходного кода для локализации.

См. также QMetaObject, QPointer, QObjectCleanupHandler, Q_DISABLE_COPY() и Деревья объектов и владение.

qDebug("MyClass::setPrecision(): (%s) invalid precision %f",
       qPrintable(objectName()), newPrecision);

Документация функций-членов

QObject::QObject(QObject *parent = nullptr)

Конструирует объект с родительским объектом parent.

Родитель объекта может рассматриваться как владелец объекта. Например, диалоговое окно является родителем кнопок ОК и Отмена, которые оно содержит.

Деструктор родительского объекта уничтожает все дочерние объекты.

Установка parent в 0 создает объект без родителя. Если объект является виджетом, он станет верхним окном.

Примечание: Эта функция может быть вызвана через систему метаобъектов и из QML. См. Q_INVOKABLE.

См. также parent(), findChild() и findChildren().

[virtual] QObject::~QObject()

Уничтожает объект, удаляя все его дочерние объекты.

Все сигналы к и от объекта автоматически отключаются, и любые ожидающие поставленные события для объекта удаляются из очереди событий. Однако часто безопаснее использовать deleteLater(), а не удалять подкласс QObject напрямую.

Предупреждение: Все дочерние объекты удаляются. Если какой-либо из этих объектов находится в стеке или является глобальным, рано или поздно ваша программа потерпит крах. Мы не рекомендуем хранить указатели на дочерние объекты вне родительского объекта. Если вы всё же это делаете, сигнал destroyed() предоставляет вам возможность определить момент уничтожения объекта.

Предупреждение: Удаление QObject во время ожидания событий может привести к краху. Вы не должны удалять QObject напрямую, если он существует в другом потоке, чем тот, который выполняется в данный момент. Используйте deleteLater() вместо этого, который заставит цикл событий удалить объект после обработки всех ожидающих событий.

См. также deleteLater().

bool QObject::blockSignals(bool block)

Если block равно true, сигналы, испускаемые этим объектом, блокируются (т.е., испускание сигнала не вызовет ничего подключенного к нему). Если block равно false, такой блокировки не происходит.

Значение возврата — предыдущее значение signalsBlocked().

Обратите внимание, что сигнал destroyed() будет испущен даже если сигналы для этого объекта заблокированы.

Сигналы, испущенные во время блокировки, не буферизуются.

См. также signalsBlocked() и QSignalBlocker.

[virtual protected] void QObject::childEvent(QChildEvent *event)

Обработчик событий, который можно переопределить в подклассе для получения событий о дочерних объектах. Событие передаётся в параметре event.

QEvent::ChildAdded и QEvent::ChildRemoved события отправляются объектам при добавлении или удалении дочерних объектов. В обоих случаях вы можете полагаться только на то, что дочерний объект является QObject, или, если isWidgetType() возвращает true, QWidget. (Это связано с тем, что в случае ChildAdded дочерний объект ещё не полностью сконструирован, а в случае ChildRemoved он, возможно, уже был разрушен).

QEvent::ChildPolished события отправляются виджетам, когда дочерние виджеты отшлифованы или добавлены отшлифованные дочерние виджеты. Если вы получаете событие child polished, значит конструкция дочернего объекта, как правило, завершена. Однако это не гарантируется, и несколько событий polish могут быть переданы во время выполнения конструктора виджета.

Для каждого дочернего виджета вы получаете одно событие ChildAdded, ноль или более событий ChildPolished и одно событие ChildRemoved.

Событие ChildPolished пропускается, если дочерний объект удаляется сразу после добавления. Если дочерний объект отшлифовывается несколько раз во время построения и уничтожения, вы можете получить несколько событий child polished для одного и того же дочернего объекта, каждый раз с разной виртуальной таблицей.

См. также event().

const QObjectList &QObject::children() const

Возвращает список дочерних объектов. Класс QObjectList определён в заголовочном файле <QObject> следующим образом:

typedef QList<QObject*> QObjectList;

Первый добавленный дочерний объект является первым объектом в списке, а последний добавленный — последним объектом в списке, то есть новые дочерние объекты добавляются в конец.

Обратите внимание, что порядок списка меняется при перемещении дочерних объектов QWidget с помощью raise или lower. Виджет, перемещённый вперёд, становится последним объектом в списке, а виджет, перемещённый назад, становится первым объектом в списке.

См. также findChild(), findChildren(), parent() и setParent().

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Создаёт соединение заданного type от signal в объекте sender к method в объекте receiver. Возвращает дескриптор соединения, который можно использовать для его последующего отключения.

При указании signal и method необходимо использовать макросы SIGNAL() и SLOT(), например:

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

Этот пример гарантирует, что метка всегда отображает текущее значение полосы прокрутки. Обратите внимание, что параметры сигнала и слота не должны содержать имён переменных, только тип. Например, следующее не будет работать и вернёт false:

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

Сигнал также может быть подключён к другому сигналу:

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

MyWidget::MyWidget()
{
    myButton = new QPushButton(this);
    connect(myButton, SIGNAL(clicked()),
            this, SIGNAL(buttonClicked()));
}

В этом примере конструктор MyWidget перенаправляет сигнал из частной переменной-члена и делает его доступным под именем, связанным с MyWidget.

Один сигнал может быть подключён к нескольким слотам и сигналам. Несколько сигналов могут быть подключены к одному слоту.

Если сигнал подключён к нескольким слотам, слоты активируются в том же порядке, в котором были установлены соединения, при передаче сигнала.

Функция возвращает QMetaObject::Connection, представляющий дескриптор соединения, если сигнал успешно подключён к слоту. Дескриптор соединения будет недействительным, если соединение не может быть создано, например, если QObject не может проверить существование signal или method, или если их сигнатуры несовместимы. Вы можете проверить, является ли дескриптор действительным, применив к нему преобразование в bool.

По умолчанию сигнал передаётся для каждого созданного соединения; два сигнала передаются для дублирующих соединений. Вы можете разорвать все эти соединения с помощью одного вызова disconnect(). Если вы передаёте Qt::UniqueConnection в качестве type, соединение будет установлено только в том случае, если оно не дублирует существующее. Если уже существует дубликат (один и тот же сигнал для одного и того же слота в одних и тех же объектах), соединение будет неуспешным, и connect вернёт недействительный QMetaObject::Connection.

Примечание: Qt::UniqueConnections не работают для лямбда-выражений, внеклассных функций и функторов; они применяются только к подключению к методам-членам.

Необязательный параметр type описывает тип соединения. В частности, он определяет, будет ли конкретный сигнал передан слоту немедленно или помещён в очередь для передачи в более позднее время. Если сигнал помещён в очередь, параметры должны быть типов, известных системе метаобъектов Qt, потому что Qt необходимо скопировать аргументы для их хранения в событии.

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

вызовите qRegisterMetaType(), чтобы зарегистрировать тип данных до установления соединения.

Примечание: Эта функция безопасна для потоков.

См. также disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE() и Различия между основанными на строках и функторах подключениями.

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection)

Создаёт соединение заданного type от signal в объекте sender к method в объекте receiver. Возвращает дескриптор соединения, который можно использовать для его последующего отключения.

Дескриптор соединения будет недействительным, если соединение не может быть создано, например, параметры были неверны. Вы можете проверить, является ли QMetaObject::Connection действительным, применив к нему преобразование в bool.

Эта функция работает так же, как connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type), но использует QMetaMethod для указания сигнала и метода.

Эта функция была добавлена в Qt 4.8.

См. также connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).

QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const

Эта функция перегружает connect().

Подключает signal из объекта sender к методу method этого объекта.

Эквивалентно connect(sender, signal, this, method, type).

При каждом создании соединения передаётся сигнал, поэтому дублирующиеся соединения передают два сигнала. Вы можете разорвать соединение с помощью disconnect().

Примечание: Эта функция безопасна для потоков.

См. также disconnect().

[static] QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

Эта функция перегружает connect().

Создаёт соединение заданного type от signal в объекте sender к method в объекте receiver. Возвращает дескриптор соединения, который можно использовать для его последующего отключения.

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

Пример:

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                 label,  &QLabel::setText);

Этот пример гарантирует, что метка всегда отображает текущий текст поля редактирования.

Один сигнал может быть подключён к нескольким слотам и сигналам. Несколько сигналов могут быть подключены к одному слоту.

Если сигнал подключён к нескольким слотам, слоты активируются в том же порядке, в котором они были подключены, при передаче сигнала.

Функция возвращает дескриптор соединения, если сигнал успешно подключён к слоту. Дескриптор соединения будет недействительным, если QObject не может проверить существование signal (если он не был объявлен как сигнал). Вы можете проверить, является ли QMetaObject::Connection действительным, применив к нему преобразование в bool.

По умолчанию, сигнал генерируется для каждого подключенного объекта; для дублирующих подключений генерируются два сигнала. Вы можете разорвать все эти подключения с помощью одного вызова disconnect(). Если вы передадите Qt::UniqueConnection в качестве параметра type, подключение будет выполнено только в случае, если оно не является дубликатом. Если уже существует дубликат (абсолютно тот же сигнал к тому же слоту тех же объектов), подключение завершится ошибкой, а connect вернёт недопустимое значение QMetaObject::Connection.

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

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

убедитесь, что тип аргумента объявлен с помощью Q_DECLARE_METATYPE.

Перегруженные функции могут быть разрешены с помощью qOverload.

Примечание: Эта функция является потокобезопасной.

См. также Различия между подключениями на основе строк и функторов.

[static] QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

Эта функция перегружает connect().

Создаёт подключение от signal в объекте sender к functor и возвращает дескриптор подключения.

Сигнал должен быть функцией, объявленной как сигнал в заголовке. Функция-слот может быть любой функцией или функтором, которые могут быть подключены к сигналу. Функция может быть подключена к заданному сигналу, если у сигнала не меньше аргументов, чем у слота. Функтор может быть подключён к сигналу, если количество аргументов совпадает. Должна существовать неявное преобразование между типами соответствующих аргументов в сигнале и слоте.

Пример:

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, someFunction);

Также могут использоваться лямбда-выражения:

QByteArray page = ...;
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, [=] () {
        socket->write("GET " + page + "\r\n");
    });

Подключение будет автоматически отключено, если отправитель будет уничтожен. Однако вы должны следить, чтобы все объекты, используемые в функторе, оставались активными при отправке сигнала.

Перегруженные функции могут быть разрешены с помощью qOverload.

Примечание: Эта функция является потокобезопасной.

[static] QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

Эта функция перегружает connect().

Создаёт подключение заданного type от signal в объекте sender к functor для размещения в определённой очереди событий context и возвращает дескриптор подключения.

Примечание: Qt::UniqueConnections не работают для лямбда-выражений, нестатических функций и функторов; они применяются только к подключению к методам объектов.

Сигнал должен быть функцией, объявленной как сигнал в заголовке. Функция-слот может быть любой функцией или функтором, которые могут быть подключены к сигналу. Функция может быть подключена к заданному сигналу, если у сигнала не меньше аргументов, чем у слота. Функтор может быть подключён к сигналу, если количество аргументов совпадает. Должна существовать неявное преобразование между типами соответствующих аргументов в сигнале и слоте.

Пример:

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);

Также могут использоваться лямбда-выражения:

QByteArray page = ...;
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
        socket->write("GET " + page + "\r\n");
    }, Qt::AutoConnection);

Подключение будет автоматически отключено, если отправитель или контекст будет уничтожен. Однако вы должны следить, чтобы все объекты, используемые в функторе, оставались активными при отправке сигнала.

Перегруженные функции могут быть разрешены с помощью qOverload.

Примечание: Эта функция является потокобезопасной.

Функция была добавлена в Qt 5.2.

[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)

Этот виртуальный метод вызывается, когда к signal в этом объекте устанавливается подключение.

Если вы хотите сравнить signal с определённым сигналом, вы можете использовать QMetaMethod::fromSignal() следующим образом:

if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
    // signal is valueChanged
}

Предупреждение: Этот метод нарушает объектно-ориентированный принцип модульности. Однако он может быть полезным, когда необходимо выполнить дорогостоящую инициализацию только в случае подключения к сигналу.

Предупреждение: Этот метод вызывается из потока, в котором выполняется подключение, что может быть другим потоком, чем поток, в котором живёт этот объект.

Функция была добавлена в Qt 5.0.

См. также connect() и disconnectNotify().

[virtual protected] void QObject::customEvent(QEvent *event)

Этот обработчик событий может быть переопределён в подклассе для получения пользовательских событий. Пользовательские события — это определяемые пользователем события с типом, значение которого не меньше, чем QEvent::User в перечислении QEvent::Type, и обычно представляют собой подкласс QEvent. Событие передаётся в параметре event.

См. также event() и QEvent.

[slot] void QObject::deleteLater()

Планирует удаление этого объекта.

Объект будет удалён, когда управление вернётся к циклу обработки событий. Если цикл обработки событий не запущен, когда вызвана эта функция (например, deleteLater() вызвана для объекта до QCoreApplication::exec()), объект будет удалён, как только цикл обработки событий будет запущен. Если deleteLater() вызывается после остановки основного цикла обработки событий, объект не будет удалён. Начиная с Qt 4.8, если deleteLater() вызывается для объекта, который живёт в потоке без работающего цикла обработки событий, объект будет уничтожен, когда поток завершит работу.

Обратите внимание, что вход и выход в новый цикл обработки событий (например, открытие модального диалогового окна) не вызовут отложенное удаление; для удаления объекта управление должно вернуться в цикл обработки событий, из которого был вызван deleteLater(). Это не относится к объектам, удалённым во время выполнения предыдущего вложенного цикла обработки событий: цикл обработки событий Qt удалит эти объекты, как только начнётся новый вложенный цикл обработки событий.

Примечание: Безопасно вызывать эту функцию несколько раз; когда будет доставлено первое событие отложенного удаления, все ожидающие события для объекта будут удалены из очереди событий.

См. также destroyed() и QPointer.

[signal] void QObject::destroyed(QObject *obj = nullptr)

Этот сигнал генерируется непосредственно перед уничтожением объекта obj и не может быть заблокирован.

Все дочерние объекты объекта уничтожаются сразу после генерации этого сигнала.

См. также deleteLater() и QPointer.

[static] bool QObject::disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)

Отключает signal в объекте sender от method в объекте receiver. Возвращает true если подключение успешно разорвано; в противном случае возвращает false.

Подключение сигнала-слота удаляется при уничтожении любого из участвующих объектов.

disconnect() обычно используется тремя способами, как показано в следующих примерах.

1. Отключить всё, что подключено к сигналам объекта:

   disconnect(myObject, 0, 0, 0);

   эквивалентно нестатической перегруженной функции

   myObject->disconnect();

2. Отключить всё, что подключено к определённому сигналу:

   disconnect(myObject, SIGNAL(mySignal()), 0, 0);

   эквивалентно нестатической перегруженной функции

   myObject->disconnect(SIGNAL(mySignal()));

3. Отключить определённого получателя:

   disconnect(myObject, 0, myReceiver, 0);

   эквивалентно нестатической перегруженной функции

   myObject->disconnect(myReceiver);

0 может использоваться как символ подстановки, означающий «любой сигнал», «любой получающий объект» или «любой слот в получающем объекте» соответственно.

sender никогда не должен быть равен 0. (Нельзя отключить сигналы от более чем одного объекта в одном вызове.)

Если signal равен 0, он отключает receiver и method от любого сигнала. Если нет, отключается только указанный сигнал.

Если receiver равен 0, он отключает всё, что подключено к signal. Если нет, слоты в объектах, отличных от receiver, не отключаются.

Если method равен 0, он отключает всё, что подключено к receiver. Если нет, отключаются только слоты с именем method, а все остальные слоты остаются на своих местах. method должен быть равен 0, если receiver не указан, поэтому вы не можете отключить конкретный слот на всех объектах.

Примечание: Эта функция является потокобезопасной.

См. также connect().

[static] bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method)

Отключает signal в объекте sender от method в объекте receiver. Возвращает true если подключение успешно разорвано; в противном случае возвращает false.

Эта функция предоставляет те же возможности, что и disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method), но использует QMetaMethod для представления сигнала и метода, подлежащего отключению.

Кроме того, эта функция возвращает false и не отключает сигналы и слоты, если:

1. сигнал не является членом класса отправителя или одного из его родительских классов.
2. метод не является членом класса получателя или одного из его родительских классов.
3. экземпляр сигнала не представляет собой сигнал.

QMetaMethod() может использоваться в качестве универсального символа, обозначающего «любой сигнал» или «любой слот в получающем объекте». Аналогичным образом 0 может использоваться для получателя, обозначая «любой получающий объект». В этом случае метод также должен быть QMetaMethod(). Параметр отправитель никогда не должен быть равен 0.

Эта функция была введена в Qt 4.8.

См. также disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

bool QObject::disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const

Эта функция перегружает disconnect().

Отключает сигнал от метода получателя.

Подключение сигнал-слот удаляется, когда любой из вовлечённых объектов уничтожается.

Примечание: Эта функция безопасна для потоков.

bool QObject::disconnect(const QObject *receiver, const char *method = nullptr) const

Эта функция перегружает disconnect().

Отключает все сигналы в этом объекте от метода получателя.

Подключение сигнал-слот удаляется, когда любой из вовлечённых объектов уничтожается.

[static] bool QObject::disconnect(const QMetaObject::Connection &connection)

Отключить соединение.

Если connection недействительно или уже отключено, ничего не делать и вернуть false.

См. также connect().

[static] bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

Эта функция перегружает функцию diconnect().

Отключает сигнал в объекте отправитель от метода в объекте получатель. Возвращает true, если соединение успешно разорвано; в противном случае возвращает false.

Подключение сигнал-слот удаляется, когда любой из вовлечённых объектов уничтожается.

disconnect() обычно используется тремя способами, как показано в следующих примерах.

1. Отключить всё, подключенное к сигналам объекта:

   disconnect(myObject, 0, 0, 0);

2. Отключить всё, подключенное к определённому сигналу:

   disconnect(myObject, &MyObject::mySignal(), 0, 0);

3. Отключить определённого получателя:

   disconnect(myObject, 0, myReceiver, 0);

4. Отключить соединение от одного определённого сигнала к определённому слоту:

   QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                    label,  &QLabel::setText);

0 может использоваться как универсальный символ, обозначающий «любой сигнал», «любой получающий объект» или «любой слот в получающем объекте» соответственно.

Отправитель никогда не должен быть равен 0. (Вы не можете отключить сигналы более чем одного объекта в одном вызове.)

Если сигнал равен 0, отключает получатель и метод от любого сигнала. В противном случае отключается только указанный сигнал.

Если получатель равен 0, отключает всё, подключенное к сигналу. В противном случае слоты в объектах, отличных от получателя, не отключаются.

Если метод равен 0, отключает всё, что подключено к получателю. В противном случае отключаются только слоты с именем метод, а все другие слоты остаются без изменений. Метод должен быть равен 0, если получатель не указан, поэтому вы не можете отключить конкретный слот во всех объектах.

Примечание: невозможно использовать этот перегруз для отключения сигналов, подключенных к функторам или лямбда-выражениям. Это связано с тем, что сравнить их нельзя. Вместо этого используйте перегруз, принимающий QMetaObject::Connection

Примечание: Эта функция безопасна для потоков.

См. также connect().

[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)

Этот виртуальный метод вызывается, когда что-то было отключено от сигнала в этом объекте.

См. connectNotify(), чтобы узнать, как сравнить сигнал с определённым сигналом.

Если все сигналы были отключены от этого объекта (например, аргумент сигнала в disconnect() был равен 0), disconnectNotify() вызывается только один раз, и сигнал будет недействительным QMetaMethod (QMetaMethod::isValid() возвращает false).

Предупреждение: Этот метод нарушает принципы объектно-ориентированного программирования — модульности. Однако он может быть полезен для оптимизации доступа к дорогим ресурсам.

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

Эта функция была введена в Qt 5.0.

См. также disconnect() и connectNotify().

void QObject::dumpObjectInfo() const

Выводит информацию о подключениях сигналов и т. д. для данного объекта в отладочный вывод.

Примечание: до Qt 5.9 эта функция не была const.

См. также dumpObjectTree().

void QObject::dumpObjectTree() const

Выводит дерево дочерних элементов в отладочный вывод.

Примечание: до Qt 5.9 эта функция не была const.

См. также dumpObjectInfo().

QList<QByteArray> QObject::dynamicPropertyNames() const

Возвращает имена всех свойств, которые были динамически добавлены в объект с помощью setProperty().

Эта функция была введена в Qt 4.2.

[virtual] bool QObject::event(QEvent *e)

Этот виртуальный метод получает события объекта и должен возвращать true, если событие e было распознано и обработано.

Метод event() можно переопределить для настройки поведения объекта.

Убедитесь, что вы вызываете реализацию родительского класса для всех событий, которые вы не обрабатывали.

Пример:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = 0);
    ~MyClass();

    bool event(QEvent* ev) override
    {
        if (ev->type() == QEvent::PolishRequest) {
            // overwrite handling of PolishRequest if any
            doThings();
            return true;
        } else  if (ev->type() == QEvent::Show) {
            // complement handling of Show if any
            doThings2();
            QWidget::event(ev);
            return true;
        }
        // Make sure the rest of events are handled
        return QWidget::event(ev);
    }
};

См. также installEventFilter(), timerEvent(), QCoreApplication::sendEvent() и QCoreApplication::postEvent().

[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)

Фильтрует события, если этот объект был установлен в качестве фильтра событий для объекта watched.

В вашей реализации этого метода, если вы хотите отфильтровать событие event, т. е. остановить его дальнейшую обработку, верните true; в противном случае верните false.

Пример:

class MainWindow : public QMainWindow
{
public:
    MainWindow();

protected:
    bool eventFilter(QObject *obj, QEvent *ev) override;

private:
    QTextEdit *textEdit;
};

MainWindow::MainWindow()
{
    textEdit = new QTextEdit;
    setCentralWidget(textEdit);

    textEdit->installEventFilter(this);
}

bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == textEdit) {
        if (event->type() == QEvent::KeyPress) {
            QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
            qDebug() << "Ate key press" << keyEvent->key();
            return true;
        } else {
            return false;
        }
    } else {
        // pass the event on to the parent class
        return QMainWindow::eventFilter(obj, event);
    }
}

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

Некоторые события, такие как QEvent::ShortcutOverride, необходимо явно принять (вызвав accept() на них), чтобы предотвратить распространение.

Предупреждение: Если вы удалите объект получателя в этой функции, обязательно верните true. В противном случае Qt перенаправит событие на удалённый объект, и программа может завершиться аварийно.

См. также installEventFilter().

T QObject::findChild(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Возвращает дочерний элемент этого объекта, который можно привести к типу T и который называется name, или 0, если такого объекта нет. Опускание аргумента name приводит к сопоставлению всех имён объектов. Поиск выполняется рекурсивно, если options не указывает опцию FindDirectChildrenOnly.

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

В этом примере возвращается дочерний элемент QPushButton объекта parentWidget с именем "button1", даже если кнопка не является непосредственным потомком родителя:

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

В этом примере возвращается дочерний элемент QListWidget объекта parentWidget, его непосредственный родитель:

QListWidget *list = parentWidget->findChild<QListWidget *>();

В этом примере возвращается дочерний элемент QPushButton объекта parentWidget (его непосредственный родитель) с именем "button1":

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

В этом примере возвращается дочерний элемент QListWidget объекта parentWidget, его непосредственный родитель:

QListWidget *list = parentWidget->findChild<QListWidget *>(QString(), Qt::FindDirectChildrenOnly);

См. также findChildren().

QList<T> QObject::findChildren(const QString &name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Возвращает всех потомков этого объекта с заданным именем name, которые можно привести к типу T, или пустой список, если таких объектов нет. Если аргумент name опущен, подбираются все имена объектов. Поиск выполняется рекурсивно, если опция options не указывает на FindDirectChildrenOnly.

Следующий пример демонстрирует, как найти список дочерних QWidget заданного parentWidget с именем widgetname:

QList<QWidget *> widgets = parentWidget.findChildren<QWidget *>("widgetname");

Этот пример возвращает все QPushButton, которые являются потомками parentWidget:

QList<QPushButton *> allPButtons = parentWidget.findChildren<QPushButton *>();

Этот пример возвращает все QPushButton, которые являются непосредственными потомками parentWidget:

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(QString(), Qt::FindDirectChildrenOnly);

См. также findChild().

QList<T> QObject::findChildren(const QRegExp &regExp, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Эта функция перегружает findChildren().

Возвращает потомков этого объекта, которые могут быть приведены к типу T и имена которых соответствуют регулярному выражению regExp, или пустой список, если таких объектов нет. Поиск выполняется рекурсивно, если опция options не указывает на FindDirectChildrenOnly.

QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Эта функция перегружает findChildren().

Возвращает потомков этого объекта, которые могут быть приведены к типу T и имена которых соответствуют регулярному выражению re, или пустой список, если таких объектов нет. Поиск выполняется рекурсивно, если опция options не указывает на FindDirectChildrenOnly.

Функция была добавлена в Qt 5.0.

bool QObject::inherits(const char *className) const

Возвращает true , если этот объект является экземпляром класса, который наследуется от className или подкласса QObject, который наследуется от className; в противном случае возвращает false.

Класс считается наследующим сам себя.

Пример:

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits("QTimer");          // returns true
timer->inherits("QObject");         // returns true
timer->inherits("QAbstractButton"); // returns false

// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject");        // returns true
layout->inherits("QLayoutItem");    // returns true (even though QLayoutItem is not a QObject)

Если вам нужно определить, является ли объект экземпляром определенного класса для целей приведения типов, используйте qobject_cast<Type *>(object) вместо этого.

См. также metaObject() и qobject_cast().

void QObject::installEventFilter(QObject *filterObj)

Устанавливает фильтр событий filterObj для этого объекта. Например:

monitoredObj->installEventFilter(filterObj);

Фильтр событий — это объект, который получает все события, отправленные этому объекту. Фильтр может либо остановить событие, либо переслать его этому объекту. Фильтр событий filterObj получает события через свою функцию eventFilter(). Функция eventFilter() должна возвращать true, если событие должно быть отфильтровано (то есть остановлено); в противном случае она должна возвращать false.

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

Вот класс KeyPressEater, который перехватывает нажатия клавиш контролируемых им объектов:

class KeyPressEater : public QObject
{
    Q_OBJECT
    ...

protected:
    bool eventFilter(QObject *obj, QEvent *event) override;
};

bool KeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        qDebug("Ate key press %d", keyEvent->key());
        return true;
    } else {
        // standard event processing
        return QObject::eventFilter(obj, event);
    }
}

И вот как установить его на два виджета:

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

Например, класс QShortcut использует этот метод для перехвата нажатий клавиш комбинаций.

Предупреждение: Если вы удаляете объект-получатель в своей функции eventFilter(), обязательно возвращайте true. Если вы вернете false, Qt отправит событие удаленному объекту, и программа аварийно завершит работу.

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

См. также removeEventFilter(), eventFilter() и event().

[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const

Возвращает true , если signal подключена хотя бы к одному получателю, в противном случае возвращает false.

signal должна быть сигнатурой члена этого объекта, в противном случае поведение не определено.

static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
if (isSignalConnected(valueChangedSignal)) {
    QByteArray data;
    data = get_the_value();       // expensive operation
    emit valueChanged(data);
}

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

Предупреждение: Эта функция нарушает объектно-ориентированный принцип модульности. Однако она может быть полезной, когда вам нужно выполнить дорогостоящую инициализацию только в том случае, если к какому-либо сигналу подключены подписчики.

Функция была добавлена в Qt 5.0.

bool QObject::isWidgetType() const

Возвращает true , если объект является виджетом; в противном случае возвращает false.

Вызов этой функции эквивалентен вызову inherits("QWidget"), за исключением того, что он намного быстрее.

bool QObject::isWindowType() const

Возвращает true , если объект является окном; в противном случае возвращает false.

Вызов этой функции эквивалентен вызову inherits("QWindow"), за исключением того, что он намного быстрее.

void QObject::killTimer(int id)

Останавливает таймер с идентификатором id.

Идентификатор таймера возвращается функцией startTimer() при запуске события таймера.

См. также timerEvent() и startTimer().

[virtual] const QMetaObject *QObject::metaObject() const

Возвращает указатель на метаобъект этого объекта.

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

Информация о метаобъекте необходима для механизма подключения сигналов/слотов и системы свойств. Функция inherits() также использует метаобъект.

Если у вас нет указателя на экземпляр объекта, но вам все равно нужно получить доступ к метаобъекту класса, вы можете использовать staticMetaObject.

Пример:

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QPushButton::staticMetaObject.className();  // returns "QPushButton"

См. также staticMetaObject.

void QObject::moveToThread(QThread *targetThread)

Изменяет сродство к потоку для этого объекта и его потомков. Объект не может быть перемещен, если у него есть родитель. Обработка событий будет продолжаться в targetThread.

Для перемещения объекта в главную нить используйте QApplication::instance() для получения указателя на текущее приложение, а затем QApplication::thread() для получения потока, в котором приложение существует. Например:

myObject->moveToThread(QApplication::instance()->thread());

Если targetThread равен nullptr, вся обработка событий для этого объекта и его потомков останавливается, поскольку они больше не связаны ни с одним потоком.

Обратите внимание, что все активные таймеры объекта будут сброшены. Таймеры сначала останавливаются в текущем потоке и перезапускаются (с тем же интервалом) в targetThread. В результате постоянное перемещение объекта между потоками может неопределенно откладывать события таймера.

Событие QEvent::ThreadChange отправляется этому объекту непосредственно перед изменением сродства к потоку. Вы можете обработать это событие для выполнения любой специальной обработки. Обратите внимание, что любые новые события, размещенные в этом объекте, будут обрабатываться в targetThread, при условии, что он не равен нулю: когда он равен nullptr, никакая обработка событий для этого объекта или его потомков не может произойти, поскольку они больше не связаны ни с одним потоком.

Предупреждение: Эта функция не является потокобезопасной; текущий поток должен быть таким же, как текущее сродство к потоку. Другими словами, эта функция может только "перемещать" объект из текущего потока в другой, она не может "перетащить" объект из любого произвольного потока в текущий. Однако есть одно исключение из этого правила: объекты без сродства к потоку могут быть "перемещены" в текущий поток.

См. также thread().

[signal] void QObject::objectNameChanged(const QString &objectName)

Этот сигнал излучается после изменения имени объекта. Новое имя объекта передается как objectName.

Примечание: Это частный сигнал. Он может использоваться в подключении сигналов, но не может излучаться пользователем.

Примечание: Сигнал-уведомление для свойства objectName.

См. также QObject::objectName.

QObject *QObject::parent() const

Возвращает указатель на родительский объект.

См. также setParent() и children().

QVariant QObject::property(const char *name) const

Возвращает значение свойства name объекта.

Если такого свойства не существует, возвращаемая переменная недействительна.

Информация обо всех доступных свойствах предоставляется через metaObject() и dynamicPropertyNames().

См. также setProperty(), QVariant::isValid(), metaObject() и dynamicPropertyNames().

[protected] int QObject::receivers(const char *signal) const

Возвращает количество получателей, подключённых к сигналу signal.

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

При вызове этой функции можно использовать макрос SIGNAL() для передачи конкретного сигнала:

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

Предупреждение: Эта функция нарушает объектно-ориентированный принцип модульности. Однако она может быть полезной, когда необходимо выполнить дорогостоящую инициализацию только в том случае, если к сигналу что-то подключено.

См. также isSignalConnected().

void QObject::removeEventFilter(QObject *obj)

Удаляет объект фильтра событий obj из этого объекта. Запрос игнорируется, если такой фильтр событий не был установлен.

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

Удаление фильтра событий всегда безопасно, даже во время активации фильтра событий (т. е. из функции eventFilter()).

См. также installEventFilter(), eventFilter() и event().

[protected] QObject *QObject::sender() const

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

Указатель, возвращённый этой функцией, становится недействительным, если отправитель уничтожен или если слот отключён от сигнала отправителя.

Предупреждение: Эта функция нарушает объектно-ориентированный принцип модульности. Однако доступ к отправителю может быть полезен, когда к одному слоту подключено много сигналов.

Предупреждение: Как упоминалось выше, значение возвращаемого результатом функции недействительно, когда слот вызывается через Qt::DirectConnection из потока, отличного от потока этого объекта. Не используйте эту функцию в таком сценарии.

См. также senderSignalIndex().

[protected] int QObject::senderSignalIndex() const

Возвращает индекс мета-метода сигнала, который вызвал выполняемый в настоящее время слот, являющийся членом класса, возвращённого функцией sender(). Если вызов осуществляется вне слота, активированного сигналом, возвращается -1.

Для сигналов с параметрами по умолчанию эта функция всегда возвращает индекс со всеми параметрами, независимо от того, какой использовался с помощью connect(). Например, у сигнала destroyed(QObject *obj = 0) будут два разных индекса (с параметром и без параметра), но эта функция всегда будет возвращать индекс с параметром. Это не относится к перегрузке сигналов с разными параметрами.

Предупреждение: Эта функция нарушает объектно-ориентированный принцип модульности. Однако доступ к индексу сигнала может быть полезен, когда к одному слоту подключено много сигналов.

Предупреждение: Значение возвращаемого результатом функции недействительно, когда слот вызывается через Qt::DirectConnection из потока, отличного от потока этого объекта. Не используйте эту функцию в таком сценарии.

Функция была добавлена в Qt 4.8.

См. также sender(), QMetaObject::indexOfSignal() и QMetaObject::method().

void QObject::setParent(QObject *parent)

Делает объект дочерним для parent.

См. также parent() и children().

bool QObject::setProperty(const char *name, const QVariant &value)

Устанавливает значение свойства name объекта на value.

Если свойство определено в классе с помощью Q_PROPERTY, то при успехе возвращается true, в противном случае - false. Если свойство не определено с помощью Q_PROPERTY и, следовательно, не указано в метаобъекте, оно добавляется как динамическое свойство, и возвращается false.

Информация обо всех доступных свойствах предоставляется через metaObject() и dynamicPropertyNames().

Динамические свойства можно запросить снова с помощью property(), и их можно удалить, установив значение свойства на недействительную QVariant. Изменение значения динамического свойства вызывает отправку события QDynamicPropertyChangeEvent объекту.

Примечание: Динамические свойства, начинающиеся с «_q_», зарезервированы для внутренних целей.

См. также property(), metaObject(), dynamicPropertyNames() и QMetaProperty::write().

bool QObject::signalsBlocked() const

Возвращает true , если сигналы заблокированы; в противном случае возвращает false.

Сигналы по умолчанию не заблокированы.

См. также blockSignals() и QSignalBlocker.

int QObject::startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer)

Запускает таймер и возвращает идентификатор таймера или ноль, если запустить таймер не удалось.

Событие таймера будет происходить каждые interval миллисекунд до тех пор, пока не будет вызвано killTimer(). Если interval равно 0, событие таймера происходит один раз всякий раз, когда больше нет событий системы окон.

Виртуальная функция timerEvent() вызывается с параметром события QTimerEvent, когда происходит событие таймера. Переопределите эту функцию, чтобы получить события таймера.

Если работает несколько таймеров, QTimerEvent::timerId() можно использовать для определения, какой таймер был активирован.

Пример:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event) override;
};

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{
    startTimer(50);     // 50-millisecond timer
    startTimer(1000);   // 1-second timer
    startTimer(60000);  // 1-minute timer

    using namespace std::chrono;
    startTimer(milliseconds(50));
    startTimer(seconds(1));
    startTimer(minutes(1));

    // since C++14 we can use std::chrono::duration literals, e.g.:
    startTimer(100ms);
    startTimer(5s);
    startTimer(2min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

Обратите внимание, что точность таймера QTimer зависит от базовой операционной системы и оборудования. Аргумент timerType позволяет настроить точность таймера. См. Qt::TimerType для получения информации о различных типах таймеров. Большинство платформ поддерживают точность в 20 миллисекунд; некоторые предоставляют больше. Если Qt не может доставить требуемое количество событий таймера, он будет молча пропускать некоторые.

Класс QTimer предоставляет интерфейс высокого уровня с таймерами однократного действия и сигналами таймера вместо событий. Также есть класс QBasicTimer, который легче, чем QTimer, и менее громоздкий, чем непосредственное использование идентификаторов таймеров.

См. также timerEvent(), killTimer() и QTimer::singleShot().

int QObject::startTimer(std::chrono::milliseconds time, Qt::TimerType timerType = Qt::CoarseTimer)

Это перегруженная функция.

Запускает таймер и возвращает идентификатор таймера или ноль, если запустить таймер не удалось.

Событие таймера будет происходить каждые time интервала до тех пор, пока не будет вызвано killTimer(). Если time равно std::chrono::duration::zero(), событие таймера происходит один раз всякий раз, когда больше нет событий системы окон.

Виртуальная функция timerEvent() вызывается с параметром события QTimerEvent, когда происходит событие таймера. Переопределите эту функцию, чтобы получить события таймера.

Если работает несколько таймеров, QTimerEvent::timerId() можно использовать для определения, какой таймер был активирован.

Пример:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event) override;
};

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{
    startTimer(50);     // 50-millisecond timer
    startTimer(1000);   // 1-second timer
    startTimer(60000);  // 1-minute timer

    using namespace std::chrono;
    startTimer(milliseconds(50));
    startTimer(seconds(1));
    startTimer(minutes(1));

    // since C++14 we can use std::chrono::duration literals, e.g.:
    startTimer(100ms);
    startTimer(5s);
    startTimer(2min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

Обратите внимание, что точность таймера QTimer зависит от базовой операционной системы и оборудования. Аргумент timerType позволяет настроить точность таймера. См. Qt::TimerType для получения информации о различных типах таймеров. Большинство платформ поддерживают точность в 20 миллисекунд; некоторые предоставляют больше. Если Qt не может доставить требуемое количество событий таймера, он будет молча пропускать некоторые.

Класс QTimer предоставляет интерфейс высокого уровня с таймерами однократного действия и сигналами таймера вместо событий. Также есть класс QBasicTimer, который легче, чем QTimer, и менее громоздкий, чем непосредственное использование идентификаторов таймеров.

Функция была добавлена в Qt 5.9.

См. также timerEvent(), killTimer() и QTimer::singleShot().

QThread *QObject::thread() const

Возвращает поток, в котором живёт объект.

См. также moveToThread().

[virtual protected] void QObject::timerEvent(QTimerEvent *event)

Обработчик событий может быть переопределён в подклассе для получения событий таймера для объекта.

QTimer предоставляет интерфейс более высокого уровня для функциональности таймеров, а также более общую информацию о таймерах. Событие таймера передаётся в параметре event.

См. также startTimer(), killTimer() и event().

[static] QString QObject::tr(const char *sourceText, const char *disambiguation = Q_OBJECT, int n = Q_OBJECT)

Возвращает переведённую версию sourceText, необязательно на основе строки disambiguation и значения n для строк, содержащих множественное число; в противном случае возвращает QString::fromUtf8(sourceText), если нет соответствующей переведённой строки.

Пример:

void MainWindow::createActions()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

Если один и тот же sourceText используется в разных ролях в одном и том же контексте, дополнительная идентифицирующая строка может быть передана в disambiguation (по умолчанию 0). В Qt 4.4 и ранее это был предпочтительный способ передачи комментариев переводчикам.

Пример:

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

См. Написание исходного кода для перевода для подробного описания механизмов перевода Qt в целом, а также раздел Разъяснение неоднозначностей для информации о разъяснении неоднозначностей.

Предупреждение: Этот метод является рекурсивным только в том случае, если все переводчики установлены до вызова этого метода. Установка или удаление переводчиков во время выполнения переводов не поддерживается. Это может привести к сбоям или другому нежелательному поведению.

См. также QCoreApplication::translate() и Международные настройки с Qt.

QPushButton::staticMetaObject.className();  // returns "QPushButton"

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QObject *obj = new QTimer;          // QTimer inherits QObject

QTimer *timer = qobject_cast<QTimer *>(obj);
// timer == (QObject *)obj

QAbstractButton *button = qobject_cast<QAbstractButton *>(obj);
// button == 0

class MyClass : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("Author", "Pierre Gendron")
    Q_CLASSINFO("URL", "http://www.my-organization.qc.ca")

public:
    ...
};

class MyClass : public QObject
{
private:
    Q_DISABLE_COPY(MyClass)
};

class MyClass : public QObject
{
private:
    MyClass(const MyClass &) = delete;
    MyClass &operator=(const MyClass &) = delete;
};

QWidget w = QWidget();

class MyClass : public QObject
{
    Q_OBJECT

public:
    MyClass(QObject *parent = 0);
    ~MyClass();

    enum Priority { High, Low, VeryHigh, VeryLow };
    Q_ENUM(Priority)
    void setPriority(Priority priority);
    Priority priority() const;
};

class QLibrary : public QObject
{
    Q_OBJECT

public:
    ...

    enum LoadHint {
        ResolveAllSymbolsHint = 0x01,
        ExportExternalSymbolsHint = 0x02,
        LoadArchiveMemberHint = 0x04
    };
    Q_DECLARE_FLAGS(LoadHints, LoadHint)
    Q_FLAG(LoadHints)
    ...
}

class BasicToolsPlugin : public QObject,
                         public BrushInterface,
                         public ShapeInterface,
                         public FilterInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json")
    Q_INTERFACES(BrushInterface ShapeInterface FilterInterface)

public:
    ...
};

class Window : public QWidget
{
    Q_OBJECT

public:
    Window();
    void normalMethod();
    Q_INVOKABLE void invokableMethod();
};

#include <QObject>

class Counter : public QObject
{
    Q_OBJECT

public:
    Counter() { m_value = 0; }

    int value() const { return m_value; }

public slots:
    void setValue(int value);

signals:
    void valueChanged(int newValue);

private:
    int m_value;
};

Q_PROPERTY(type name
           (READ getFunction [WRITE setFunction] |
            MEMBER memberName [(READ getFunction | WRITE setFunction)])
           [RESET resetFunction]
           [NOTIFY notifySignal]
           [REVISION int]
           [DESIGNABLE bool]
           [SCRIPTABLE bool]
           [STORED bool]
           [USER bool]
           [CONSTANT]
           [FINAL])

Q_PROPERTY(QString title READ title WRITE setTitle USER true)

class Window : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(int normalProperty READ normalProperty)
    Q_PROPERTY(int newProperty READ newProperty REVISION 1)

public:
    Window();
    int normalProperty();
    int newProperty();
public slots:
    void normalMethod();
    Q_REVISION(1) void newMethod();
};

    Window window;
    int expectedRevision = 0;
    const QMetaObject *windowMetaObject = window.metaObject();
    for (int i=0; i < windowMetaObject->methodCount(); i++)
        if (windowMetaObject->method(i).revision() <= expectedRevision)
            exposeMethod(windowMetaObject->method(i));
    for (int i=0; i < windowMetaObject->propertyCount(); i++)
        if (windowMetaObject->property(i).revision() <= expectedRevision)
            exposeProperty(windowMetaObject->property(i));