Класс 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)
• 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)
• disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

Свойства

• objectName : QString

Публичные функции

Публичные слоты

Сигналы

Статические публичные члены

Protected Functions

Related Non-Members

Macros

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

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

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

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

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

Привязка к потоку

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Локализация (I18n)

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

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

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

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

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

QObject::QObject(QObject *parent = Q_NULLPTR)

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

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

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

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

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

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

См. также 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 для указания сигнала и метода.

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

[static] QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

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

Создаёт соединение от signal в объекте sender к functor и возвращает дескриптор соединения.

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

Пример:

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

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

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

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

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

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

[static] QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

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

Создаёт соединение заданного типа от 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.

[slot] void QObject::deleteLater()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   disconnect(myObject, 0, 0, 0);

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

   myObject->disconnect();

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

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

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

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

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

   disconnect(myObject, 0, myReceiver, 0);

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

   myObject->disconnect(myReceiver);

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

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

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

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

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

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

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

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

Отключает signal в объекте sender от method в объекте receiver. Возвращает true если соединение успешно разорвано; в противном случае возвращает disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   disconnect(myObject, 0, 0, 0);

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

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

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

   disconnect(myObject, 0, myReceiver, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void QObject::dumpObjectInfo() const

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

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

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

void QObject::dumpObjectTree() const

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

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

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

QList<QByteArray> QObject::dynamicPropertyNames() const

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

Этот метод был введён в Qt 4.2.

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

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

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

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

Пример:

class MyClass : public QWidget
{
    Q_OBJECT

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

    bool event(QEvent* ev)
    {
        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);

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() для своих внутренних целей.

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

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

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

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

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

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

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

Этот пример возвращает дочерний QListWidget объекта parentWidget:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QList<T> QObject::findChildren(const QRegExp &regExp, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

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

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

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

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

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

Объекту отправляется событие QEvent::ThreadChange непосредственно перед изменением сродства потока. Вы можете обработать это событие, чтобы выполнить любую специальную обработку. Обратите внимание, что любые новые события, которые будут отправлены этому объекту, будут обработаны в targetThread.

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

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

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

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

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

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

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

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

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

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

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

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

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

[protected] int QObject::senderSignalIndex() const

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

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

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

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

Функция была введена в Qt 4.8.

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

void QObject::setParent(QObject *parent)

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

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

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

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

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

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

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

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

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

bool QObject::signalsBlocked() const

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

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

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

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

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

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

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

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

Пример:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event);
};

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{
    startTimer(50);     // 50-millisecond timer
    startTimer(1000);   // 1-second timer
    startTimer(60000);  // 1-minute timer

    using namespace std::chrono;
    startTimer(milliseconds(50));
    startTimer(seconds(1));
    startTimer(minutes(1));

    // since C++14 we can use std::chrono::duration literals, e.g.:
    startTimer(100ms);
    startTimer(5s);
    startTimer(2min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

Обратите внимание, что точность QTimer зависит от используемой операционной системы и оборудования. Аргумент timerType позволяет настроить точность таймера. См. Qt::TimerType для получения информации о различных типах таймеров. Большинство платформ поддерживают точность в 20 миллисекунд; некоторые предоставляют больше. Если Qt не может доставить запрошенное количество событий таймера, оно молча отбросит некоторые из них.

Класс QTimer предоставляет интерфейс высокого уровня с таймерами единственного запуска и сигналами таймера вместо событий. Также существует класс QBasicTimer, который легче QTimer и менее громоздкий, чем прямое использование идентификаторов таймеров.

См. также timerEvent(), killTimer() и QTimer::singleShot().

int QObject::startTimer(std::chrono::milliseconds time, Qt::TimerType timerType = Qt::CoarseTimer)

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

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

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

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

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

Пример:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event);
};

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 = Q_NULLPTR, int n = -1)

Возвращает переведённую версию sourceText, необязательно на основе строки disambiguation и значения n для строк, содержащих множественное число; в противном случае возвращает QString::fromUtf8(sourceText), если нет соответствующей переведённой строки.

Пример:

void MainWindow::createActions()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

Если один и тот же sourceText используется в разных ролях в одном контексте, может быть передана дополнительная идентифицирующая строка в disambiguation (по умолчанию 0). В Qt 4.4 и более ранних версиях это был предпочтительный способ передачи комментариев переводчикам.

Пример:

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

См. Написание исходного кода для перевода для подробного описания механизмов перевода Qt, а также раздел Разъяснение неоднозначностей для получения информации о разъяснении неоднозначностей.

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

См. также QCoreApplication::translate() и Международные возможности Qt.

QPushButton::staticMetaObject.className();  // returns "QPushButton"

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QObject *obj = new QTimer;          // QTimer inherits QObject

QTimer *timer = qobject_cast<QTimer *>(obj);
// timer == (QObject *)obj

QAbstractButton *button = qobject_cast<QAbstractButton *>(obj);
// button == 0

class MyClass : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("Author", "Pierre Gendron")
    Q_CLASSINFO("URL", "http://www.my-organization.qc.ca")

public:
    ...
};

class MyClass : public QObject
{

  private:
    Q_DISABLE_COPY(MyClass)
};

class MyClass : public QObject
{

  private:
     MyClass(const MyClass &);
     MyClass &operator=(const MyClass &);
};

  QWidget w = QWidget();

class MyClass : public QObject
{
    Q_OBJECT

public:
    MyClass(QObject *parent = 0);
    ~MyClass();

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

class QLibrary : public QObject
{
    Q_OBJECT

public:
    ...

    enum LoadHint {
        ResolveAllSymbolsHint = 0x01,
        ExportExternalSymbolsHint = 0x02,
        LoadArchiveMemberHint = 0x04
    };
    Q_DECLARE_FLAGS(LoadHints, LoadHint)
    Q_FLAG(LoadHints)
    ...
}

class BasicToolsPlugin : public QObject,
                         public BrushInterface,
                         public ShapeInterface,
                         public FilterInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json")
    Q_INTERFACES(BrushInterface ShapeInterface FilterInterface)

public:
    ...
};

class Window : public QWidget
{
    Q_OBJECT

public:
    Window();
    void normalMethod();
    Q_INVOKABLE void invokableMethod();
};

#include <QObject>

class Counter : public QObject
{
    Q_OBJECT

public:
    Counter() { m_value = 0; }

    int value() const { return m_value; }

public slots:
    void setValue(int value);

signals:
    void valueChanged(int newValue);

private:
    int m_value;
};

Q_PROPERTY(type name
           (READ getFunction [WRITE setFunction] |
            MEMBER memberName [(READ getFunction | WRITE setFunction)])
           [RESET resetFunction]
           [NOTIFY notifySignal]
           [REVISION int]
           [DESIGNABLE bool]
           [SCRIPTABLE bool]
           [STORED bool]
           [USER bool]
           [CONSTANT]
           [FINAL])

Q_PROPERTY(QString title READ title WRITE setTitle USER true)

class Window : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(int normalProperty READ normalProperty)
    Q_PROPERTY(int newProperty READ newProperty REVISION 1)

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

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