Определение типов QML из C++
При расширении QML с помощью кода C++, класс C++ может быть зарегистрирован в системе типов QML, что позволит использовать класс в качестве типа данных в коде QML. В то время как свойства, методы и сигналы любого класса, производного от QObject, доступны из QML, как обсуждается в Размещение атрибутов типов C++ в QML, такой класс не может быть использован как тип данных из QML, пока он не зарегистрирован в системе типов. Кроме того, регистрация может предоставить другие возможности, такие как возможность использования класса в качестве порождаемого типа QML-объекта из QML или возможность импорта и использования единственного экземпляра класса из QML.
Кроме того, модуль Qt QML предоставляет механизмы для реализации QML-специфических функций, таких как прикреплённые свойства и свойства по умолчанию, в C++.
(Обратите внимание, что ряд важных концепций, рассматриваемых в этом документе, демонстрируются в учебнике по написанию расширений QML с C++.)
Регистрация типов C++ в системе типов QML
Класс, производный от QObject, может быть зарегистрирован в системе типов QML, чтобы позволить использовать тип в качестве типа данных в коде QML.
Движок позволяет регистрировать как порождаемые, так и непорождаемые типы. Регистрация порождаемого типа позволяет использовать класс C++ в качестве определения типа QML-объекта, позволяя использовать его в объявлениях объектов из кода QML для создания объектов этого типа. Регистрация также предоставляет движку дополнительные метаданные о типе, позволяя использовать тип (и любые перечисления, объявленные классом) в качестве типа данных для значений свойств, параметров методов и значений возврата, а также параметров сигналов, которые обмениваются между QML и C++.
Регистрация непорождаемого типа также регистрирует класс как тип данных таким образом, но тип не может быть использован для создания QML-объектов из QML. Это полезно, например, если тип имеет перечисления, которые должны быть доступны QML, но сам тип не должен быть порождаемым.
Для быстрого руководства по выбору правильного подхода к экспонированию типов C++ в QML, см. Выбор правильного метода интеграции между C++ и QML.
Регистрация порождаемого типа объекта
Любой класс C++, производный от QObject, может быть зарегистрирован в качестве определения QML-типа объекта. После регистрации класса в системе типов QML класс можно объявлять и создавать, как любой другой тип объекта из кода QML. После создания экземпляр класса можно манипулировать из QML; как объясняется в Размещении атрибутов типов C++ в QML, свойства, методы и сигналы любого класса, производного от QObject, доступны из кода QML.
Для регистрации класса, производного от QObject, как порождаемого QML-типа объекта, вызовите qmlRegisterType(), чтобы зарегистрировать класс как тип QML в определенном пространстве имен типа. Затем клиенты могут импортировать это пространство имен для использования типа.
Например, предположим, что существует класс Message со свойствами author и creationDate.
class Message : public QObject
{
Q_OBJECT
Q_PROPERTY(QString author READ author WRITE setAuthor NOTIFY authorChanged)
Q_PROPERTY(QDateTime creationDate READ creationDate WRITE setCreationDate NOTIFY creationDateChanged)
public:
// ...
}; Этот тип можно зарегистрировать, вызвав qmlRegisterType() с соответствующим пространством имен типа и номером версии. Например, чтобы сделать тип доступным в пространстве имен com.mycompany.messaging с версией 1.0:
qmlRegisterType<Message>("com.mycompany.messaging", 1, 0, "Message"); Тип может быть использован в объявлении объекта из QML, и его свойства могут быть читаемыми и записываемыми, как показано в примере ниже:
import com.mycompany.messaging 1.0
Message {
author: "Amelie"
creationDate: new Date()
} Регистрация непорождаемых типов
Иногда класс, производный от QObject, может потребоваться зарегистрировать в системе типов QML, но не как порождаемый тип. Например, это происходит, если класс C++:
- является типом интерфейса, который не должен быть порождаемым
- является типом базового класса, который не нужно экспонировать в QML
- объявляет некоторое перечисление, которое должно быть доступно из QML, но иначе не должно быть порождаемым
- является типом, который должен предоставляться QML через экземпляр одиночки и не должен быть порождаемым из QML
Модуль Qt QML предоставляет несколько методов для регистрации непорождаемых типов:
- qmlRegisterType() (без параметров) регистрирует тип C++, который не порождаем и не может быть указан в QML. Это позволяет движку принудительно преобразовывать любые наследуемые типы, которые порождаемы из QML.
- qmlRegisterInterface() регистрирует существующий тип интерфейса Qt. Тип не порождаем из QML, и вы не можете объявлять QML-свойства с ним. Использование C++ свойств этого типа из QML будет выполнять ожидаемые преобразования интерфейса.
- qmlRegisterUncreatableType() регистрирует именованный тип C++, который не порождаем, но должен быть идентифицируемым как тип для системы типов QML. Это полезно, если перечисления или прикреплённые свойства типа должны быть доступны из QML, но сам тип не должен быть порождаемым.
- qmlRegisterSingletonType() регистрирует тип-одиночку, который можно импортировать из QML, как описано ниже.
Обратите внимание, что все типы C++, зарегистрированные в системе типов QML, должны быть производными от QObject, даже если они не порождаемы.
Регистрация объектов-одиночек с типом-одиночкой
Тип-одиночка позволяет экспонировать свойства, сигналы и методы в пространстве имен без необходимости ручного создания экземпляра объекта клиентом. QObject типы-одиночки, в частности, являются эффективным и удобным способом предоставления функциональности или глобальных значений свойств.
Обратите внимание, что типы-одиночки не имеют связанного QQmlContext, так как они совместно используются всеми контекстами в движке. Экземпляры QObject типов-одиночек создаются и владеются QQmlEngine и будут уничтожены при уничтожении движка.
С типом-одиночкой QObject можно взаимодействовать аналогично любому другому QObject или порождаемому типу, за исключением того, что существует только один экземпляр (созданный и владеящийся движком), и к нему необходимо обращаться по имени типа, а не по идентификатору. Свойства Q_PROPERTY QObject типов-одиночек могут быть связаны, и функции Q_INVOKABLE модулей API QObject могут использоваться в выражениях обработчиков сигналов. Это делает типы-одиночки идеальным способом реализации стилей или тем, и они также могут использоваться вместо импорта скриптов ".pragma library" для хранения глобального состояния или предоставления глобальной функциональности.
После регистрации тип-одиночка QObject можно импортировать и использовать, как любой другой экземпляр QObject, экспонированный QML. Следующий пример предполагает, что тип-одиночка QObject был зарегистрирован в пространстве имен "MyThemeModule" с версией 1.0, где у этого QObject есть свойство QColor "color":
import MyThemeModule 1.0 as Theme
Rectangle {
color: Theme.color // binding.
} QJSValue также можно экспонировать как тип-одиночку, однако клиенты должны понимать, что свойства такого типа-одиночки не могут быть связаны.
См. qmlRegisterSingletonType() для получения дополнительной информации о том, как реализовать и зарегистрировать новый тип-одиночку и как использовать существующий тип-одиночку.
Примечание: Значения перечислений для зарегистрированных типов в QML должны начинаться с заглавной буквы.
Ревизии и версии типов
Многие функции регистрации типов требуют указания версий зарегистрированного типа. Ревизии и версии типов позволяют добавлять новые свойства или методы в новой версии, сохраняя совместимость с предыдущими версиями.
Рассмотрим два файла QML:
// main.qml
import QtQuick 1.0
Item {
id: root
MyType {}
} // MyType.qml
import MyTypes 1.0
CppType {
value: root.x
} где CppType отображается на класс C++ CppType.
Если автор CppType добавит свойство root к CppType в новой версии своего определения типа, root.x теперь отображает другое значение, потому что root также является id верхнего уровня компонента. Автор может указать, что новое свойство root доступно с определённой дополнительной версией. Это позволяет добавлять новые свойства и функции к существующим типам без нарушения работы существующих программ.
Тег REVISION используется для пометки свойства root как добавленного в ревизии 1 типа. Методы, такие как Q_INVOKABLE, сигналы и слоты также могут быть помечены для ревизии с помощью макроса Q_REVISION(x):
class CppType : public BaseType
{
Q_OBJECT
Q_PROPERTY(int root READ root WRITE setRoot NOTIFY rootChanged REVISION 1)
signals:
Q_REVISION(1) void rootChanged();
}; Для регистрации новой ревизии класса в определенной версии используется следующая функция:
template<typename T, int metaObjectRevision> int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
Для регистрации CppType версии 1 для MyTypes 1.1:
qmlRegisterType<CppType,1>("MyTypes", 1, 1, "CppType") root доступно только при импорте MyTypes версии 1.1.
По этой же причине новые типы, введённые в более поздних версиях, должны использовать аргумент дополнительной версии функции qmlRegisterType.
Эта особенность языка позволяет вносить изменения в поведение без нарушения работы существующих приложений. Следовательно, авторы модулей QML всегда должны документировать, что изменилось между дополнительными версиями, и пользователи модулей QML должны проверять, что их приложение всё ещё работает корректно, прежде чем развернуть обновлённую строку импорта.
Вы также можете зарегистрировать ревизию базового класса, от которого зависит ваш тип, с помощью функции qmlRegisterRevision():
template<typename T, int metaObjectRevision> int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor) template<typename T, int metaObjectRevision> int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason) template<typename T, typename E, int metaObjectRevision> int qmlRegisterExtendedUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)
Например, если BaseType изменён и теперь имеет ревизию 1, вы можете указать, что ваш тип использует новую ревизию:
qmlRegisterRevision<BaseType,1>("MyTypes", 1, 1); Это полезно при наследовании от базовых классов, предоставляемых другими авторами, например, при расширении классов из модуля Qt Quick.
Примечание: Движок QML не поддерживает ревизии для свойств или сигналов групповых и прикреплённых объектов свойств.
Регистрация объектов расширения
При интеграции существующих классов и технологий в QML API часто требуют корректировки для лучшего соответствия декларативной среде. Хотя лучшие результаты обычно достигаются путём прямого изменения исходных классов, если это невозможно или усложняется другими проблемами, объекты расширения позволяют ограничить возможности расширения без прямых изменений.
Объекты расширения добавляют дополнительные свойства к существующему типу. Объекты расширения могут только добавлять свойства, а не сигналы или методы. Определение расширяемого типа позволяет программисту предоставить дополнительный тип, известный как тип расширения, при регистрации класса. Свойства прозрачно объединяются с исходным целевым классом при использовании из QML. Например:
QLineEdit {
leftMargin: 20
} Свойство leftMargin является новым свойством, добавленным к существующему типу C++, QLineEdit, без изменения исходного кода.
Функция qmlRegisterExtendedType() предназначена для регистрации расширенных типов. Обратите внимание, что она имеет два варианта.
template<typename T, typename ExtendedT> int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor, const char *qmlName) template<typename T, typename ExtendedT> int qmlRegisterExtendedType()
Эти функции следует использовать вместо обычных qmlRegisterType() вариантов. Аргументы идентичны соответствующим функциям регистрации без расширения, за исключением параметра ExtendedT, который представляет тип объекта расширения.
Класс расширения — это обычный QObject с конструктором, принимающим указатель на QObject. Однако создание класса расширения откладывается до первого доступа к расширенному свойству. Класс расширения создается, а целевой объект передается в качестве родителя. При доступе к свойству в оригинале вместо него используется соответствующее свойство в объекте расширения.
Пример объектов расширения демонстрирует использование объектов расширения.
Определение типов и атрибутов QML
Предоставление присоединенных свойств
В синтаксисе языка QML существует понятие присоединенных свойств и присоединенных обработчиков сигналов, которые являются дополнительными атрибутами, присоединенными к объекту. По существу, такие атрибуты реализуются и предоставляются типом присоединения, и эти атрибуты могут быть присоединены к объекту другого типа. Это контрастирует с обычными свойствами объектов, которые предоставляются самим типом объекта (или наследуемым типом объекта).
Например, Item ниже использует присоединенные свойства и присоединенные обработчики:
import QtQuick 2.0
Item {
width: 100; height: 100
focus: true
Keys.enabled: false
Keys.onReturnPressed: console.log("Return key was pressed")
} Здесь объект Item может получить доступ к значениям Keys.enabled и Keys.onReturnPressed и установить их. Это позволяет объекту Item получать доступ к этим дополнительным атрибутам как расширению его собственных существующих атрибутов.
Шаги по реализации присоединенных объектов
При рассмотрении вышеприведенного примера участвуют несколько сторон:
- Существует экземпляр анонимного типа присоединенного объекта с
enabledи сигналомreturnPressed, который был присоединен к объекту Item, чтобы позволить ему получать доступ к этим атрибутам и устанавливать их. - Объект Item является присоединяемым объектом, к которому был присоединен экземпляр типа присоединенного объекта.
- Keys является типом присоединения, который предоставляет присоединяемому объекту именованную квалификацию «Keys», через которую он может получить доступ к атрибутам типа присоединенного объекта.
При обработке этого кода движком QML создается один экземпляр типа присоединенного объекта и присоединяется к объекту Item, тем самым предоставляя ему доступ к атрибутам enabled и returnPressed экземпляра.
Механизмы предоставления присоединенных объектов могут быть реализованы из C++ путем предоставления классов для типа присоединенного объекта и типа присоединения. Для типа присоединенного объекта предоставьте класс, производный от QObject, который определяет атрибуты, которые должны быть доступны объектам присоединяемого объекта. Для типа присоединения предоставьте класс, производный от QObject, который:
- реализует статический qmlAttachedProperties() со следующим сигнатурой:
static <AttachedPropertiesType> *qmlAttachedProperties(QObject *object);
Этот метод должен возвращать экземпляр типа присоединенного объекта.
Движок QML вызывает этот метод для присоединения экземпляра типа присоединенного объекта к присоединяемому объекту, указанному параметром
object. Обычно, хотя и не обязательно, эта реализация метода родит возвращаемый экземпляр кobject, чтобы предотвратить утечки памяти.Этот метод вызывается движком не более одного раза для каждого экземпляра объекта присоединения, так как движок кэширует возвращаемый указатель на экземпляр для последующего доступа к присоединенному свойству. Следовательно, объект присоединения может быть удален только после того, как объект присоединения
objectбудет уничтожен. - объявляется как тип присоединения, вызывая макрос QML_DECLARE_TYPEINFO() с флагом QML_HAS_ATTACHED_PROPERTIES
Реализация присоединенных объектов: пример
Например, рассмотрим тип Message, описанный в предыдущем примере:
class Message : public QObject
{
Q_OBJECT
Q_PROPERTY(QString author READ author WRITE setAuthor NOTIFY authorChanged)
Q_PROPERTY(QDateTime creationDate READ creationDate WRITE setCreationDate NOTIFY creationDateChanged)
public:
// ...
}; Предположим, необходимо вызвать сигнал на Message при публикации его на доске сообщений, а также отслеживать, когда сообщение истекает на доске сообщений. Поскольку добавление этих атрибутов напрямую к Message не имеет смысла, так как атрибуты более релевантны контексту доски сообщений, их можно реализовать как присоединенные атрибуты к объекту Message с квалификатором «MessageBoard». В терминах концепций, описанных ранее, здесь участвуют следующие стороны:
- Экземпляр анонимного типа присоединенного объекта, который предоставляет сигнал
publishedи свойство expired. Этот тип реализован вMessageBoardAttachedTypeниже - Объект
Message— присоединяемый объект - Тип
MessageBoard— тип присоединения, который используется объектамиMessageдля доступа к присоединенным атрибутам
Ниже приведен пример реализации. Сначала должен быть тип присоединенного объекта с необходимыми свойствами и сигналами, которые будут доступны присоединяемому объекту:
class MessageBoardAttachedType : public QObject
{
Q_OBJECT
Q_PROPERTY(bool expired READ expired WRITE expired NOTIFY expiredChanged)
public:
MessageBoardAttachedType(QObject *parent);
bool expired() const;
void setExpired(bool expired);
signals:
void published();
void expiredChanged();
}; Затем тип присоединения, MessageBoard, должен объявить метод qmlAttachedProperties(), который возвращает экземпляр типа присоединенного объекта, как реализовано в MessageBoardAttachedType. Кроме того, Message board должен быть объявлен как тип присоединения с помощью макроса QML_DECLARE_TYPEINFO:
class MessageBoard : public QObject
{
Q_OBJECT
public:
static MessageBoard *qmlAttachedProperties(QObject *object)
{
return new MessageBoardAttachedType(object);
}
};
QML_DECLARE_TYPEINFO(MessageBoard, QML_HAS_ATTACHED_PROPERTIES) Теперь тип Message может получить доступ к свойствам и сигналам типа присоединенного объекта:
Message {
author: "Amelie"
creationDate: new Date()
MessageBoard.expired: creationDate < new Date("January 01, 2015 10:45:00")
MessageBoard.onPublished: console.log("Message by", author, "has been
published!")
} Кроме того, реализация на C++ может получить доступ к экземпляру присоединенного объекта, который был присоединен к любому объекту, вызвав функцию qmlAttachedPropertiesObject().
Например:
Message *msg = someMessageInstance();
MessageBoardAttachedType *attached =
qobject_cast<MessageBoardAttachedType*>(qmlAttachedPropertiesObject<MessageBoard>(msg));
qDebug() << "Value of MessageBoard.expired:" << attached->expired(); Типы модификаторов свойств
Тип модификатора свойства — это специальный тип объекта QML. Экземпляр типа модификатора свойства влияет на свойство (объекта экземпляра QML), к которому он применяется. Существуют два типа типов модификаторов свойств:
- интерцепторы записи значения свойства
- источники значений свойства
Интерцептор записи значения свойства можно использовать для фильтрации или изменения значений при записи в свойства. В настоящее время единственный поддерживаемый интерцептор записи значения свойства — тип Behavior, предоставляемый импортом QtQuick.
Источник значения свойства можно использовать для автоматического обновления значения свойства со временем. Клиенты могут определять свои собственные типы источников значений свойства. Различные типы анимации свойства, предоставляемые импортом QtQuick, являются примерами источников значений свойства.
Экземпляры типов модификаторов свойств могут быть созданы и применены к свойству объекта QML с помощью синтаксиса «<ТипМодификатора> на <ИмяСвойства>», как показано в следующем примере:
import QtQuick 2.0
Item {
width: 400
height: 50
Rectangle {
width: 50
height: 50
color: "red"
NumberAnimation on x {
from: 0
to: 350
loops: Animation.Infinite
duration: 2000
}
}
} Клиенты могут регистрировать свои собственные типы источников значений свойства, но в настоящее время не интерцепторы записи значений свойства.
Источники значений свойств
Источники значений свойств — это типы QML, которые могут автоматически обновлять значение свойства со временем, используя синтаксис <PropertyValueSource> on <property>. Например, различные типы анимации свойства, предоставляемые модулем QtQuick, являются примерами источников значений свойства.
Источник значения свойства можно реализовать на C++ путем наследования от QQmlPropertyValueSource и предоставления реализации, которая записывает разные значения в свойство со временем. Когда источник значения свойства применяется к свойству с помощью синтаксиса <PropertyValueSource> on <property> в QML, движок предоставляет этому свойству ссылку, чтобы источник значения мог обновлять значение свойства.
Например, предположим, что существует класс RandomNumberGenerator для использования в качестве источника значений свойства, так что при применении к свойству QML он будет обновлять значение свойства на другое случайное число каждые 500 миллисекунд. Кроме того, можно предоставить максимальное значение для этого генератора случайных чисел. Этот класс можно реализовать следующим образом:
class RandomNumberGenerator : public QObject, public QQmlPropertyValueSource
{
Q_OBJECT
Q_INTERFACES(QQmlPropertyValueSource)
Q_PROPERTY(int maxValue READ maxValue WRITE setMaxValue NOTIFY maxValueChanged);
public:
RandomNumberGenerator(QObject *parent)
: QObject(parent), m_maxValue(100)
{
QObject::connect(&m_timer, SIGNAL(timeout()), SLOT(updateProperty()));
m_timer.start(500);
}
int maxValue() const;
void setMaxValue(int maxValue);
virtual void setTarget(const QQmlProperty &prop) { m_targetProperty = prop; }
signals:
void maxValueChanged();
private slots:
void updateProperty() {
m_targetProperty.write(QRandomGenerator::global()->bounded(m_maxValue));
}
private:
QQmlProperty m_targetProperty;
QTimer m_timer;
int m_maxValue;
}; Когда движок QML сталкивается с использованием RandomNumberGenerator в качестве источника значений свойства, он вызывает RandomNumberGenerator::setTarget() для предоставления типу свойства, к которому был применен источник значения.
Когда внутренний таймер в RandomNumberGenerator срабатывает каждые 500 миллисекунд, он записывает новое числовое значение в указанное свойство.
После регистрации класса RandomNumberGenerator в системе типов QML его можно использовать в QML в качестве источника значений свойства. Ниже он используется для изменения ширины Rectangle каждые 500 миллисекунд:
import QtQuick 2.0
Item {
width: 300; height: 300
Rectangle {
RandomNumberGenerator on width { maxValue: 300 }
height: 100
color: "red"
}
} Во всех других отношениях источники значений свойств — это обычные типы QML, которые могут иметь свойства, сигналы, методы и т. д., но с дополнительной возможностью изменения значений свойств с помощью синтаксиса <PropertyValueSource> on <property>.
Когда объект источника значения свойства назначается свойству, QML сначала пытается назначить его нормально, как если бы это был обычный тип QML. Только если это назначение терпит неудачу, движок вызывает метод setTarget(). Это позволяет типу использоваться и в других контекстах, помимо просто источника значения.
Определение свойств по умолчанию для типов QML объектов
Любой тип, производный от QObject, зарегистрированный как экземпляризуемый тип объекта QML, может дополнительно указать свойство по умолчанию для типа. Свойство по умолчанию — это свойство, которому автоматически назначаются дочерние элементы объекта, если они не назначены какому-либо конкретному свойству.
Значение свойства по умолчанию можно установить, вызвав макрос Q_CLASSINFO() для класса со значением «DefaultProperty». Например, класс MessageBoard ниже указывает свойство messages в качестве свойства по умолчанию для класса:
class MessageBoard : public QObject
{
Q_OBJECT
Q_PROPERTY(QQmlListProperty<Message> messages READ messages)
Q_CLASSINFO("DefaultProperty", "messages")
public:
QQmlListProperty<Message> messages();
private:
QList<Message *> m_messages;
}; Это позволяет дочерним объектам MessageBoard автоматически присваиваться к свойству messages в том случае, если они не присвоены какому-либо конкретному свойству. Например:
MessageBoard {
Message { author: "Naomi" }
Message { author: "Clancy" }
} Если messages не было установлено как свойство по умолчанию, то все объекты Message должны быть явно присвоены свойству messages следующим образом:
MessageBoard {
messages: [
Message { author: "Naomi" },
Message { author: "Clancy" }
]
} (Кстати, свойство Item::data является свойством по умолчанию. Любые объекты Item, добавленные к этому свойству data, также добавляются в список Item::children, так что использование свойства по умолчанию позволяет объявлять визуальные дочерние элементы для элемента без явного присвоения их к свойству children.)
Определение визуальных элементов с модулем Qt Quick
При построении пользовательских интерфейсов с модулем Qt Quick все объекты QML, которые должны отображаться визуально, должны наследоваться от типа Item, так как это базовый тип для всех визуальных объектов в Qt Quick. Этот тип Item реализуется классом C++ QQuickItem, который предоставляется модулем Qt Quick. Поэтому этот класс следует наследоваться, когда необходимо реализовать визуальный тип на C++, который можно интегрировать в пользовательский интерфейс на основе QML.
Дополнительную информацию см. в документации к QQuickItem. Кроме того, учебник Создание расширений QML с помощью C++ демонстрирует, как реализовать визуальный элемент на основе QQuickItem на C++ и интегрировать его в пользовательский интерфейс на основе Qt Quick.
Получение уведомлений об инициализации объекта
Для некоторых пользовательских типов объектов QML может быть полезно отложить инициализацию определенных данных до момента создания объекта и установки всех его свойств. Например, это может быть так, если инициализация дорогостоящая или если инициализация не должна выполняться до тех пор, пока не будут инициализированы все значения свойств.
Модуль Qt QML предоставляет класс QQmlParserStatus для наследования в этих целях. Он определяет ряд виртуальных методов, которые вызываются на разных этапах создания компонента. Чтобы получать эти уведомления, класс C++ должен унаследовать от QQmlParserStatus и также уведомлять систему метаданных Qt с помощью макроса Q_INTERFACES().
Например:
class MyQmlType : public QObject, public QQmlParserStatus
{
Q_OBJECT
Q_INTERFACES(QQmlParserStatus)
public:
virtual void componentComplete()
{
// Perform some initialization here now that the object is fully created
}
};
© The Qt Company Ltd
Licensed under the GNU Free Documentation License, Version 1.3.
https://doc.qt.io/qt-5.13/qtqml-cppintegration-definetypes.html
