Класс QObject

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

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

Примечание: Все функции в этом классе являются повторно входящими.

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

• connect()
• connect()
• connect()
• connect()
• connect()
• disconnect()
• disconnect()
• disconnect()
• deleteLater()

Свойства

• objectName : QString

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

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

Сигналы

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

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

Связанные нечленные функции

Макросы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Основным следствием является то, что вы должны использовать указатели на 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);

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

[invokable] QObject::QObject(QObject *parent = nullptr)

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

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

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

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

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

bool QObject::blockSignals(bool block)

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

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

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

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

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

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

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

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

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

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

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

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

const QObjectList &QObject::children() const

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

typedef QList<QObject*> QObjectList;

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

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

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

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

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

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

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

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

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

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

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

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

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

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

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

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

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

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

См. также 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] template <typename PointerToMemberFunction> 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 не может проверить существование сигнала (если он не был объявлен как сигнал). Вы можете проверить, является ли QMetaObject::Connection допустимым, применив к нему преобразование в булево значение.

По умолчанию сигнал испускается для каждого подключения, которое вы создаете; два сигнала испускаются для дублируемых подключений. Вы можете разорвать все эти подключения одним вызовом disconnect(). Если вы передадите Qt::UniqueConnection тип, подключение будет создано только в том случае, если оно не является дубликатом. Если уже существует дубликат (тот же самый сигнал к тому же самому слоту на тех же самых объектах), подключение не удастся, и 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] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

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

Создает подключение от сигнала в объекте 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] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

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

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

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

Пример:

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)

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

Если вы хотите сравнить сигнал со специфическим сигналом, вы можете использовать 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод был добавлен в Qt 5.0.

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

void QObject::dumpObjectInfo() const

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

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

void QObject::dumpObjectTree() 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() на них), чтобы предотвратить распространение.

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

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

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

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

[protected] int QObject::senderSignalIndex() const

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

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

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