<qqml.h> - Functions to register C++ types to QML

Documentation de la fonction

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

La forme de cette fonction modèle est la suivante :

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

Elle renvoie l’instance de l’objet qui a été associée à l’ attachee spécifiée par le type d’association T.

Si attachee est nullptr, renvoie nullptr.

Si une instance d’objet attachée de type T existe déjà, elle sera renvoyée. Sinon, une instance nouvellement créée sera renvoyée si ` createIfMissing ` est ` true ` et si `T` est un type d’attachement valide, ou ` nullptr ` dans le cas contraire.

Voir également QML_ATTACHED() et Fournir des propriétés associées.

void qmlClearTypeRegistrations()

Efface tous les enregistrements de types stockés, tels que ceux créés avec la fonction ` qmlRegisterType()`.

Cette fonction n’affecte que le cache global de l’application. Supprimez l’ QQmlEngine pour effacer toutes les données mises en cache relatives à ce moteur.

QObject *qmlExtendedObject(QObject *base)

Cette fonction renvoie l'objet d'extension associé à base, s'il en existe un. Sinon, elle renvoie nullptr.

Voir également QML_EXTENDED.

bool qmlProtectModule(const char *uri, int majVersion)

Cette fonction protège un module contre toute modification ultérieure. Elle peut être utilisée pour empêcher d’autres plugins d’injecter des types dans votre module. Elle peut également améliorer les performances, car elle permet au moteur d’éviter de vérifier la présence éventuelle de nouveaux types ou plugins lorsque cette importation est atteinte.

Une fois que `qmlProtectModule` a été appelé, un moteur QML ne recherchera plus de nouveau fichier ` qmldir ` pour charger le module. Il réutilisera toutefois tous les fichiers ` qmldir ` qu’il a chargés auparavant. Par conséquent, les types présents à ce stade continuent de fonctionner. Notez que différents moteurs QML peuvent charger différents modules. La protection des modules est toutefois globale et affecte tous les moteurs. La surcharge liée à la recherche des fichiers ` qmldir ` et au chargement des plugins peut être perceptible avec des systèmes de fichiers lents. Par conséquent, protéger un module une fois que vous êtes certain de ne plus avoir besoin de le charger peut constituer une bonne optimisation. Notez également que le verrouillage de module n'affecte pas seulement les plugins, mais aussi toutes les autres directives `qmldir`, telles que ` import ` ou ` prefer`, ainsi que tous les types composites ou scripts déclarés dans un fichier ` qmldir `.

De plus, une fois cette fonction appelée, toute tentative d’enregistrement de types C++ dans cette combinaison d’URI et de version majeure entraînera une erreur d’exécution.

Renvoie « true » si le module dont l’identifiant est uri et dont le numéro de version majeure est majVersion a été trouvé et verrouillé ; sinon, renvoie « false ». Le module doit contenir des types exportés pour pouvoir être trouvé.

template <typename T> int qmlRegisterAnonymousType(const char *uri, int versionMajor)

Cette fonction modèle enregistre le type C++ dans le système QML en tant que type anonyme. Le type QML ainsi créé n'a pas de nom. Par conséquent, il n'est pas possible de créer des instances de ce type à partir du système QML. Vous pouvez toutefois accéder aux instances de ce type lorsqu'elles sont exposées en tant que propriétés d'autres types.

Utilisez cette fonction lorsque le type ne sera pas référencé par son nom, en particulier pour les types C++ utilisés à gauche d'une liaison de propriété. Pour indiquer à quel module appartient le type, utilisez uri et versionMajor.

Prenons par exemple les deux classes suivantes :

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

En QML, on attribue une chaîne de caractères à la propriété ` baz ` de ` bar` :

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

Pour que le moteur QML sache que le type « Bar » dispose d’une propriété « baz », il faut déclarer « Bar » :

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

Comme le type Foo est instancié en QML, il doit être enregistré avec la version de qmlRegisterType() qui prend un nom d’élément.

Renvoie l’identifiant du type QML.

Voir également QML_ANONYMOUS et Choisir la bonne méthode d’intégration entre C++ et QML.

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

Cette fonction modèle enregistre le type C++ et son objet d'extension dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor. Les propriétés non disponibles dans le type principal seront recherchées dans l'objet d'extension.

Renvoie l’identifiant du type QML.

Voir également QML_EXTENDED(), qmlRegisterType() et Enregistrement d’objets d’extension.

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

Cette fonction modèle enregistre le type C++ et son extension dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor.

Bien que le type dispose d’un nom et d’un type, il ne peut pas être instancié. Un message d’erreur indiquant l’ reason est affiché si l’utilisateur tente de créer une instance de ce type.

Ceci est utile lorsque le type est uniquement destiné à fournir des propriétés associées, des valeurs d’énumération ou une classe de base abstraite avec son extension.

Renvoie l’identifiant du type QML.

Voir également QML_EXTENDED(), QML_UNCREATABLE() et qmlRegisterUncreatableType().

void qmlRegisterModule(const char *uri, int versionMajor, int versionMinor)

Cette fonction enregistre un module dans une « uri » spécifique, avec une version spécifiée dans versionMajor et versionMinor.

Cela permet de rendre disponible une version donnée d’un module, même si aucun type n’est enregistré pour cette version. Cette fonctionnalité est particulièrement utile pour synchroniser les versions de modules associés.

void qmlRegisterModuleImport(const char *uri, int moduleMajor, const char *import, int importMajor = QQmlModuleImportLatest, int importMinor = QQmlModuleImportLatest)

Enregistre une importation qmldir pour le module uri de la version majeure moduleMajor.

Cela a le même effet qu’une instruction « import » dans un fichier qmldir : chaque fois que uri de la version moduleMajor est importé, import de la version importMajor. importMinor est également importé automatiquement. Si importMajor est QQmlModuleImportLatest, la dernière version disponible de ce module est importée, et importMinor n’a pas d’importance. Si importMinor est QQmlModuleImportLatest, la dernière version mineure de importMajor est choisie. Si importMajor est QQmlModuleImportAuto, la version de import correspond à celle de uri en cours d’importation, et importMinor n’a pas d’importance. Si moduleMajor est QQmlModuleImportModuleAny, l’importation du module s’applique à toutes les versions majeures de uri. Par exemple, vous pouvez spécifier que chaque fois qu’une version quelconque de MyModule est importée, la dernière version de MyOtherModule doit être importée. Dans ce cas, l’appel suivant serait approprié :

qmlRegisterModuleImport("MyModule", QQmlModuleImportModuleAny,
                        "MyOtherModule", QQmlModuleImportLatest);

Vous pouvez également spécifier que chaque fois que la version majeure 5 de « MyModule » est importée, la version 3.14 de « MyOtherModule » doit être importée :

qmlRegisterModuleImport("MyModule", 5, "MyOtherModule", 3, 14);

Enfin, si vous souhaitez que la même version de « MyOtherModule » soit toujours importée chaque fois que « MyModule » est importé, spécifiez ce qui suit :

qmlRegisterModuleImport("MyModule", QQmlModuleImportModuleAny,
                        "MyOtherModule", QQmlModuleImportAuto);

Voir également qmlUnregisterModuleImport().

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

Cette fonction modèle enregistre le type C++ T à la révision spécifiée metaObjectRevision dans le système QML, avec la bibliothèque importée depuis uri dont le numéro de version est composé de versionMajor et versionMinor.

Renvoie l’identifiant du type QML.

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

Cette fonction est généralement utilisée pour enregistrer la révision d’une classe de base à utiliser pour la version spécifiée du type (voir Révisions et versions des types).

int qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor, const char *typeName, QObject *cppObject)

Cette fonction sert à enregistrer un objet singleton cppObject, avec une uri et une typeName spécifiques. Sa version est une combinaison de versionMajor et versionMinor.

L'installation d'un type singleton dans une URI vous permet de fournir des fonctionnalités arbitraires (méthodes et propriétés) au code QML sans que le client ait besoin d'instancier des instances individuelles de ce type.

Utilisez cette fonction pour enregistrer un objet du type T donné en tant que type singleton.

Un type singleton de type « QObject » peut être référencé via le nom de type sous lequel il a été enregistré ; ce nom de type peut à son tour être utilisé comme cible dans un type de type « Connections », ou comme n’importe quel autre identifiant de type. Il existe toutefois une exception : une propriété de type singleton QObject ne peut pas être aliasée, car le nom du type singleton n’identifie pas un objet au sein du même composant qu’un autre élément.

REMARQUE : qmlRegisterSingleton ne peut être utilisé que lorsque tous les types de ce module sont enregistrés de manière procédurale.

Utilisation :

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

Pour utiliser le type singleton enregistré dans QML, vous devez importer l’URI avec la version correspondante.

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

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

Voir également QML_SINGLETON et qmlRegisterSingletonType.

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

Cette fonction permet d'enregistrer un type singleton portant le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor. Le type est défini par le fichier QML situé à l'adresse url. L'URL doit être une URL absolue, c'est-à-dire que url.isRelative() doit être égal à false.

De plus, le fichier QML du type doit comporter une directive `pragma Singleton` parmi ses directives d’importation.

Un type singleton peut être référencé via le nom de type sous lequel il a été enregistré, et ce nom de type peut servir de cible dans un type « Connections » ou être utilisé comme n’importe quel autre identifiant de type. Il existe toutefois une exception : une propriété de type singleton ne peut pas être aliasée (car le nom du type singleton n’identifie pas un objet au sein du même composant qu’un autre élément).

Utilisation :

// 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");

Pour utiliser le type singleton enregistré dans QML, vous devez importer ce type singleton.

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

Il est également possible d’enregistrer des types singleton QML sans utiliser la fonction `qmlRegisterSingletonType`. Pour ce faire, ajoutez une directive `pragma Singleton` parmi les importations du fichier QML du type. De plus, le type doit être défini dans un fichier qmldir avec le mot-clé `singleton` et le fichier qmldir doit être importé par les fichiers QML utilisant le singleton.

Voir également QML_SINGLETON.

int qmlRegisterSingletonType(const char *uri, int versionMajor, int versionMinor, const char *typeName, std::function<QJSValue (QQmlEngine *, QJSEngine *)> callback)

Cette fonction peut être utilisée pour enregistrer un fournisseur de type singleton callback dans une uri et une typeName spécifiques, avec une version spécifiée dans versionMajor et versionMinor.

L’installation d’un type singleton permet aux développeurs de fournir des fonctionnalités arbitraires (méthodes et propriétés) à un client sans que celui-ci ait à instancier des instances individuelles de ce type.

Un type singleton peut être soit un « QObject », soit un « QJSValue ». Cette fonction doit être utilisée pour enregistrer une fonction de fourniture de type singleton qui renvoie un « QJSValue » en tant que type singleton.

REMARQUE : les propriétés d’un type singleton de type « QJSValue » ne déclenchent pas de réévaluation de la liaison en cas de modification.

Utilisation :

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

Vous pouvez également utiliser un lambda 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;
});

Pour utiliser le type singleton enregistré dans QML, vous devez importer ce type singleton.

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

Voir également QML_SINGLETON et Choisir la bonne méthode d’intégration entre C++ et QML.

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

Cette fonction peut être utilisée pour enregistrer un fournisseur de type singleton callback dans une uri et typeName spécifiques, avec une version spécifiée dans versionMajor et versionMinor.

L’installation d’un type singleton dans un URI permet aux développeurs de fournir des fonctionnalités arbitraires (méthodes et propriétés) aux clients sans que ceux-ci aient à instancier des instances individuelles de ce type.

Un type singleton peut être soit un « QObject », soit un « QJSValue ». Cette fonction doit être utilisée pour enregistrer une fonction de fourniture de type singleton qui renvoie un « QObject » du type T donné en tant que type singleton.

Un type singleton de type « QObject » peut être référencé via le nom de type sous lequel il a été enregistré, et ce nom de type peut être utilisé comme cible dans un type « Connections » ou utilisé de la même manière que n’importe quel autre identifiant de type. Une exception à cette règle est qu’une propriété de type singleton « QObject » ne peut pas faire l’objet d’un alias.

REMARQUE : une instance de type singleton « QObject » renvoyée par un fournisseur de types singleton appartient au moteur QML, sauf si l'objet dispose explicitement du drapeau QQmlEngine::CppOwnership.

Utilisation :

// 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 = nullptr)
        : 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);

Vous pouvez également utiliser un lambda 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;
});

Pour utiliser le type singleton enregistré dans QML, vous devez importer ce type singleton.

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

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

Voir également QML_SINGLETON et Choisir la bonne méthode d’intégration entre C++ et QML.

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

Cette fonction modèle enregistre le type C++ dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor.

Renvoie l'identifiant du type QML.

Il existe deux formes de cette fonction modèle :

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

La première est la forme standard qui enregistre le type T en tant que nouveau type. La seconde permet d'enregistrer une révision particulière d'une classe dans une version spécifiée (voir Révisions et versions des types).

Par exemple, ceci enregistre une classe C++ MySliderItem en tant que type QML nommé Slider pour la version 1.0 d'un espace de noms de type appelé « com.mycompany.qmlcomponents » :

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

Une fois enregistré, le type peut être utilisé en QML en important l’espace de noms de type et le numéro de version spécifiés :

import com.mycompany.qmlcomponents 1.0

Slider {
    // ...
}

Notez qu’il est tout à fait raisonnable qu’une bibliothèque enregistre des types correspondant à des versions antérieures à la version actuelle de la bibliothèque. En effet, il est normal que la nouvelle bibliothèque permette au code QML écrit pour les versions précédentes de continuer à fonctionner, même si des versions plus avancées de certains de ses types sont disponibles.

Voir également QML_ELEMENT, QML_NAMED_ELEMENT() et « Choisir la bonne méthode d’intégration entre C++ et QML ».

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

Cette fonction enregistre un type dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor. Le type est défini par le fichier QML situé à l'adresse url. L'URL doit être une URL absolue, c'est-à-dire que url.isRelative() doit être égal à false.

Normalement, les fichiers QML peuvent être chargés en tant que types directement à partir d’autres fichiers QML, ou à l’aide d’un fichier qmldir. Cette fonction permet d’enregistrer des fichiers en tant que types à partir de code C++, par exemple lorsque le mappage des types doit être déterminé de manière procédurale au démarrage.

Renvoie -1 si l'enregistrement a échoué.

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

Cette fonction enregistre un type dans le système QML sous le nom qmlName, dans l'espace de noms de type importé depuis uri, avec un numéro de version composé de versionMajor et versionMinor; toutefois, toute tentative d'instanciation de ce type générera l'erreur indiquée message.

Normalement, les types exportés par un plugin doivent être corrigés. Cependant, si un type C++ n'est pas disponible, vous devez au moins « réserver » le nom du type QML et fournir à l'utilisateur du type indisponible un message d'erreur pertinent.

Renvoie l’identifiant du type QML.

Exemple :

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

Cela provoquera l'affichage d'un message d'erreur dans tout code QML qui importe l'espace de noms de type « MinehuntCore » et tente d'utiliser ce type :

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

Sans cela, un message générique du type « Game n'est pas un type » serait affiché.

Voir également QML_UNAVAILABLE, qmlRegisterUncreatableType() et « Choisir la bonne méthode d’intégration entre C++ et QML ».

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

Cette fonction enregistre l'staticMetaObject e et son extension dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor.

Il n’est pas possible de créer une instance de ce méta-objet. Si l’utilisateur tente de le créer, un message d’erreur contenant l’ reason indiquée s’affiche.

Cette fonction est utile pour enregistrer des espaces de noms Q_NAMESPACE.

Renvoie l'identifiant du type QML.

Par exemple :

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

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

Côté QML, vous pouvez désormais utiliser les énumérations enregistrées :

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

Voir également ` QML_ELEMENT`, ` QML_NAMED_ELEMENT()` et ` QML_UNCREATABLE()`.

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

Cette fonction modèle enregistre le type C++ dans le système QML sous le nom qmlName, dans la bibliothèque importée depuis uri, dont le numéro de version est composé de versionMajor et versionMinor.

Bien que le type dispose d'un nom et d'un type, il ne peut pas être créé, et une tentative de création entraînera l'erreur « message ».

Ceci est utile lorsque le type est uniquement destiné à fournir des propriétés associées ou des valeurs d’énumération.

Renvoie l’identifiant du type QML.

Voir également QML_UNCREATABLE(), qmlRegisterTypeNotAvailable() et « Choisir la bonne méthode d’intégration entre C++ et QML ».

int qmlTypeId(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

Renvoie l'identifiant de type QML d'un type qui a été enregistré sous le nom qmlName dans une uri donnée, avec une version spécifiée dans versionMajor et versionMinor.

Cette fonction renvoie la même valeur que les fonctions d'enregistrement de types QML telles que qmlRegisterType() et qmlRegisterSingletonType().

Si qmlName, uri et versionMajor correspondent à un type enregistré, mais que la version mineure spécifiée dans versionMinor est supérieure, l’identifiant du type dont la version mineure est la plus proche est renvoyé.

Renvoie -1 si aucun type correspondant n’a été trouvé ou si l’un des paramètres fournis n’était pas valide.

Voir également QML_ELEMENT, QML_NAMED_ELEMENT, QML_SINGLETON, qmlRegisterType() et qmlRegisterSingletonType().

void qmlUnregisterModuleImport(const char *uri, int moduleMajor, const char *import, int importMajor = QQmlModuleImportLatest, int importMinor = QQmlModuleImportLatest)

Supprime l'importation d'un module précédemment enregistrée via la fonction qmlRegisterModuleImport()

L'appel de cette fonction garantit que import de la version importMajor.importMinor ne sera plus importé automatiquement lorsque uri de la version moduleMajor le sera. La résolution de version fonctionne de la même manière qu'avec qmlRegisterModuleImport().

Voir également qmlRegisterModuleImport().