Класс QQmlEngine

QQmlEngine engine;
QQmlComponent component(&engine);
component.setData("import QtQuick 2.0\nText { text: \"Hello world!\" }", QUrl());
QQuickItem *item = qobject_cast<QQuickItem *>(component.create());

//add item to view, etc
...

class MySingleton : public QObject {
    Q_OBJECT

    // Register as default constructed singleton.
    QML_ELEMENT
    QML_SINGLETON

    static int typeId;
    // ...
};

    MySingleton::typeId = qmlTypeId(...);

    // Retrieve as QObject*
    QQmlEngine engine;
    MySingleton* instance = engine.singletonInstance<MySingleton*>(MySingleton::typeId);

    // Register with QJSValue callback
    int typeId = qmlRegisterSingletonType(...);

    // Retrieve as QJSValue
    QQmlEngine engine;
    QJSValue instance = engine.singletonInstance<QJSValue>(typeId);

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

template <typename T> QObject *qmlAttachedPropertiesObject(const QObject *attachee, bool create = true)

Формат этой шаблонной функции:

template<typename T> QObject *qmlAttachedPropertiesObject(const QObject *attachee, bool create = true)

Это возвращает экземпляр присоединённого объекта, который был присоединён к указанному attachee типом T.

Если create равно true, а тип T — допустимый тип присоединения, то это создаёт и возвращает новый экземпляр присоединённого объекта.

Возвращает 0, если тип T не является допустимым типом присоединения или если create равно false, и ранее не был создан экземпляр присоединённого объекта для attachee.

См. также QML_ATTACHED() и Обеспечение присоединённых свойств.

void qmlClearTypeRegistrations()

Очищает все сохранённые регистрации типов, такие как те, которые созданы с помощью qmlRegisterType().

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

QQmlContext *qmlContext(const QObject *object)

Возвращает QQmlContext, связанный с object, если таковой есть. Это эквивалентно QQmlEngine::contextForObject(object).

См. также contextForObject() и qmlEngine().

[since 5.9] QQmlInfo qmlDebug(const QObject *object)

Выводит сообщения отладки, включающие файл и строку для указанного QML-объекта object.

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

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

qmlDebug(object) << "Internal state: 42";

выводит

QML MyCustomType (unknown location): Internal state: 42

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

См. также qmlInfo и qmlWarning.

QQmlEngine *qmlEngine(const QObject *object)

Возвращает QQmlEngine, связанный с object, если таковой есть. Это эквивалентно QQmlEngine::contextForObject(object)->engine(), но более эффективно.

См. также contextForObject() и qmlContext().

QQmlInfo qmlInfo(const QObject *object)

Выводит информационные сообщения, включающие файл и строку для указанного QML-объекта object.

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

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

Например,

qmlInfo(object) << tr("component property is a write-once property");

выводит

QML MyCustomType (unknown location): component property is a write-once property

См. также qmlDebug и qmlWarning.

bool qmlProtectModule(const char *uri, int majVersion)

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

После вызова qmlProtectModule QML-движок больше не будет искать новый файл qmldir для загрузки модуля. Он будет повторно использовать загруженные ранее файлы qmldir, хотя. Таким образом, присутствующие в этот момент типы по-прежнему работают. Обратите внимание, что разные QML-движки могут загружать разные модули. Однако защита модуля является глобальной и влияет на все движки. Надгрузка поиска файлов qmldir и загрузки плагинов может быть заметной при медленных файловых системах. Поэтому защита модуля, когда вы уверены, что вам больше не нужно его загружать, может быть хорошей оптимизацией. Учитывайте также, что блокировка модуля влияет не только на плагины, но и на все другие директивы qmldir, такие как import или prefer, а также на любые составные типы или скрипты, объявленные в файле qmldir.

Кроме того, после вызова этой функции любая попытка зарегистрировать C++-типы в этой комбинации uri и major version приведёт к ошибке во время выполнения.

Возвращает true, если модуль с uri в качестве идентификатора модуля и majVersion в качестве номера основной версии был найден и заблокирован, в противном случае возвращает false. Модуль должен содержать экспортированные типы, чтобы быть найденным.

[since 5.14] template <typename T> int qmlRegisterAnonymousType(const char *uri, int versionMajor)

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

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

Для указания модуля, к которому принадлежит тип, используйте uri и versionMajor.

Например, рассмотрим следующие два класса:

class Bar : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString baz READ baz WRITE setBaz NOTIFY bazChanged)

public:
    Bar() {}

    QString baz() const { return mBaz; }

    void setBaz(const QString &baz)
    {
        if (baz == mBaz)
            return;

        mBaz = baz;
        emit bazChanged();
    }

signals:
    void bazChanged();

private:
    QString mBaz;
};

class Foo : public QObject
{
    Q_OBJECT
    Q_PROPERTY(Bar *bar READ bar CONSTANT FINAL)

public:
    Foo() {}

    Bar *bar() { return &mBar; }

private:
    Bar mBar;
};

В QML мы присваиваем строку свойству baz объекта bar:

Foo {
    bar.baz: "abc"
    Component.onCompleted: print(bar.baz)
}

Для того, чтобы QML-движок знал, что тип Bar имеет свойство baz, мы должны сделать тип Bar известным:

qmlRegisterType<Foo>("App", 1, 0, "Foo");
qmlRegisterAnonymousType<Bar>("App", 1);

Поскольку тип Foo создаётся в QML, его необходимо зарегистрировать с помощью версии qmlRegisterType(), которая принимает имя элемента.

Возвращает идентификатор QML-типа.

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

См. также QML_ANONYMOUS и Выбор правильного метода интеграции между C++ и QML.

template <typename T, typename E> int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Эта шаблонная функция регистрирует C++-тип и его расширяющий объект в QML-системе с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor. Свойства, отсутствующие в основном типе, будут искаться в расширяющем объекте.

Возвращает идентификатор QML-типа.

См. также QML_EXTENDED(), qmlRegisterType() и Регистрация расширяющих объектов.

template <typename T, typename E> int qmlRegisterExtendedUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString &reason)

Эта шаблонная функция регистрирует C++-тип и его расширение в QML-системе с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor.

Хотя тип имеет имя и тип, он не может быть создан. Сообщение об ошибке с заданным reason выводится, если пользователь пытается создать экземпляр этого типа.

Это полезно в тех случаях, когда тип предназначен только для предоставления присоединённых свойств, значений перечислений или абстрактного базового класса с его расширением.

Возвращает идентификатор QML-типа.

См. также QML_EXTENDED(), QML_UNCREATABLE() и qmlRegisterUncreatableType().

[since 5.9] void qmlRegisterModule(const char *uri, int versionMajor, int versionMinor)

Эта функция регистрирует модуль в определённом uri с указанной в versionMajor и versionMinor версией.

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

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

template <typename T, int metaObjectRevision> int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor)

Эта шаблонная функция регистрирует указанную версию типа C++ в системе QML с библиотекой, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor.

Возвращает идентификатор типа QML.

template<typename T, int metaObjectRevision>
int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor);

Эта функция обычно используется для регистрации версии базового класса для использования в указанной версии типа (см. Ревизии и версии типов).

[since 5.14] int qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor, const char *typeName, QObject *cppObject)

Эта функция используется для регистрации одиночного объекта cppObject с конкретным uri и typeName. Его версия является комбинацией versionMajor и versionMinor.

Установка типа-синглтона в URI позволяет предоставлять произвольные функции (методы и свойства) коду QML без необходимости создания отдельных экземпляров типа клиентом.

Используйте эту функцию для регистрации объекта данного типа T в качестве типа-синглтона.

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

ПРИМЕЧАНИЕ: qmlRegisterSingleton можно использовать только в том случае, когда все типы данного модуля зарегистрированы процедурно.

Использование:

// First, define your QObject which provides the functionality.
class SingletonTypeExample : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int someProperty READ someProperty WRITE setSomeProperty NOTIFY somePropertyChanged)

public:
    explicit SingletonTypeExample(QObject* parent = nullptr) : QObject(parent) {}

    Q_INVOKABLE int doSomething()
    {
        setSomeProperty(5);
        return m_someProperty;
    }

    int someProperty() const { return m_someProperty; }
    void setSomeProperty(int val) {
        if (m_someProperty != val) {
            m_someProperty = val;
            emit somePropertyChanged(val);
        }
    }

signals:
    void somePropertyChanged(int newValue);

private:
    int m_someProperty = 0;
};

// Second, create an instance of the object

// allocate example before the engine to ensure that it outlives it
QScopedPointer<SingletonTypeExample> example(new SingletonTypeExample);
QQmlEngine engine;

// Third, register the singleton type provider with QML by calling this
// function in an initialization function.
qmlRegisterSingletonInstance("Qt.example.qobjectSingleton", 1, 0, "MyApi", example.get());

Для использования зарегистрированного типа синглтона в QML необходимо импортировать URI с соответствующей версией.

import QtQuick 2.0
import Qt.example.qobjectSingleton 1.0
Item {
    id: root
    property int someValue: MyApi.someProperty

    Component.onCompleted: {
        console.log(MyApi.doSomething())
    }
}

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

См. также QML_SINGLETON и qmlRegisterSingletonType.

int qmlRegisterSingletonType(const char *uri, int versionMajor, int versionMinor, const char *typeName, QJSValue (*)(QQmlEngine *, QJSEngine *) callback)

Эта функция может быть использована для регистрации поставщика типа-синглтона callback в конкретном uri и typeName с версией, указанной в versionMajor и versionMinor.

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

Тип синглтона может быть QObject или QJSValue. Эта функция должна использоваться для регистрации функции поставщика типа-синглтона, которая возвращает QJSValue как тип-синглтон.

ПРИМЕЧАНИЕ: свойства типа-синглтона QJSValue не будут повторно вызывать привязку, если их изменить.

Использование:

// First, define the singleton type provider function (callback).
static QJSValue example_qjsvalue_singletontype_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
{
    Q_UNUSED(engine)

    static int seedValue = 5;
    QJSValue example = scriptEngine->newObject();
    example.setProperty("someProperty", seedValue++);
    return example;
}

// Second, register the singleton type provider with QML by calling this function in an initialization function.
qmlRegisterSingletonType("Qt.example.qjsvalueApi", 1, 0, "MyApi", example_qjsvalue_singletontype_provider);

В качестве альтернативы вы можете использовать лямбда-функцию C++11:

qmlRegisterSingletonType("Qt.example.qjsvalueApi", 1, 0, "MyApi", [](QQmlEngine *engine, QJSEngine *scriptEngine) -> QJSValue {
    Q_UNUSED(engine)

    static int seedValue = 5;
    QJSValue example = scriptEngine->newObject();
    example.setProperty("someProperty", seedValue++);
    return example;
});

Для использования зарегистрированного типа-синглтона в QML необходимо импортировать тип-синглтон.

import QtQuick 2.0
import Qt.example.qjsvalueApi 1.0 as ExampleApi
Item {
    id: root
    property int someValue: ExampleApi.MyApi.someProperty
}

См. также QML_SINGLETON и Выбор правильного метода интеграции между C++ и QML.

template <typename T> int qmlRegisterSingletonType(const char *uri, int versionMajor, int versionMinor, const char *typeName, QObject *(*)(QQmlEngine *, QJSEngine *) callback)

Эта функция может быть использована для регистрации поставщика типа-синглтона callback в конкретном uri и typeName с версией, указанной в versionMajor и versionMinor.

Установка типа-синглтона в URI позволяет разработчикам предоставлять произвольные функции (методы и свойства) клиентам без необходимости создания отдельных экземпляров типа клиентом.

Тип синглтона может быть QObject или QJSValue. Эта функция должна использоваться для регистрации функции поставщика типа-синглтона, которая возвращает QObject заданного типа T в качестве типа-синглтона.

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

ПРИМЕЧАНИЕ: Экземпляр типа-синглтона QObject, возвращаемый поставщиком типа-синглтона, принадлежит движку QML, если только объект не имеет явно установленного флага QQmlEngine::CppOwnership.

Использование:

// First, define your QObject which provides the functionality.
class SingletonTypeExample : public QObject
{
    Q_OBJECT
    Q_PROPERTY (int someProperty READ someProperty WRITE setSomeProperty NOTIFY somePropertyChanged)

public:
    SingletonTypeExample(QObject* parent = 0)
        : QObject(parent), m_someProperty(0)
    {
    }

    ~SingletonTypeExample() {}

    Q_INVOKABLE int doSomething() { setSomeProperty(5); return m_someProperty; }

    int someProperty() const { return m_someProperty; }
    void setSomeProperty(int val) { m_someProperty = val; emit somePropertyChanged(val); }

signals:
    void somePropertyChanged(int newValue);

private:
    int m_someProperty;
};

// Second, define the singleton type provider function (callback).
static QObject *example_qobject_singletontype_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
{
    Q_UNUSED(engine)
    Q_UNUSED(scriptEngine)

    SingletonTypeExample *example = new SingletonTypeExample();
    return example;
}

// Third, register the singleton type provider with QML by calling this function in an initialization function.
qmlRegisterSingletonType<SingletonTypeExample>("Qt.example.qobjectSingleton", 1, 0, "MyApi", example_qobject_singletontype_provider);

В качестве альтернативы вы можете использовать лямбда-функцию C++11:

qmlRegisterSingletonType<SingletonTypeExample>("Qt.example.qobjectSingleton", 1, 0, "MyApi", [](QQmlEngine *engine, QJSEngine *scriptEngine) -> QObject * {
    Q_UNUSED(engine)
    Q_UNUSED(scriptEngine)

    SingletonTypeExample *example = new SingletonTypeExample();
    return example;
});

Для использования зарегистрированного типа-синглтона в QML необходимо импортировать тип-синглтон.

import QtQuick 2.0
import Qt.example.qobjectSingleton 1.0
Item {
    id: root
    property int someValue: MyApi.someProperty

    Component.onCompleted: {
        someValue = MyApi.doSomething()
    }
}

См. также QML_SINGLETON и Выбор правильного метода интеграции между C++ и QML.

[since 5.14] template <typename T> int qmlRegisterSingletonType(const char *uri, int versionMajor, int versionMinor, const char *typeName, std::function<QObject *(QQmlEngine *, QJSEngine *)> callback)

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

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

int qmlRegisterSingletonType(const QUrl &url, const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Эта функция может использоваться для регистрации типа-синглтона с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor. Тип определяется файлом QML, расположенным по адресу url. Адрес URL должен быть абсолютным, т.е. url.isRelative() == false.

Кроме того, файл QML типа должен иметь в своих операциях импорта директиву pragma Singleton.

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

Использование:

// First, define your QML singleton type which provides the functionality.
pragma Singleton
import QtQuick 2.0
Item {
    property int testProp1: 125
}

// Second, register the QML singleton type by calling this function in an initialization function.
qmlRegisterSingletonType(QUrl("file:///absolute/path/SingletonType.qml"), "Qt.example.qobjectSingleton", 1, 0, "RegisteredSingleton");

Для использования зарегистрированного типа-синглтона в QML необходимо импортировать тип-синглтон.

import QtQuick 2.0
import Qt.example.qobjectSingleton 1.0
Item {
    id: root
    property int someValue: RegisteredSingleton.testProp1
}

Также можно регистрировать типы-синглтона QML без использования функции qmlRegisterSingletonType. Это можно сделать, добавив директиву pragma Singleton в импорты файла QML типа. Кроме того, тип должен быть определен в файле qmldir со словом singleton, а qmldir должен быть импортирован файлами QML, использующими синглтон.

См. также QML_SINGLETON.

template <typename T> int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Эта шаблонная функция регистрирует тип C++ в системе QML с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor.

Возвращает идентификатор типа QML.

Существует две формы этой шаблонной функции:

template<typename T>
int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName);

template<typename T, int metaObjectRevision>
int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName);

Первая — стандартная форма, которая регистрирует тип T как новый тип. Вторая позволяет зарегистрировать определенную ревизию класса в указанной версии (см. Ревизии и версии типов).

Например, это регистрирует класс C++ MySliderItem как тип QML с именем Slider для версии 1.0 пространства имен типа "com.mycompany.qmlcomponents":

qmlRegisterType<MySliderItem>("com.mycompany.qmlcomponents", 1, 0, "Slider");

После регистрации этот тип может использоваться в QML путем импорта указанного пространства имен типа и номера версии:

import com.mycompany.qmlcomponents 1.0

Slider {
    // ...
}

Обратите внимание, что для библиотеки вполне разумно регистрировать типы для более старых версий, чем фактическая версия библиотеки. Фактически, это нормально для новой библиотеки, чтобы QML, написанный для предыдущих версий, продолжал работать, даже если доступны более продвинутые версии некоторых её типов.

См. также QML_ELEMENT, QML_NAMED_ELEMENT(), и Выбор правильного метода интеграции между C++ и QML.

int qmlRegisterType(const QUrl &url, const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Эта функция регистрирует тип в системе QML с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor. Тип определяется файлом QML, расположенным по адресу url. URL-адрес должен быть абсолютным, т.е. url.isRelative() == false.

Обычно файлы QML могут загружаться как типы напрямую из других файлов QML или с помощью файла qmldir. Эта функция позволяет регистрировать файлы в типы из кода C++, например, когда отображение типов нужно определять процедурно при запуске.

Возвращает -1, если регистрация не удалась.

int qmlRegisterTypeNotAvailable(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString &message)

Эта функция регистрирует тип в системе QML с именем qmlName в пространстве имён типа, импортированном из uri, имеющем номер версии, составленный из versionMajor и versionMinor, но любая попытка создать экземпляр типа приведет к ошибке message.

Обычно типы, экспортируемые плагином, должны быть неизменными. Однако, если тип C++ недоступен, вы должны хотя бы «зарезервировать» имя типа QML и предоставить пользователю недоступного типа осмысленное сообщение об ошибке.

Возвращает идентификатор типа QML.

Пример:

#ifdef NO_GAMES_ALLOWED
qmlRegisterTypeNotAvailable("MinehuntCore", 0, 1, "Game", "Get back to work, slacker!");
#else
qmlRegisterType<MinehuntGame>("MinehuntCore", 0, 1, "Game");
#endif

Это приведет к тому, что любой QML, импортирующий пространство имен типа «MinehuntCore» и пытающийся использовать тип, выдаст сообщение об ошибке:

fun.qml: Get back to work, slacker!
   Game {
   ^

Без этого было бы выдано общее сообщение «Игра не является типом».

См. также QML_UNAVAILABLE, qmlRegisterUncreatableType(), и Выбор правильного метода интеграции между C++ и QML.

[since 5.8] int qmlRegisterUncreatableMetaObject(const QMetaObject &staticMetaObject, const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString &reason)

Эта функция регистрирует staticMetaObject и её расширение в системе QML с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor.

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

Эта функция полезна для регистрации пространств имён Q_NAMESPACE.

Возвращает идентификатор типа QML.

Например:

namespace MyNamespace {
  Q_NAMESPACE
  enum MyEnum {
      Key1,
      Key2,
  };
  Q_ENUMS(MyEnum)
}

//...
qmlRegisterUncreatableMetaObject(MyNamespace::staticMetaObject, "io.qt", 1, 0, "MyNamespace", "Access to enums & flags only");

Теперь на стороне QML вы можете использовать зарегистрированные перечисления:

Component.onCompleted: console.log(MyNamespace.Key2)

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

См. также QML_ELEMENT, QML_NAMED_ELEMENT(), и QML_UNCREATABLE().

template <typename T> int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString &message)

Эта шаблонная функция регистрирует тип C++ в системе QML с именем qmlName в библиотеке, импортированной из uri, имеющей номер версии, составленный из versionMajor и versionMinor.

Хотя тип имеет имя и тип, его нельзя создать, и при попытке создания будет выведено сообщение об ошибке message.

Это полезно, когда тип предназначен только для предоставления присоединённых свойств или значений перечислений.

Возвращает идентификатор типа QML.

См. также QML_UNCREATABLE(), qmlRegisterTypeNotAvailable(), и Выбор правильного метода интеграции между C++ и QML.

[since 5.12] int qmlTypeId(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Возвращает идентификатор типа QML типа, который был зарегистрирован с именем qmlName в определённом uri и версии, указанной в versionMajor и versionMinor.

Эта функция возвращает то же значение, что и функции регистрации типов QML, такие как qmlRegisterType() и qmlRegisterSingletonType().

Если qmlName, uri и versionMajor соответствуют зарегистрированному типу, но указанная версия minor в versionMinor выше, то возвращается идентификатор типа с ближайшей версией minor.

Возвращает -1, если соответствующий тип не был найден или один из заданных параметров был некорректен.

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

См. также QML_ELEMENT, QML_NAMED_ELEMENT, QML_SINGLETON, qmlRegisterType(), и qmlRegisterSingletonType().

[since 5.9] QQmlInfo qmlWarning(const QObject *object)

Выводит сообщения об ошибках, которые включают файл и номер строки для указанного объекта QML object.

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

Для включения файла и номера строки должен быть передан объект. Если файл и номер строки недоступны для данного экземпляра (либо он не был создан движком QML, либо информация о местоположении отключена), вместо этого будет использоваться «неизвестное местоположение».

Например,

qmlInfo(object) << tr("property cannot be set to 0");

выводит

QML MyCustomType (unknown location): property cannot be set to 0

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

См. также qmlDebug и qmlInfo.

class Slider : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    ...
}

CONFIG += qmltypes
QML_IMPORT_NAME = com.mycompany.qmlcomponents
QML_IMPORT_MAJOR_VERSION = 1

qt6_add_qml_module(myapp
  URI com.mycompany.qmlcomponents
  VERSION 1.0
)

import com.mycompany.qmlcomponents 1.0

Slider {
    // ...
}

namespace MyNamespace {
    Q_NAMESPACE
    enum MyEnum { MyEnumerator = 10 };
    Q_ENUM_NS(MyEnum)
}

class QmlType : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_EXTENDED_NAMESPACE(MyNamespace)
}

QmlType {
    property int i: QmlType.MyEnumerator // i will be 10
}

struct FooInterface
{
    QML_INTERFACE
public:
    virtual ~FooInterface();
    virtual void doSomething() = 0;
};

Q_DECLARE_INTERFACE(FooInterface, "org.foo.FooInterface")

class SqlEventDatabase : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(EventDatabase)

    // ...
};

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )
public:
    // members, Q_INVOKABLE functions, etc.
};

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )

public:
    static MySingleton *create(QQmlEngine *qmlEngine, QJSEngine *jsEngine)
    {
        MySingleton *result = nullptr;
        // Create the object using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }

    // members, Q_INVOKABLE functions, etc
};

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
public:

    static MySingleton *create(QQmlEngine *, QJSEngine *engine)
    {
        MySingleton *result = nullptr;
        // Create the instance using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }
};

qmlRegisterSingletonInstance("MyModule", 1, 0, "MySingleton", myObject);

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
public:

    // Initialize this using myObject where you would previously
    // call qmlRegisterSingletonInstance().
    static MySingleton *s_singletonInstance = nullptr;

    static MySingleton *create(QQmlEngine *, QJSEngine *engine)
    {
        // The instance has to exist before it is used. We cannot replace it.
        Q_ASSERT(s_singletonInstance);

        // The engine has to have the same thread affinity as the singleton.
        Q_ASSERT(engine->thread() == s_singletonInstance->thread());

        // There can only be one engine accessing the singleton.
        if (s_engine)
            Q_ASSERT(engine == s_engine);
        else
            s_engine = engine;

        // Explicitly specify C++ ownership so that the engine doesn't delete
        // the instance.
        QJSEngine::setObjectOwnership(s_singletonInstance,
                                      QJSEngine::CppOwnership);
        return s_singletonInstance;
    }

private:
    static QJSEngine *s_engine = nullptr;
};

#ifdef NO_GAMES_ALLOWED
struct MinehuntGame
{
    Q_GADGET
    QML_NAMED_ELEMENT(Game)
    QML_UNAVAILABLE
    QML_UNCREATABLE("Get back to work, slacker!");
};
#else
class MinehuntGame : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(Game)
    // ...
};
#endif

fun.qml: Get back to work, slacker!
   Game {
   ^