Класс 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

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

Public Slots

Signals

Static Public Members

Protected Functions

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

Макросы

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

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 предоставляет базовую поддержку таймеров; см. QTimer для поддержки таймеров высокого уровня.

Обратите внимание, что макрос Q_OBJECT является обязательным для любого объекта, реализующего сигналы, слоты или свойства. Вам также необходимо запустить компилятор метаобъектов (MOC) на исходном файле. Мы настоятельно рекомендуем использовать этот макрос во всех подклассах 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() завершится неудачно, если два QObjects обитают в разных потоках.
• Когда 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 можно найти в разделе Использование файла пользовательского интерфейса 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 является родителем кнопок ОК и Отмена, которые оно содержит.

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

Установление 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.

[private 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 истинно, сигналы, излучаемые этим объектом, блокируются (т.е., излучение сигнала не вызовет ничего связанного с ним). Если block ложно, никакой такой блокировки не будет.

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

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

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

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

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

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

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

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

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

Событие ChildPolished пропускается, если дочерний элемент удаляется сразу после добавления. Если дочерний элемент полируется несколько раз во время создания и уничтожения, вы можете получить несколько событий 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)

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

Вы должны использовать макросы 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 не может проверить существование сигнала или метода, или если их сигнатуры несовместимы. Вы можете проверить, является ли дескриптор допустимым, приведён его к типу 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)

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

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

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

См. также 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().

Подключает сигнал от объекта sender к методу этого объекта.

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Функция возвращает дескриптор соединения, если сигнал успешно подключён к слоту. Дескриптор соединения будет недопустимым, если не удалось создать подключение, например, если QObject не может проверить существование сигнала (если он не объявлен как сигнал). Вы можете проверить, является ли 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] шаблон <typename PointerToMemberFunction, typename Functor> 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, since 5.2] шаблон <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

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

Создаёт соединение заданного типа от 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, since 5.0] 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, nullptr, nullptr, nullptr);

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

   myObject->disconnect();

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

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

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

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

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

   disconnect(myObject, nullptr, myReceiver, nullptr);

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

   myObject->disconnect(myReceiver);

nullptr может использоваться в качестве универсального значения, обозначающего "любой сигнал", "любой объект-получатель" или "любой слот в объекте-получателе", соответственно.

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

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

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

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

Примечание: Отключение всех соединений сигнал-слот также отключит сигнал QObject::destroyed(), если он подключен. Это может негативно сказаться на классах, которые полагаются на этот сигнал для очистки ресурсов. Рекомендуется отключить только те конкретные сигналы, которые были подключены кодом приложения.

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

См. также 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. signal не является членом класса sender или одного из его родительских классов.
2. method не является членом класса receiver или одного из его родительских классов.
3. signal не представляет собой сигнал.

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

Примечание: Отключение всех соединений сигнал-слот также отключит сигнал QObject::destroyed(), если он подключен. Это может негативно сказаться на классах, которые полагаются на этот сигнал для очистки ресурсов. Рекомендуется отключить только те конкретные сигналы, которые были подключены кодом приложения.

См. также 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().

Отключает signal от method объекта receiver.

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

Примечание: Отключение всех соединений сигнал-слот также отключит сигнал QObject::destroyed(), если он подключен. Это может негативно сказаться на классах, которые полагаются на этот сигнал для очистки ресурсов. Рекомендуется отключить только те конкретные сигналы, которые были подключены кодом приложения.

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

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

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

Отключает все сигналы из этого объекта от method объекта receiver.

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

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

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

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

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

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

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

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

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

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

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

   disconnect(myObject, nullptr, nullptr, nullptr);

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

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

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

   disconnect(myObject, nullptr, myReceiver, nullptr);

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

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

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

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

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

Если receiver nullptr, он отключает всё, подключенное к signal. В противном случае отключаются только слоты в указанном получателе. disconnect() с ненулевым receiver также отключает функции слотов, которые были подключены с receiver как объектом контекста.

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

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

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

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

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

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

См. connectNotify() для примера сравнения signal с конкретным сигналом.

Если все сигналы были отключены от этого объекта (например, аргумент сигнала в disconnect() был nullptr), disconnectNotify() вызывается только один раз, и signal будет недействительным 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().

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

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

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

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

Пример:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = nullptr);
    ~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().

template <typename T> 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().

template <typename T> 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().

[since 5.0] template <typename T> 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, since 5.0] 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: когда он nullptr, никакая обработка событий для этого объекта или его потомков не может произойти, так как они больше не ассоциированы ни с каким потоком.

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

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

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 = \nullptr) будет иметь два разных индекса (с параметром и без параметра), но эта функция всегда будет возвращать индекс с параметром. Это не относится к перегрузке сигналов с разными параметрами.

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

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

См. также 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 = nullptr);

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().

[since 5.9] 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 = nullptr);

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 (nullptr по умолчанию). В 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 == nullptr

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 = nullptr);
    ~MyClass();

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

class QItemSelectionModel : public QObject
{
    Q_OBJECT

public:
    ...
    enum SelectionFlag {
        NoUpdate       = 0x0000,
        Clear          = 0x0001,
        Select         = 0x0002,
        Deselect       = 0x0004,
        Toggle         = 0x0008,
        Current        = 0x0010,
        Rows           = 0x0020,
        Columns        = 0x0040,
        SelectCurrent  = Select | Current,
        ToggleCurrent  = Toggle | Current,
        ClearAndSelect = Clear | Select
    };

    Q_DECLARE_FLAGS(SelectionFlags, SelectionFlag)
    Q_FLAG(SelectionFlags)
    ...
}

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();
};

// Put this in your code and the generated code will include this header.
Q_MOC_INCLUDE("myheader.h")

namespace test {
Q_NAMESPACE
...

namespace test {
Q_NAMESPACE_EXPORT(EXPORT_MACRO)
...

#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 | REVISION(int[, int])]
           [DESIGNABLE bool]
           [SCRIPTABLE bool]
           [STORED bool]
           [USER bool]
           [BINDABLE bindableProperty]
           [CONSTANT]
           [FINAL]
           [REQUIRED])

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(2, 1))

public:
    Window();
    int normalProperty();
    int newProperty();
public slots:
    void normalMethod();
    Q_REVISION(2, 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));