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

Funktionsdokumentation

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

Die Form dieser Vorlagenfunktion lautet:

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

Diese gibt die angehängte Objektinstanz zurück, die vom Anhängetyp T an die angegebene „ attachee “ angehängt wurde.

Ist ` attachee ` gleich ` nullptr`, wird ` nullptr` zurückgegeben.

Wenn bereits eine angehängte Objektinstanz vom Typ T vorhanden ist, wird diese zurückgegeben. Andernfalls wird eine neu erstellte Instanz zurückgegeben, sofern ` createIfMissing ` ` true ` ist und `T` ein gültiger Anhängetyp ist; andernfalls wird ` nullptr ` zurückgegeben.

Siehe auch „ QML_ATTACHED()“ und „Bereitstellen von angehängten Eigenschaften“.

void qmlClearTypeRegistrations()

Löscht alle gespeicherten Typregistrierungen, wie sie beispielsweise mit ` qmlRegisterType()` erstellt wurden.

Diese Funktion wirkt sich nur auf den globalen Cache der Anwendung aus. Löschen Sie die ` QQmlEngine `, um alle zwischengespeicherten Daten zu dieser Engine zu löschen.

QObject *qmlExtendedObject(QObject *base)

Diese Funktion gibt das zu base gehörende Erweiterungsobjekt zurück, sofern vorhanden. Andernfalls gibt sie nullptr zurück.

Siehe auch QML_EXTENDED.

bool qmlProtectModule(const char *uri, int majVersion)

Diese Funktion schützt ein Modul vor weiteren Änderungen. Damit lässt sich verhindern, dass andere Plugins Typen in Ihr Modul einfügen. Außerdem kann dies zu einer Leistungssteigerung führen, da die Engine dadurch die Überprüfung auf mögliche neue Typen oder Plugins überspringen kann, sobald dieser Import erreicht wird.

Sobald `qmlProtectModule` aufgerufen wurde, sucht eine QML-Engine nicht mehr nach einer neuen ` qmldir `-Datei, um das Modul zu laden. Sie verwendet jedoch weiterhin alle zuvor geladenen ` qmldir `-Dateien. Daher funktionieren zu diesem Zeitpunkt vorhandene Typen weiterhin. Beachten Sie, dass verschiedene QML-Engines unterschiedliche Module laden können. Der Modulschutz ist jedoch global und wirkt sich auf alle Engines aus. Der Overhead beim Auffinden von „ qmldir “-Dateien und beim Laden von Plugins kann bei langsamen Dateisystemen spürbar sein. Daher kann es eine sinnvolle Optimierung sein, ein Modul zu schützen, sobald Sie sicher sind, dass Sie es nicht mehr laden müssen. Beachten Sie außerdem, dass die Modulsperre nicht nur Plugins betrifft, sondern auch alle anderen „qmldir“-Anweisungen wie „ import “ oder „ prefer “ sowie alle zusammengesetzten Typen oder Skripte, die in einer „ qmldir “-Datei deklariert sind.

Darüber hinaus führt nach dem Aufruf dieser Funktion jeder Versuch, C++-Typen unter dieser Kombination aus URI und Hauptversionsnummer zu registrieren, zu einem Laufzeitfehler.

Gibt „true“ zurück, wenn das Modul mit der Modulkennung „ uri “ und der Hauptversionsnummer „ majVersion “ gefunden und gesperrt wurde; andernfalls wird „false“ zurückgegeben. Das Modul muss exportierte Typen enthalten, damit es gefunden werden kann.

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

Diese Vorlagenfunktion registriert den C++-Typ im QML-System als anonymen Typ. Der daraus resultierende QML-Typ hat keinen Namen. Daher können Instanzen dieses Typs nicht über das QML-System erstellt werden. Sie können jedoch auf Instanzen des Typs zugreifen, wenn diese als Eigenschaften anderer Typen verfügbar gemacht werden.

Verwenden Sie diese Funktion, wenn der Typ nicht namentlich referenziert wird, insbesondere für C++-Typen, die auf der linken Seite einer Eigenschaftsbindung verwendet werden. Um anzugeben, zu welchem Modul der Typ gehört, verwenden Sie uri und versionMajor.

Betrachten Sie beispielsweise die folgenden beiden Klassen:

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

In QML weisen wir der Eigenschaft „ baz “ von „ bar “ eine Zeichenkette zu:

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

Damit die QML-Engine weiß, dass der Typ „ Bar “ über eine Eigenschaft „ baz “ verfügt, müssen wir „ Bar “ bekannt machen:

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

Da der Typ „ Foo “ in QML instanziiert wird, muss er bei der Version von „ qmlRegisterType()“ registriert werden, die einen Elementnamen akzeptiert.

Gibt die QML-Typ-ID zurück.

Siehe auch „ QML_ANONYMOUS “ und „Auswahl der richtigen Integrationsmethode zwischen C++ und QML“.

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

Diese Vorlagenfunktion registriert den C++-Typ und sein Erweiterungsobjekt im QML-System unter dem Namen „ qmlName “ in der Bibliothek, die von uri importiert wird und deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt. Eigenschaften, die im Haupttyp nicht verfügbar sind, werden im Erweiterungsobjekt gesucht.

Gibt die QML-Typ-ID zurück.

Siehe auch QML_EXTENDED(), qmlRegisterType() und „Registrieren von Erweiterungsobjekten“.

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

Diese Vorlagenfunktion registriert den C++-Typ und dessen Erweiterung im QML-System unter dem Namen „ qmlName “ in der aus uri importierten Bibliothek, deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt.

Der Typ verfügt zwar über einen Namen und einen Typ, kann jedoch nicht erstellt werden. Wenn der Benutzer versucht, eine Instanz dieses Typs zu erstellen, wird eine Fehlermeldung mit dem angegebenen reason ausgegeben.

Dies ist nützlich, wenn der Typ ausschließlich dazu dient, angehängte Eigenschaften, Enum-Werte oder eine abstrakte Basisklasse mit ihrer Erweiterung bereitzustellen.

Gibt die QML-Typ-ID zurück.

Siehe auch „ QML_EXTENDED()“, „ QML_UNCREATABLE()“ und „ qmlRegisterUncreatableType()“.

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

Diese Funktion registriert ein Modul in einem bestimmten „ uri “ mit einer Version, die unter versionMajor und versionMinor angegeben ist.

Dies kann genutzt werden, um eine bestimmte Modulversion verfügbar zu machen, auch wenn für diese Version keine Typen registriert sind. Dies ist besonders nützlich, um die Versionen verwandter Module synchron zu halten.

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

Registriert einen qmldir-Import für das Modul „ uri “ der Hauptversion „ moduleMajor “.

Dies hat denselben Effekt wie eine ` import `-Anweisung in einer `qmldir`-Datei: Immer wenn ` uri ` der Version ` moduleMajor ` importiert wird, wird auch ` import ` der Version ` importMajor`. ` importMinor ` wird ebenfalls automatisch importiert. Wenn ` importMajor ` gleich ` QQmlModuleImportLatest ` ist, wird die neueste verfügbare Version dieses Moduls importiert, und ` importMinor ` spielt keine Rolle. Wenn ` importMinor ` gleich ` QQmlModuleImportLatest ` ist, wird die neueste Nebenversion von ` importMajor ` ausgewählt. Wenn ` importMajor ` gleich ` QQmlModuleImportAuto ` ist, entspricht die Version von ` import ` der Version von ` uri `, die importiert wird, und ` importMinor ` spielt keine Rolle. Wenn moduleMajor gleich QQmlModuleImportModuleAny ist, gilt der Modulimport für jede Hauptversion von uri. Sie können beispielsweise festlegen, dass immer dann, wenn eine beliebige Version von „MyModule“ importiert wird, die neueste Version von „MyOtherModule“ importiert werden soll. In diesem Fall wäre der folgende Aufruf angemessen:

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

Oder Sie können festlegen, dass immer dann, wenn die Hauptversion 5 von „MyModule“ importiert wird, die Version 3.14 von „MyOtherModule“ importiert werden soll:

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

Wenn Sie schließlich immer dieselbe Version von „MyOtherModule“ importieren möchten, sobald „MyModule“ importiert wird, geben Sie Folgendes an:

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

Siehe auch qmlUnregisterModuleImport().

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

Diese Vorlagenfunktion registriert den C++-Typ „ T “ unter der angegebenen Revision „ metaObjectRevision “ im QML-System, wobei die aus „ uri “ importierte Bibliothek die Versionsnummer verwendet, die sich aus „ versionMajor “ und „ versionMinor “ zusammensetzt.

Gibt die QML-Typ-ID zurück.

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

Diese Funktion wird in der Regel verwendet, um die Revision einer Basisklasse zu registrieren, die für die angegebene Version des Typs verwendet werden soll (siehe Typrevisionen und -versionen).

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

Diese Funktion dient dazu, ein Singleton-Objekt cppObject mit einem bestimmten uri und typeName zu registrieren. Seine Version setzt sich aus versionMajor und versionMinor zusammen.

Durch die Einbindung eines Singleton-Typs in eine URI können Sie dem QML-Code beliebige Funktionen (Methoden und Eigenschaften) zur Verfügung stellen, ohne dass einzelne Instanzen des Typs vom Client instanziiert werden müssen.

Verwenden Sie diese Funktion, um ein Objekt des angegebenen Typs T als Singleton-Typ zu registrieren.

Ein Singleton-Typ vom Typ „ QObject “ kann über den Typnamen referenziert werden, unter dem er registriert wurde; dieser Typname kann wiederum als Ziel in einem Typ vom Typ „ Connections “ oder wie jede andere Typ-ID verwendet werden. Es gibt jedoch eine Ausnahme: Eine Eigenschaft vom Typ „ QObject “ kann nicht mit einem Alias versehen werden, da der Name des Singleton-Typs kein Objekt innerhalb derselben Komponente wie ein anderes Element identifiziert.

HINWEIS: `qmlRegisterSingleton` kann nur verwendet werden, wenn alle Typen dieses Moduls prozedural registriert sind.

Verwendung:

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

Um den registrierten Singleton-Typ in QML zu verwenden, müssen Sie die URI mit der entsprechenden Version importieren.

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

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

Siehe auch „QML_SINGLETON“ und „ qmlRegisterSingletonType “.

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

Diese Funktion kann verwendet werden, um einen Singleton-Typ mit dem Namen „ qmlName “ in der aus uri importierten Bibliothek zu registrieren, deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt. Der Typ wird durch die QML-Datei definiert, die sich unter url befindet. Die URL muss eine absolute URL sein, d. h. url.isRelative() == false.

Zudem muss die QML-Datei des Typs unter ihren Import-Anweisungen die Anweisung `pragma Singleton` enthalten.

Ein Singleton-Typ kann über den Typnamen referenziert werden, unter dem er registriert wurde, und dieser Typname kann als Ziel in einem „ Connections “-Typ oder anderweitig wie jede andere Typ-ID verwendet werden. Eine Ausnahme bildet dabei, dass eine Eigenschaft eines Singleton-Typs nicht mit einem Alias versehen werden darf (da der Name des Singleton-Typs kein Objekt innerhalb derselben Komponente wie ein anderes Element identifiziert).

Verwendung:

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

Um den registrierten Singleton-Typ in QML zu verwenden, müssen Sie den Singleton-Typ importieren.

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

Es ist auch möglich, QML-Singleton-Typen zu registrieren, ohne die Funktion `qmlRegisterSingletonType` zu verwenden. Dies kann durch Hinzufügen einer `pragma Singleton`-Anweisung unter den Importen der QML-Datei des Typs erfolgen. Außerdem muss der Typ in einer `qmldir`-Datei mit dem Schlüsselwort `singleton` definiert sein, und die `qmldir`-Datei muss von den QML-Dateien importiert werden, die den Singleton verwenden.

Siehe auch QML_SINGLETON.

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

Diese Funktion kann verwendet werden, um einen Singleton-Typ-Anbieter callback in einem bestimmten uri und typeName mit einer in versionMajor und versionMinor angegebenen Version zu registrieren.

Die Installation eines Singleton-Typs ermöglicht es Entwicklern, einem Client beliebige Funktionalitäten (Methoden und Eigenschaften) bereitzustellen, ohne dass einzelne Instanzen des Typs vom Client instanziiert werden müssen.

Ein Singleton-Typ kann entweder ein „ QObject “ oder ein „ QJSValue “ sein. Diese Funktion sollte verwendet werden, um eine Singleton-Typ-Provider-Funktion zu registrieren, die ein „ QJSValue “ als Singleton-Typ zurückgibt.

HINWEIS: Eigenschaften von Singleton-Typen vom Typ „ QJSValue “ lösen bei einer Änderung keine Neubewertung der Bindung aus.

Verwendung:

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

Alternativ können Sie ein C++11-Lambda verwenden:

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

Um den registrierten Singleton-Typ in QML zu verwenden, müssen Sie den Singleton-Typ importieren.

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

Siehe auch QML_SINGLETON und Auswahl der richtigen Integrationsmethode zwischen C++ und QML.

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

Diese Funktion kann verwendet werden, um einen Singleton-Typ-Anbieter callback in einem bestimmten uri und typeName mit einer in versionMajor und versionMinor angegebenen Version zu registrieren.

Die Installation eines Singleton-Typs in einer URI ermöglicht es Entwicklern, Clients beliebige Funktionalitäten (Methoden und Eigenschaften) zur Verfügung zu stellen, ohne dass einzelne Instanzen des Typs vom Client instanziiert werden müssen.

Ein Singleton-Typ kann entweder ein „ QObject “ oder ein „ QJSValue “ sein. Diese Funktion sollte verwendet werden, um eine Singleton-Typ-Provider-Funktion zu registrieren, die ein „ QObject “ des angegebenen Typs T als Singleton-Typ zurückgibt.

Ein Singleton-Typ vom Typ „ QObject “ kann über den Typnamen referenziert werden, unter dem er registriert wurde, und dieser Typname kann als Ziel in einem Typ vom Typ „ Connections “ oder anderweitig wie jede andere Typ-ID verwendet werden. Eine Ausnahme bildet dabei, dass eine Singleton-Typ-Eigenschaft vom Typ „ QObject “ nicht mit einem Alias versehen werden darf.

HINWEIS: Eine vom Singleton-Typ-Anbieter zurückgegebene Instanz des Singleton-Typs „ QObject “ gehört der QML-Engine, es sei denn, für das Objekt ist explizit das Flag „QQmlEngine::CppOwnership“ gesetzt.

Verwendung:

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

Alternativ können Sie ein C++11-Lambda verwenden:

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

Um den registrierten Singleton-Typ in QML zu verwenden, müssen Sie den Singleton-Typ importieren.

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

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

Siehe auch QML_SINGLETON und Auswahl der richtigen Integrationsmethode zwischen C++ und QML.

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

Diese Vorlagenfunktion registriert den C++-Typ im QML-System unter dem Namen „ qmlName “ in der Bibliothek, die von uri importiert wird und deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt.

Gibt die QML-Typ-ID zurück.

Es gibt zwei Formen dieser Vorlagenfunktion:

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

Die erste ist die Standardform, die den Typ T als neuen Typ registriert. Die zweite ermöglicht es, eine bestimmte Revision einer Klasse in einer angegebenen Version zu registrieren (siehe Typ-Revisionen und Versionen).

Beispielsweise registriert dies eine C++-Klasse „ MySliderItem “ als QML-Typ mit dem Namen „ Slider “ für Version 1.0 eines Typnamensraums namens „com.mycompany.qmlcomponents“:

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

Sobald dies registriert ist, kann der Typ in QML verwendet werden, indem der angegebene Typnamensraum und die Versionsnummer importiert werden:

import com.mycompany.qmlcomponents 1.0

Slider {
    // ...
}

Beachten Sie, dass es durchaus sinnvoll ist, wenn eine Bibliothek Typen für ältere Versionen als die aktuelle Version der Bibliothek registriert. Tatsächlich ist es üblich, dass die neue Bibliothek die Kompatibilität mit QML-Code gewährleistet, der für frühere Versionen geschrieben wurde, auch wenn für einige ihrer Typen bereits fortgeschrittenere Versionen verfügbar sind.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“ und „Choosing the Correct Integration Method Between C++ and QML“.

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

Diese Funktion registriert einen Typ im QML-System unter dem Namen „ qmlName “ in der Bibliothek, die von uri importiert wird und deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt. Der Typ wird durch die QML-Datei definiert, die sich unter url befindet. Die URL muss eine absolute URL sein, d. h. url.isRelative() == false.

Normalerweise können QML-Dateien direkt aus anderen QML-Dateien oder mithilfe einer qmldir-Datei als Typen geladen werden. Diese Funktion ermöglicht die Registrierung von Dateien als Typen aus C++-Code heraus, beispielsweise wenn die Typzuordnung beim Start prozedural ermittelt werden muss.

Gibt -1 zurück, wenn die Registrierung nicht erfolgreich war.

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

Diese Funktion registriert einen Typ im QML-System unter dem Namen „ qmlName “ im Typ-Namespace, der aus „ uri “ importiert wird, wobei die Versionsnummer sich aus „ versionMajor “ und „ versionMinor “ zusammensetzt; jeder Versuch, den Typ zu instanziieren, führt jedoch zu der angegebenen Fehlermeldung „ message “.

Normalerweise sollten die von einem Plugin exportierten Typen feststehen. Sollte ein C++-Typ jedoch nicht verfügbar sein, sollten Sie zumindest den QML-Typnamen „reservieren“ und dem Benutzer des nicht verfügbaren Typs eine aussagekräftige Fehlermeldung anzeigen.

Gibt die QML-Typ-ID zurück.

Beispiel:

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

Dies führt dazu, dass jeder QML-Code, der den Typ-Namespace „MinehuntCore“ importiert und versucht, den Typ zu verwenden, eine Fehlermeldung ausgibt:

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

Ohne diese Maßnahme würde eine allgemeine Fehlermeldung wie „Game ist kein Typ“ ausgegeben werden.

Siehe auch „ QML_UNAVAILABLE“ , „ qmlRegisterUncreatableType()“ und „Auswahl der richtigen Integrationsmethode zwischen C++ und QML“.

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

Diese Funktion registriert das staticMetaObject und dessen Erweiterung im QML-System unter dem Namen qmlName in der aus uri importierten Bibliothek, deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt.

Eine Instanz des Metaobjekts kann nicht erstellt werden. Wenn der Benutzer versucht, eine solche Instanz zu erstellen, wird eine Fehlermeldung mit dem angegebenen reason ausgegeben.

Diese Funktion ist nützlich für die Registrierung von Q_NAMESPACE -Namespaces.

Gibt die QML-Typ-ID zurück.

Beispiel:

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

Auf der QML-Seite können Sie nun die registrierten Enums verwenden:

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

Siehe auch ` QML_ELEMENT`, ` QML_NAMED_ELEMENT()` und ` QML_UNCREATABLE()`.

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

Diese Vorlagenfunktion registriert den C++-Typ im QML-System unter dem Namen „ qmlName “ in der Bibliothek, die von uri importiert wird und deren Versionsnummer sich aus versionMajor und versionMinor zusammensetzt.

Der Typ verfügt zwar über einen Namen und einen Typ, kann jedoch nicht erstellt werden; bei einem Erstellungsversuch wird der Fehler „ message “ ausgegeben.

Dies ist nützlich, wenn der Typ ausschließlich dazu dient, angehängte Eigenschaften oder Enum-Werte bereitzustellen.

Gibt die QML-Typ-ID zurück.

Siehe auch QML_UNCREATABLE(), qmlRegisterTypeNotAvailable() und Auswahl der richtigen Integrationsmethode zwischen C++ und QML.

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

Gibt die QML-Typ-ID eines Typs zurück, der unter dem Namen „ qmlName “ in einem bestimmten „ uri “ registriert wurde und dessen Version unter „ versionMajor “ und „ versionMinor “ angegeben ist.

Diese Funktion gibt denselben Wert zurück wie die QML-Typregistrierungsfunktionen, z. B. ` qmlRegisterType()` und ` qmlRegisterSingletonType()`.

Wenn qmlName, uri und versionMajor mit einem registrierten Typ übereinstimmen, die in versionMinor angegebene Nebenversion jedoch höher ist, wird die ID des Typs mit der nächstgelegenen Nebenversion zurückgegeben.

Gibt -1 zurück, wenn kein passender Typ gefunden wurde oder einer der angegebenen Parameter ungültig war.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT “, „QML_SINGLETON“, „ qmlRegisterType()“ und „ qmlRegisterSingletonType()“.

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

Entfernt einen zuvor mit qmlRegisterModuleImport() registrierten Modulimport

Der Aufruf dieser Funktion stellt sicher, dass „ import “ der Version „ importMajor.importMinor “ nicht mehr automatisch importiert wird, wenn „ uri “ der Version „ moduleMajor “ importiert wird. Die Versionsauflösung funktioniert genauso wie bei „ qmlRegisterModuleImport()“.

Siehe auch qmlRegisterModuleImport().