Класс 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)
• deleteLater()

Свойства

• objectName : QString

Открытые функции

Открытые слоты

Сигналы

Статические открытые члены

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

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

Макросы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

uic генерирует код, который вызывает эту функцию для включения автоподключения между виджетами на формах, созданных с помощью Qt Designer. Дополнительная информация об использовании автоподключения с Qt Designer приведена в разделе «Использование файла UI 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.

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

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

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

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

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

[slot] void QObject::deleteLater()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[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, конструкция дочернего элемента обычно завершена. Однако это не гарантируется, и несколько событий полировки могут быть доставлены во время выполнения конструктора виджета.

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

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

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

const QObjectList &QObject::children() const

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

typedef QList<QObject*> QObjectList;

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

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

См. также 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() и SLOT() при указании signal и method, например:

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.

[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);

   эквивалентно перегруженной функции без модификатора static

   myObject->disconnect();

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

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

   эквивалентно перегруженной функции без модификатора static

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

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

   disconnect(myObject, 0, myReceiver, 0);

   эквивалентно перегруженной функции без модификатора static

   myObject->disconnect(myReceiver);

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

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

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

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

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

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

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

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

Отключает сигнал в объекте отправитель от метода в объекте получатель. Возвращает 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 может использоваться в качестве символа подстановки, означающего «любой сигнал», «любой принимающий объект» или «любой слот в принимающем объекте» соответственно.

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

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

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

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

Примечание: Невозможно использовать этот перегруз, чтобы отключить сигналы, подключенные к функциям-обработчикам или лямбда-выражениям. Это связано с тем, что их нельзя сравнить. Вместо этого используйте перегруз, который принимает 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, или nullptr , если такого объекта нет. Пропуск аргумента 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 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, при условии, что он не равен null: если он nullptr, обработка событий для этого объекта или его дочерних элементов не может происходить, поскольку они больше не связаны с каким-либо потоком.

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

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

QObject *QObject::parent() const

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

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

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

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

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

Информация обо всех доступных свойствах предоставляется через 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 = nullptr, int n = -1)

Возвращает переведённую версию 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));