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

Fonction Documentation

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

La forme de cette fonction modèle est :

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

Ceci renvoie l'instance d'objet attachée qui a été attachée à l'adresse attachee spécifiée par le type d'attachement T.

Si attachee est nullptr, elle renvoie nullptr.

Si une instance d'objet attaché de type T existe, elle sera retournée. Sinon, il renverra une instance nouvellement créée si createIfMissing est true et si T est un type d'attachement valide, ou nullptr si ce n'est pas le cas.

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

void qmlClearTypeRegistrations()

Efface tous les enregistrements de types stockés, tels que ceux produits avec qmlRegisterType().

N'appelez pas cette fonction tant que QQmlEngine existe, sinon le comportement sera indéfini. Tout QQmlEngines existant doit être supprimé avant d'appeler cette fonction. Cette fonction n'affecte que le cache global de l'application. Supprimez le site QQmlEngine pour effacer toutes les données mises en cache relatives à ce moteur.

QObject *qmlExtendedObject(QObject *base)

Cette fonction renvoie l'objet d'extension qui appartient à base, s'il y en a un. Sinon, elle renvoie nullptr.

Voir aussi 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 de ne pas vérifier la possibilité de nouveaux types ou plugins lorsque cet import est atteint.

Une fois que qmlProtectModule a été appelé, un moteur QML ne cherchera plus un nouveau fichier qmldir pour charger le module. En revanche, il réutilisera les fichiers qmldir qu'il a déjà chargés. Par conséquent, les types présents à ce stade continuent de fonctionner. N'oubliez pas que différents moteurs QML peuvent charger des modules différents. La protection du module est cependant globale et affecte tous les moteurs. La surcharge liée à la localisation des fichiers qmldir et au chargement des plugins peut être perceptible sur les systèmes de fichiers lents. Par conséquent, protéger un module une fois que vous êtes sûr de ne plus avoir besoin de le charger peut être une bonne optimisation. N'oubliez pas non plus que le verrouillage des modules n'affecte pas seulement les modules externes, mais aussi toutes les autres directives qmldir, comme import ou prefer, ainsi que tous les types composites ou les scripts déclarés dans un fichier qmldir.

En outre, après l'appel de cette fonction, toute tentative d'enregistrement de types C++ dans cette combinaison d'uri et de version majeure entraînera une erreur d'exécution.

Retourne vrai si le module avec uri comme identifiant de module et majVersion comme numéro de version majeure a été trouvé et verrouillé, sinon retourne faux. Le module doit contenir des types exportés pour ê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 résultant n'a pas de nom. Par conséquent, les instances de ce type ne peuvent pas être créées à partir du système QML. Vous pouvez toutefois accéder aux instances du 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++ qui sont utilisés du côté gauche d'une liaison de propriété. Pour indiquer à quel module le type appartient, utilisez uri et versionMajor.

Par exemple, considérons 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, nous attribuons 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 a une propriété baz, nous devons faire connaître Bar:

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

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

Renvoie l'identifiant du type QML.

Voir aussi 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 avec le nom qmlName dans la bibliothèque importée de uri ayant un numéro de version 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 aussi QML_EXTENDED(), qmlRegisterType(), et Enregistrer des 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 avec le nom qmlName dans la bibliothèque importée de uri ayant un numéro de version composé de versionMajor et versionMinor.

Bien que le type ait un nom et un type, il ne peut pas être créé. Un message d'erreur avec l'adresse reason est imprimé si l'utilisateur tente de créer une instance de ce type.

Ceci est utile lorsque le type n'est destiné qu'à fournir des propriétés attaché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 particulière avec une version spécifiée dans versionMajor et versionMinor.

Cette fonction peut être utilisée pour rendre une certaine version de module disponible, même si aucun type n'est enregistré pour cette version. Cette fonction est particulièrement utile pour synchroniser les versions de modules apparentés.

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

Enregistre un qmldir-import pour le module uri de la version majeure moduleMajor.

Cela a le même effet qu'une déclaration import dans un fichier qmldir : Lorsque uri de la version moduleMajor est importé, import de la version importMajor. importMinor est automatiquement importé aussi. 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, c'est la dernière version mineure de importMajor qui est choisie. Si importMajor est QQmlModuleImportAuto, la version de import est la version de uri importée, et importMinor n'a pas d'importance. Si moduleMajor est QQmlModuleImportModuleAny, l'importation du module est appliquée à toute version majeure de uri. Par exemple, vous pouvez spécifier qu'à chaque fois qu'une version de MonModule est importée, la dernière version de MonAutreModule doit être importée. L'appel suivant serait alors approprié :

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

Ou encore, vous pouvez spécifier qu'à chaque fois que la version majeure 5 de "MonModule" est importée, la version 3.14 de "MonAutreModule" doit être importée :

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

Enfin, si vous souhaitez que la même version de "MonAutreModule" soit importée à chaque fois que "MonModule" est importé, spécifiez ce qui suit :

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

Voir aussi qmlUnregisterModuleImport().

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

Cette fonction modèle enregistre la révision spécifiée d'un type C++ dans le système QML avec la bibliothèque importée de uri ayant le numéro de version composé de versionMajor et versionMinor.

Elle 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 est utilisée pour enregistrer un objet singleton cppObject, avec un type particulier uri et typeName. Sa version est une combinaison de versionMajor et versionMinor.

L'installation d'un type singleton dans un URI vous permet de fournir des fonctionnalités arbitraires (méthodes et propriétés) au code QML sans que des instances individuelles du type soient instanciées par le client.

Cette fonction permet d'enregistrer un objet du type T donné en tant que type singleton.

Un type singleton QObject peut être référencé via le nom du type avec lequel il a été enregistré ; à son tour, ce nom de type peut être utilisé comme cible dans un type Connections, ou comme n'importe quel autre ID de type. Il existe cependant 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 que n'importe quel autre élément.

NOTE : 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 peut être utilisée pour enregistrer un type singleton portant le nom qmlName, dans la bibliothèque importée de uri ayant le numéro de version 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() == false.

En outre, le fichier QML du type doit comporter la déclaration pragma Singleton parmi ses déclarations d'importation.

Un type singleton peut être référencé via le nom du type avec lequel il a été enregistré, et ce nom de type peut être utilisé comme cible dans un type Connections ou utilisé comme n'importe quel autre identifiant de type. Une exception à cette règle est que la propriété d'un type singleton ne peut pas être aliasée (parce que le nom du type singleton n'identifie pas un objet dans le même composant que n'importe quel 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 le 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 en QML sans utiliser la fonction qmlRegisterSingletonType. Pour ce faire, il suffit d'ajouter une déclaration pragma Singleton parmi les importations du fichier QML du type. En outre, le type doit être défini dans un fichier qmldir avec un mot-clé singleton et le qmldir doit être importé par les fichiers QML utilisant le singleton.

Voir aussi 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 version particulière de uri et typeName 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 n'ait besoin d'instancier des instances individuelles du type.

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

REMARQUE : les propriétés du type singleton QJSValue ne déclencheront 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 une 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 le type singleton.

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

Voir aussi 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 un site particulier uri et typeName avec une version spécifiée dans versionMajor et versionMinor.

L'installation d'un type singleton dans une uri permet aux développeurs de fournir des fonctionnalités arbitraires (méthodes et propriétés) aux clients sans qu'il soit nécessaire que des instances individuelles du type soient instanciées par le client.

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

Un type singleton QObject peut être référencé via le nom de type avec lequel il a été enregistré, et ce nom de type peut être utilisé comme cible dans un type Connections ou utilisé comme n'importe quel autre identifiant de type. Une exception à cette règle est qu'une propriété d'un type singleton QObject ne peut pas être aliasée.

NOTE : Une instance de type singleton QObject renvoyée par un fournisseur de type singleton est la propriété du moteur QML, à moins que l'indicateur explicite QQmlEngine::CppOwnership ne soit activé sur l'objet.

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 une 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 le 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 aussi 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 avec le nom qmlName, dans la bibliothèque importée de uri ayant le numéro de version composé de versionMajor et versionMinor.

Elle 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 comme un nouveau type. La seconde permet à une révision particulière d'une classe d'être enregistrée 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 types 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 et le numéro de version spécifiés :

import com.mycompany.qmlcomponents 1.0

Slider {
    // ...
}

Notez qu'il est tout à fait raisonnable pour une bibliothèque d'enregistrer des types dans des versions plus anciennes que la version actuelle de la bibliothèque. En effet, il est normal que la nouvelle bibliothèque permette à QML écrit avec des versions antérieures de continuer à fonctionner, même si des versions plus avancées de certains de ses types sont disponibles.

Voir aussi 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 avec le nom qmlName, dans la bibliothèque importée de uri ayant le numéro de version 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() == 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 d'un code C++, par exemple lorsque la correspondance des types doit être déterminée de manière procédurale au démarrage.

Elle renvoie -1 si l'enregistrement n'a pas réussi.

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 avec le nom qmlName, dans l'espace de noms de type importé de uri ayant le numéro de version composé de versionMajor et versionMinor, mais toute tentative d'instanciation du type produira l'erreur donnée message.

Normalement, les types exportés par un plugin devraient être fixés. Cependant, si un type C++ n'est pas disponible, vous devriez au moins "réserver" le nom du type QML, et donner à l'utilisateur du type indisponible un message d'erreur significatif.

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

Tout QML qui importe l'espace de noms de type "MinehuntCore" et tente d'utiliser le type produira un message d'erreur :

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

Sans cela, un message générique "Game is not a type" serait affiché.

Voir aussi 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 le staticMetaObject et son extension dans le système QML avec le nom qmlName dans la bibliothèque importée de uri ayant un numéro de version composé de versionMajor et versionMinor.

Une instance de l'objet méta ne peut pas être créée. Un message d'erreur avec l'adresse reason est imprimé si l'utilisateur tente de la créer.

Cette fonction est utile pour enregistrer les 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");

Du côté de QML, vous pouvez maintenant utiliser les enums enregistrés :

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 avec le nom qmlName, dans la bibliothèque importée de uri ayant le numéro de version composé de versionMajor et versionMinor.

Bien que le type ait un nom et un type, il ne peut pas être créé, et l'erreur donnée message se produira si la création est tentée.

Ceci est utile lorsque le type n'est destiné qu'à fournir des propriétés attachées ou des valeurs d'énumération.

Renvoie l'identifiant du type QML.

Voir aussi 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 un site particulier uri et une version spécifiée dans versionMajor et versionMinor.

Cette fonction renvoie la même valeur que les fonctions d'enregistrement de type 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é.

Retourne -1 si aucun type correspondant n'a été trouvé ou si l'un des paramètres fournis n'est pas valide.

Voir aussi 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é avec qmlRegisterModuleImport()

L'appel à cette fonction permet de s'assurer que import de la version importMajor.importMinor n'est plus automatiquement importé lorsque uri de la version moduleMajor l'est. La résolution de la version fonctionne de la même manière qu'avec qmlRegisterModuleImport().

Voir aussi qmlRegisterModuleImport().