Класс QObject

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

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

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

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

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

Свойства

• objectName : QString

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

Public Slots

Signals

Static Public Members

Protected Functions

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

Макросы

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

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

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

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

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

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

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

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

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

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

Аффинити потока

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Международная локализация (I18n)

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

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

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

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

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

QObject::QObject(QObject *parent = nullptr)

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

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

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

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

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

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

[slot] void QObject::deleteLater()

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

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

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

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

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

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

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

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

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

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

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

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

const QObjectList &QObject::children() const

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

typedef QList<QObject*> QObjectList;

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

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

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

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

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

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

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

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

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

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

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Отключает 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] шаблон <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void QObject::dumpObjectInfo() const

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

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

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

void QObject::dumpObjectTree() const

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

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

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

QList<QByteArray> QObject::dynamicPropertyNames() const

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

Этот метод был представлен в Qt 4.2.

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

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

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

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

Пример:

class MyClass : public QWidget
{
    Q_OBJECT

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

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

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

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

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

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

Пример:

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

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

private:
    QTextEdit *textEdit;
};

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

    textEdit->installEventFilter(this);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В этом примере возвращаются все QPushButton являющиеся дочерними элементами объекта parentWidget:

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

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

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

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

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

Этот метод перегружает findChildren().

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

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

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

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

Класс считается, что он наследует самого себя.

Пример:

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

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

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

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

void QObject::installEventFilter(QObject *filterObj)

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

monitoredObj->installEventFilter(filterObj);

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

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

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

class KeyPressEater : public QObject
{
    Q_OBJECT
    ...

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

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

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

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

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

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

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

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

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

[protected] 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.

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

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

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

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

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

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

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

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

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

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

void QObject::removeEventFilter(QObject *obj)

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

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

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

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

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

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

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

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

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

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

[protected] int QObject::senderSignalIndex() const

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

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

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

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

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

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

void QObject::setParent(QObject *parent)

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

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

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

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

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

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

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

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

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

bool QObject::signalsBlocked() const

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

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

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

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

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

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

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

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

Пример:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 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().

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

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]
           [DESIGNABLE bool]
           [SCRIPTABLE bool]
           [STORED bool]
           [USER bool]
           [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 1)

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

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