QQmlEngine Class

Verwandte Nicht-Mitglieder

enum QQmlModuleImportSpecialVersions

Definiert einige spezielle Werte, die an die Versionsargumente von qmlRegisterModuleImport() und qmlUnregisterModuleImport() übergeben werden können.

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

Die Form dieser Vorlagenfunktion ist:

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

Sie gibt die angehängte Objektinstanz zurück, die an die angegebene attachee durch den anhängenden Typ T angehängt wurde.

Wenn create wahr ist und Typ T ein gültiger anhängender Typ ist, wird eine neue angehängte Objektinstanz erstellt und zurückgegeben.

Gibt nullptr zurück, wenn Typ T kein gültiger anhängender Typ ist, oder wenn create falsch ist und zuvor keine angehängte Objektinstanz für attachee erstellt wurde.

Siehe auch QML_ATTACHED() und Providing Attached Properties.

void qmlClearTypeRegistrations()

Löscht alle gespeicherten Typregistrierungen, wie die mit qmlRegisterType() erzeugten.

Rufen Sie diese Funktion nicht auf, solange eine QQmlEngine existiert, sonst ist das Verhalten undefiniert. Alle vorhandenen QQmlEngines müssen vor dem Aufruf dieser Funktion gelöscht werden. Diese Funktion betrifft nur den globalen Cache der Anwendung. Löschen Sie die QQmlEngine, um alle gecachten Daten zu löschen, die sich auf diese Engine beziehen.

QQmlContext *qmlContext(const QObject *object)

Gibt die QQmlContext zurück, die mit object verbunden ist, falls vorhanden. Dies ist gleichbedeutend mit QQmlEngine::contextForObject(Objekt).

Siehe auch contextForObject() und qmlEngine().

QQmlEngine *qmlEngine(const QObject *object)

Gibt die QQmlEngine zurück, die mit object verbunden ist, falls vorhanden. Dies entspricht QQmlEngine::contextForObject(Objekt)->engine(), ist aber effizienter.

Siehe auch contextForObject() und qmlContext().

bool qmlProtectModule(const char *uri, int majVersion)

Diese Funktion schützt ein Modul vor weiteren Änderungen. Dies kann verwendet werden, um zu verhindern, dass andere Plugins Typen in Ihr Modul injizieren. Es kann auch eine Leistungsverbesserung sein, da es der Engine erlaubt, die Überprüfung auf die Möglichkeit neuer Typen oder Plugins zu überspringen, wenn dieser Import erreicht ist.

Sobald qmlProtectModule aufgerufen wurde, wird eine QML-Engine nicht mehr nach einer neuen qmldir Datei suchen, um das Modul zu laden. Sie wird jedoch alle qmldir Dateien, die sie zuvor geladen hat, wiederverwenden. Daher funktionieren Typen, die zu diesem Zeitpunkt vorhanden sind, weiterhin. Beachten Sie, dass verschiedene QML-Engines unterschiedliche Module laden können. Der Modulschutz ist jedoch global und betrifft alle Engines. Der Overhead beim Auffinden von qmldir Dateien und beim Laden von Plugins kann sich bei langsamen Dateisystemen bemerkbar machen. Daher kann es eine gute Optimierung sein, ein Modul zu schützen, wenn Sie sicher sind, dass Sie es nicht mehr laden müssen. Beachten Sie auch, dass die Modulsperre nicht nur Plugins betrifft, sondern auch alle anderen qmldir-Direktiven, 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 in dieser Kombination aus uri und Hauptversion zu registrieren, zu einem Laufzeitfehler.

Gibt true zurück, wenn das Modul mit uri als Modulbezeichner und majVersion als Hauptversionsnummer gefunden und gesperrt wurde; andernfalls wird false zurückgegeben. Das Modul muss exportierte Typen enthalten, um gefunden zu werden.

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

Diese Vorlagenfunktion registriert den C++-Typ im QML-System als anonymen Typ. Der 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 sie als Eigenschaften anderer Typen exponiert sind.

Verwenden Sie diese Funktion, wenn der Typ nicht über den Namen 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 wir zum Beispiel die folgenden zwei 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 einen String zu:

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

Damit die QML-Engine weiß, dass der Typ Bar eine Eigenschaft baz hat, 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 mit der Version von qmlRegisterType() registriert werden, die einen Elementnamen annimmt.

Gibt die QML-Typ-ID zurück.

Siehe auch QML_ANONYMOUS und Auswahl der korrekten 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 mit dem Namen qmlName in der von uri importierten Bibliothek mit einer aus versionMajor und versionMinor zusammengesetzten Versionsnummer. 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 Registrierung 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 seine Erweiterung im QML-System mit dem Namen qmlName in der von uri importierten Bibliothek mit einer aus versionMajor und versionMinor zusammengesetzten Versionsnummer.

Solange der Typ einen Namen und einen Typ hat, kann er 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 nur für die Bereitstellung von angehängten Eigenschaften, Enum-Werten oder einer abstrakten Basisklasse mit ihrer Erweiterung gedacht ist.

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 in versionMajor und versionMinor angegebenen Version.

Auf diese Weise kann eine bestimmte Modulversion verfügbar gemacht werden, auch wenn keine Typen für diese Version registriert sind. Dies ist besonders nützlich, um die Versionen von verwandten Modulen 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 die gleiche Wirkung wie eine import -Anweisung in einer qmldir-Datei: Immer wenn uri der Version moduleMajor importiert wird, wird import der Version importMajor. importMinor automatisch mit importiert. Wenn importMajor QQmlModuleImportLatest ist, wird die letzte verfügbare Version dieses Moduls importiert, und importMinor spielt keine Rolle. Wenn importMinor QQmlModuleImportLatest ist, wird die letzte Nebenversion von importMajor gewählt. Wenn importMajor QQmlModuleImportAuto ist, ist die Version von import die Version von uri, die importiert wird, und importMinor spielt keine Rolle. Wenn moduleMajor gleich QQmlModuleImportModuleAny ist, wird der Modulimport auf jede Hauptversion von uri angewendet. Sie können zum Beispiel angeben, dass immer dann, wenn eine Version von MyModule importiert wird, die neueste Version von MyOtherModule importiert werden soll. Dann 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 wollen, dass immer dieselbe Version von "MyOtherModule" importiert wird, wenn "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 Template-Funktion registriert die angegebene Revision eines C++-Typs im QML-System mit der von uri importierten Bibliothek, deren Versionsnummer 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 typischerweise 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 wird verwendet, um ein Singleton-Objekt cppObject mit einem bestimmten uri und typeName zu registrieren. Seine Version ist eine Kombination aus versionMajor und versionMinor.

Die Installation eines Singleton-Typs in einer URI ermöglicht es Ihnen, QML-Code beliebige Funktionalität (Methoden und Eigenschaften) zur Verfügung zu 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 QObject Singleton-Typ kann über den Typnamen, mit dem er registriert wurde, referenziert werden; dieser Typname kann wiederum als Ziel in einem Connections -Typ oder wie jede andere Typ-ID verwendet werden. Es gibt jedoch eine Ausnahme: eine QObject Singleton-Typ-Eigenschaft kann nicht aliasiert werden, da der Singleton-Typ-Name kein Objekt innerhalb der gleichen Komponente identifiziert wie jedes andere Element.

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 von uri importierten Bibliothek mit der aus versionMajor und versionMinor zusammengesetzten Versionsnummer zu registrieren. 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.

Außerdem muss die QML-Datei des Typs in ihren Import-Anweisungen die Anweisung pragma Singleton enthalten.

Ein Singleton-Typ kann über den Typnamen referenziert werden, mit dem er registriert wurde, und dieser Typname kann als Ziel in einem Connections -Typ oder auf andere Weise wie jede andere Typ-ID verwendet werden. Eine Ausnahme hiervon ist, dass eine Eigenschaft eines Singleton-Typs nicht aliasiert werden darf (weil der Name des Singleton-Typs ein Objekt innerhalb derselben Komponente nicht mit einem anderen 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 verwenden zu können, 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 registrieren zu lassen, ohne die Funktion qmlRegisterSingletonType zu verwenden. Dies kann durch Hinzufügen einer pragma Singleton-Anweisung zu den Importen der QML-Datei des Typs geschehen. Zusätzlich muss der Typ in einer qmldir-Datei mit einem Singleton-Schlüsselwort definiert sein und die qmldir-Datei muss von den QML-Dateien, die das Singleton verwenden, importiert werden.

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 einer 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ät (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-Anbieterfunktion zu registrieren, die einen QJSValue als Singleton-Typ zurückgibt.

HINWEIS: QJSValue Singleton-Typ-Eigenschaften lösen bei Änderung keine erneute Bindungsevaluierung 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 auch 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 verwenden zu können, 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 korrekten 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 einer 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, beliebige Funktionalität (Methoden und Eigenschaften) für Clients 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 QObject des gegebenen Typs T als Singleton-Typ zurückgibt.

Ein QObject Singleton-Typ kann über den Typnamen referenziert werden, mit dem er registriert wurde, und dieser Typname kann als Ziel in einem Connections -Typ oder auf andere Weise wie jede andere Typ-ID verwendet werden. Eine Ausnahme hiervon ist, dass eine QObject singleton type Eigenschaft nicht aliasiert werden darf.

HINWEIS: Eine QObject Singleton-Typ-Instanz, die von einem Singleton-Typ-Anbieter zurückgegeben wird, gehört der QML-Engine, es sei denn, das Objekt hat ein explizites QQmlEngine::CppOwnership-Flag 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 auch 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 verwenden zu können, 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 korrekten Integrationsmethode zwischen C++ und QML.

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

Diese Template-Funktion registriert den C++-Typ im QML-System mit dem Namen qmlName, in der von uri importierten Bibliothek mit der Versionsnummer, die 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. Mit der zweiten Form kann eine bestimmte Revision einer Klasse in einer bestimmten Version registriert werden (siehe Typrevisionen und Versionen).

So wird beispielsweise eine C++-Klasse MySliderItem als QML-Typ mit dem Namen Slider für Version 1.0 eines Typ-Namensraums namens "com.mycompany.qmlcomponents" registriert:

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 möglich ist, dass eine Bibliothek Typen für ältere Versionen als die aktuelle Version der Bibliothek registriert. In der Tat ist es normal, dass die neue Bibliothek QML, das für frühere Versionen geschrieben wurde, weiterhin funktionieren lässt, selbst wenn fortgeschrittenere Versionen einiger ihrer Typen verfügbar sind.

Siehe auch QML_ELEMENT, QML_NAMED_ELEMENT(), und Auswahl der richtigen Integrationsmethode zwischen C++ und QML.

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

Diese Funktion registriert einen Typ im QML-System mit dem Namen qmlName, in der von uri importierten Bibliothek mit der aus versionMajor und versionMinor zusammengesetzten Versionsnummer. 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 als Typen direkt aus anderen QML-Dateien oder über eine qmldir-Datei geladen werden. Diese Funktion ermöglicht die Registrierung von Dateien zu Typen aus C++-Code, z. B. wenn die Typzuordnung beim Start prozedural bestimmt 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 mit dem Namen qmlName, im Typ-Namensraum, der von uri importiert wurde und die Versionsnummer hat, die sich aus versionMajor und versionMinor zusammensetzt, aber jeder Versuch, den Typ zu instanziieren, führt zu dem angegebenen Fehler message.

Normalerweise sollten die von einem Plugin exportierten Typen fest sein. Wenn jedoch ein C++-Typ nicht verfügbar ist, sollten Sie zumindest den QML-Typnamen "reservieren" und dem Benutzer des nicht verfügbaren Typs eine sinnvolle Fehlermeldung geben.

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 jede QML, die den "MinehuntCore"-Typ-Namensraum importiert und versucht, den Typ zu verwenden, eine Fehlermeldung erzeugt:

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

Ohne dies würde eine allgemeine "Game is not a type"-Meldung 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 die staticMetaObject und ihre Erweiterung im QML-System mit dem Namen qmlName in der von uri importierten Bibliothek mit der Versionsnummer, die sich aus versionMajor und versionMinor zusammensetzt.

Eine Instanz des Meta-Objekts kann nicht erstellt werden. Eine Fehlermeldung mit dem angegebenen reason wird ausgegeben, wenn der Benutzer versucht, es zu erstellen.

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

Gibt die QML-Typ-ID zurück.

Zum 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 mit dem Namen qmlName in der von uri importierten Bibliothek mit der Versionsnummer, die sich aus versionMajor und versionMinor zusammensetzt.

Der Typ hat zwar einen Namen und einen Typ, kann aber nicht erstellt werden, und der angegebene Fehler message wird ausgegeben, wenn versucht wird, ihn zu erstellen.

Dies ist nützlich, wenn der Typ nur dazu gedacht ist, 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 mit dem Namen qmlName in einem bestimmten uri und einer in versionMajor und versionMinor angegebenen Version registriert wurde.

Diese Funktion gibt denselben Wert zurück wie die QML-Typenregistrierungsfunktionen wie qmlRegisterType() und qmlRegisterSingletonType().

Wenn qmlName, uri und versionMajor mit einem registrierten Typ übereinstimmen, aber die in versionMinor angegebene Minor-Version höher ist, dann wird die ID des Typs mit der nächstliegenden Minor-Version 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 auf die gleiche Weise wie bei qmlRegisterModuleImport().

Siehe auch qmlRegisterModuleImport().