Класс QObject

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

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

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

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

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

Свойства

• objectName : QString

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

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

Сигналы

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

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

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

Макросы

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

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

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

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

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

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

По умолчанию, 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 приведена в разделе Использование файла UI 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.

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

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

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

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

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

[slot] void QObject::deleteLater()

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

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

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

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

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

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

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

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

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

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

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

Для каждого дочернего виджета вы получаете одно событие 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)

Создает подключение указанного типа от сигнала в объекте 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().

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

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

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

Пример:

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

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

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

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

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

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

Эта функция была представлена в Qt 5.2.

[virtual protected, 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)

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

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

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

[static] шаблон <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().

шаблон <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().

шаблон <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] шаблон <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));