<qqmlintegration.h>

Makro-Dokumentation

QML_ADDED_IN_VERSION(MAJOR, MINOR)

Gibt an, dass der übergeordnete Typ oder Namespace in der angegebenen Version MAJOR.MINOR hinzugefügt wurde. Es wird davon ausgegangen, dass die Version mit allen Revisionen übereinstimmt, die durch die Makros Q_REVISION() bei Methoden, Slots oder Signalen sowie durch alle REVISION()-Attribute bei Eigenschaften angegeben werden, die mit Q_PROPERTY() deklariert wurden.

QML_ADDED_IN_VERSION() wirkt sich nur aus, wenn der Typ oder Namespace in QML verfügbar ist, d. h. wenn ein Makro vom Typ „ QML_ELEMENT “, „ QML_NAMED_ELEMENT()“, „ QML_ANONYMOUS “ oder „ QML_INTERFACE “ vorhanden ist.

Wird das QML-Modul, zu dem der Typ gehört, mit einer Version importiert, die niedriger ist als die auf diese Weise ermittelte, ist der QML-Typ nicht sichtbar.

Siehe auch „ QML_ELEMENT “ und „ QML_NAMED_ELEMENT “.

QML_ANONYMOUS

Deklariert den übergeordneten Typ als verfügbar, jedoch anonym in QML. Der Typ kann in QML weder erstellt noch zur Deklaration von Eigenschaften verwendet werden, wird jedoch erkannt, wenn er aus C++ übergeben wird. In QML können Sie Eigenschaften dieses Typs verwenden, sofern sie in C++ deklariert sind.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“, „ QML_UNCREATABLE()“ und „ QML_INTERFACE “.

QML_ATTACHED(ATTACHED_TYPE)

Legt fest, dass der umschließende Typ „ ATTACHED_TYPE “ als angehängte Eigenschaft an andere Typen anfügt. Dies tritt in Kraft, wenn der Typ über ein „ QML_ELEMENT “- oder „ QML_NAMED_ELEMENT()“-Makro für QML verfügbar gemacht wird.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“, „ qmlAttachedPropertiesObject()“ und „Bereitstellen von angehängten Eigenschaften“.

[since 6.5] QML_CONSTRUCTIBLE_VALUE

Kennzeichnet den umgebenden Werttyp als konstruierbar. Das bedeutet, dass alle Konstruktoren von Q_INVOKABLE dieses Typs, die genau ein Argument entgegennehmen, verwendet werden können, wenn ein JavaScript-Wert einer Eigenschaft dieses Typs zugewiesen wird.

Sie können einen konstruierbaren Werttyp wie folgt deklarieren:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_CONSTRUCTIBLE_VALUE
public:
    Q_INVOKABLE MyValueType(double d);

    // ...
};

Mit dem oben genannten Typ erzeugt der folgende QML-Code einen ` MyValueType `-Wert unter Verwendung des angegebenen Konstruktors und weist ihn der Eigenschaft zu.

QtObject {
    property myValueType v: 5.4
}

Auf diese Weise können Sie auch Listen von Werten erstellen:

QtObject {
    property list<myValueType> v: [5.4, 4.5, 3.3]
}

Seit Qt 6.8 können Sie, wenn Sie das QML-Modul, zu dem der Werttyp gehört, in einen Namensraum importieren, den JavaScript-Operator ` new ` verwenden, um ihn zu instanziieren.

import MyModule as MM

QtObject {
    function process(d: real) {
        let v = new MM.myValueType(d);
        // v is a myValueType now
    }
}

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch ` QML_VALUE_TYPE`.

QML_ELEMENT

Deklariert den übergeordneten Typ oder Namespace als in QML verfügbar, wobei dessen Klassen- oder Namespace-Name als QML-Elementname verwendet wird.

Dadurch wird beispielsweise die C++-Klasse „ Slider “ als QML-Typ mit dem Namen „ Slider “ verfügbar gemacht. Alle ihre Eigenschaften, aufrufbaren Methoden und Aufzählungen werden offengelegt.

class Slider : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged FINAL)
    // ...
public:
    enum Slippiness {
        Dry, Wet, Icy
    };
    Q_ENUM(Slippiness)

    Q_INVOKABLE void slide(Slippiness slippiness);

    // ...
}

Sie können das Build-System verwenden, um den Typ im Typ-Namespace `com.mycompany.qmlcomponents ` mit der Hauptversion ` 1` zu registrieren. Geben Sie für `qmake` Folgendes in Ihrer Projektdatei an:

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

Bei CMake übergeben Sie die URI und die Version an ` qt_add_qml_module()`

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

Nach der Registrierung kann der Typ in QML verwendet werden, indem derselbe Typ-Namespace und dieselbe Versionsnummer importiert werden:

import com.mycompany.qmlcomponents 1.0

Slider {
    value: 12
    Component.onCompleted: slide(Slider.Icy)

    // ...
}

Auf diese Weise können Sie auch Namespaces mit dem Tag „ Q_NAMESPACE “ verfügbar machen, um darin enthaltene Enums mit dem Tag „ Q_ENUM_NS “ zugänglich zu machen:

namespace MyNamespace {
  Q_NAMESPACE
  QML_ELEMENT

  enum MyEnum {
      Key1,
      Key2,
  };
  Q_ENUM_NS(MyEnum)
}

In QML können Sie die Enums dann wie folgt verwenden:

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

HINWEIS: Wenn Klassen denselben Namen haben, sich aber in unterschiedlichen Namespaces befinden, führt die Verwendung von `QML_ELEMENT` für beide zu einem Konflikt. Verwenden Sie stattdessen für eine der beiden unbedingt ` QML_NAMED_ELEMENT()`.

Siehe auch „Auswahl der richtigen Integrationsmethode zwischen C++ und QML“, „ QML_NAMED_ELEMENT()“, „ Q_REVISION()“ und „ QML_ADDED_IN_VERSION()“.

QML_EXTENDED(EXTENDED_TYPE)

Gibt an, dass der umschließende Typ „ EXTENDED_TYPE “ als Erweiterung verwendet, um weitere Eigenschaften, Methoden und Aufzählungen in QML bereitzustellen. Dies tritt in Kraft, wenn der Typ mithilfe eines Makros vom Typ „ QML_ELEMENT “ oder „ QML_NAMED_ELEMENT()“ für QML freigegeben wird.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“, „ QML_EXTENDED_NAMESPACE()“ und „Registrieren von Erweiterungsobjekten“.

QML_EXTENDED_NAMESPACE(EXTENSION_NAMESPACE)

Legt fest, dass der umschließende Typ „ EXTENSION_NAMESPACE “ als Erweiterung verwendet, um weitere Aufzählungen in QML bereitzustellen. Dies wird wirksam, wenn der Typ mithilfe eines Makros vom Typ „ QML_ELEMENT “ oder „ QML_NAMED_ELEMENT()“ für QML verfügbar gemacht wird. Damit dies funktioniert, müssen die Aufzählungen dem Metaobjektsystem zur Verfügung gestellt werden.

Nehmen wir beispielsweise den folgenden C++-Code

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

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

können wir in QML auf die Enumeration zugreifen:

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

Siehe auch „ QML_NAMESPACE_EXTENDED()“, „ QML_ELEMENT “, „ QML_NAMED_ELEMENT()“, „ QML_EXTENDED()“, „Registering Extension Objects“, „ Q_ENUM “ und „ Q_ENUM_NS “.

QML_EXTRA_VERSION(MAJOR, MINOR)

Geben Sie an, dass der Typ auch in der Version MAJOR.MINOR verfügbar sein soll. Dies kann hilfreich sein, wenn ein Typ in mehreren Hauptversionen verfügbar sein soll.

Typen werden automatisch registriert für:

• Die Hauptversion, in der sie eingeführt wurden, siehe QML_ADDED_IN_VERSION.
• Alle Hauptversionen, in denen ihre Mitglieder eingeführt wurden.
• Die aktuelle Hauptversion ihres Moduls, sofern sie nicht bereits zuvor unter QML_REMOVED_IN_VERSION registriert waren.

Beachten Sie insbesondere, dass sie nicht automatisch in PAST_MAJOR_VERSIONS zwischen den oben genannten Versionen registriert werden. Mit QML_EXTRA_VERSION können Sie Ihre Typen manuell in weiteren Hauptversionen registrieren.

Siehe auch QML_ELEMENT und QML_ADDED_IN_VERSION.

QML_FOREIGN(FOREIGN_TYPE)

Legt fest, dass alle Makros vom Typ „ QML_ELEMENT “, „ QML_NAMED_ELEMENT()“, „ QML_ANONYMOUS “, „ QML_INTERFACE “, „ QML_UNCREATABLE()“, „QML_SINGLETON“, „ QML_ADDED_IN_VERSION()“, „ QML_REMOVED_IN_VERSION()“, „ QML_ADDED_IN_MINOR_VERSION()“, „ QML_REMOVED_IN_MINOR_VERSION()“, „ QML_EXTENDED()“, „ QML_EXTENDED_NAMESPACE()“ oder „ QML_NAMESPACE_EXTENDED()“ im umschließenden C++-Typ nicht auf den umschließenden Typ, sondern stattdessen auf „ FOREIGN_TYPE “ angewendet werden. Der umschließende Typ muss weiterhin mithilfe eines Makros wie „ Q_GADGET “ oder „ Q_OBJECT “ beim Metaobjektsystem registriert werden.

Dies ist nützlich für die Registrierung von Typen, die nicht geändert werden können, um die Makros hinzuzufügen, beispielsweise weil sie zu Bibliotheken von Drittanbietern gehören. Informationen zur Registrierung eines Namensraums finden Sie unter QML_FOREIGN_NAMESPACE().

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“ und „ QML_FOREIGN_NAMESPACE()“.

QML_FOREIGN_NAMESPACE(FOREIGN_NAMESPACE)

Legt fest, dass alle Makros vom Typ „ QML_ELEMENT “, „ QML_NAMED_ELEMENT()“, „ QML_ANONYMOUS “, „ QML_INTERFACE “, „ QML_UNCREATABLE()“, „QML_SINGLETON“, „ QML_ADDED_IN_VERSION()“, „ QML_REMOVED_IN_VERSION()“, „ QML_ADDED_IN_MINOR_VERSION()“ oder „ QML_REMOVED_IN_MINOR_VERSION()“ im umgebenden C++-Namespace nicht für den umgebenden Typ gelten, sondern stattdessen für „ FOREIGN_NAMESPACE “. Der umgebende Namespace muss weiterhin mithilfe eines „ Q_NAMESPACE “-Makros beim Metaobjektsystem registriert werden.

Dies ist nützlich für die Registrierung von Namespaces, die nicht um die Makros erweitert werden können, beispielsweise weil sie zu Bibliotheken von Drittanbietern gehören.

Siehe auch QML_ELEMENT, QML_NAMED_ELEMENT() und QML_FOREIGN().

QML_IMPLEMENTS_INTERFACES(interfaces)

Dieses Makro teilt Qt mit, welche QML- interfaces die Klasse implementiert. Dieses Makro sollte nur für die Anbindung an Klassen verwendet werden, die QML_INTERFACE nutzen; andernfalls sollte Q_INTERFACES verwendet werden. Es ist erforderlich, damit die deklarative Registrierung über QML_ELEMENT ordnungsgemäß funktioniert.

Siehe auch QML_INTERFACE und Q_INTERFACES.

QML_INTERFACE

Dieses Makro registriert den übergeordneten C++-Typ im QML-System als Schnittstelle.

Typen, die in QML als Schnittstelle registriert sind, sollten sich auch im Metaobjektsystem als Schnittstelle deklarieren. Zum Beispiel:

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

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

Wenn sie auf diese Weise bei QML registriert sind, können sie als Eigenschaftstypen verwendet werden:

Q_PROPERTY(FooInterface *foo READ foo WRITE setFoo)

Wenn Sie dieser Eigenschaft eine Unterklasse von ` QObject ` zuweisen, führt die QML-Engine automatisch den Schnittstellen-Cast zu ` FooInterface* ` durch.

Schnittstellentypen sind in QML implizit anonym und können nicht instanziiert werden.

HINWEIS: Wenn Sie von Typen erben, die `QML_INTERFACE` verwenden, nutzen Sie ` QML_IMPLEMENTS_INTERFACES ` anstelle von ` Q_INTERFACES`.

Siehe auch QML_IMPLEMENTS_INTERFACES(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() und QML_ANONYMOUS.

QML_NAMED_ELEMENT(name)

Deklariert den übergeordneten Typ oder Namespace als in QML verfügbar, wobei „ name “ als Elementname verwendet wird. Ansonsten verhält sich die Funktion genauso wie „ QML_ELEMENT “.

class SqlEventDatabase : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(EventDatabase)

    // ...
};

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

QML_REMOVED_IN_VERSION(MAJOR, MINOR)

Gibt an, dass der übergeordnete Typ oder Namespace in der angegebenen Version von MAJOR.MINOR entfernt wurde. Dies ist vor allem dann nützlich, wenn die Implementierung eines QML-Typs ersetzt wird. Wenn ein entsprechendes ` QML_ADDED_IN_VERSION()` für einen anderen Typ oder Namespace mit demselben QML-Namen vorhanden ist, wird der entfernte Typ beim Importieren von Modulversionen verwendet, die kleiner oder gleich ` MAJOR` sind.MINOR Der hinzugefügte Typ wird hingegen beim Importieren von Modulversionen verwendet, die größer oder gleich ` MAJOR` sind.MINOR

QML_REMOVED_IN_VERSION() wirkt sich nur dann aus, wenn der Typ oder der Namespace in QML verfügbar ist, d. h. wenn ein Makro QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS oder QML_INTERFACE vorhanden ist.

Siehe auch „ QML_ELEMENT “ und „ QML_NAMED_ELEMENT “.

QML_SEQUENTIAL_CONTAINER(VALUE_TYPE)

Dieses Makro deklariert den umschließenden oder referenzierten Typ als sequenziellen Container, der eine Folge von „ VALUE_TYPE “-Elementen verwaltet. „ VALUE_TYPE “ kann ein tatsächlicher Werttyp oder ein Zeiger auf einen Objekttyp sein. Sie werden dieses Makro nur selten direkt in die eigentliche Container-Deklaration einfügen können, da Container in der Regel Vorlagen sind. Sie sollten „ QML_FOREIGN “ verwenden, um die Typregistrierung an eine Template-Instanziierung anzuhängen. Mit dieser Technik können Sie beispielsweise sequenzielle Container wie folgt deklarieren:

class IntDequeRegistration
{
  Q_GADGET
  QML_FOREIGN(std::deque<int>)
  QML_ANONYMOUS
  QML_SEQUENTIAL_CONTAINER(int)
};

Danach können Sie den Container in QML wie ein JavaScript-Array verwenden.

class Maze
{
  Q_OBJECT
  Q_ELEMENT
  // 0: North, 1: East, 2: South, 3: West
  Q_PROPERTY(std::deque<int> solution READ solution CONSTANT FINAL)
  [...]
}

Item {
  Maze {
    id: maze
  }

  function showSolution() {
      maze.solution.forEach([...])
  }
}

Siehe auch ` QML_ANONYMOUS ` und ` QML_FOREIGN()`.

QML_SINGLETON

Deklariert den umschließenden Typ in QML als Singleton. Dies wirkt sich nur aus, wenn es sich bei dem Typ um einen „ Q_OBJECT “ handelt und er in QML verfügbar ist (durch das Vorhandensein eines Makros „ QML_ELEMENT “ oder „ QML_NAMED_ELEMENT()“). Sofern der Typ nicht explizit mit dem Makro „ QML_UNCREATABLE()“ als nicht erstellbar markiert ist, versucht jede „ QQmlEngine “-Instanz beim ersten Zugriff auf den Typ, eine Singleton-Instanz zu erstellen – entweder mithilfe des Standardkonstruktors des Typs oder einer statischen Factory-Funktion mit der Signatur „ T *create(QQmlEngine *, QJSEngine *) “. Sind beide vorhanden und zugänglich, wird der Standardkonstruktor bevorzugt.

Wenn kein Standardkonstruktor und keine Factory-Funktion vorhanden ist und keine Instanz explizit über ` QQmlEngine::setExternalSingletonInstance ` in der Engine festgelegt wurde, ist das Singleton nicht zugänglich. Wenn die QML-Engine das Singleton instanziiert hat, übernimmt die Engine in der Regel die Verantwortung für das Singleton und löscht es, wenn die Engine selbst zerstört wird. Im Gegensatz dazu übernimmt die Engine nicht die Verantwortung für externe Singletons, es sei denn, sie wird ausdrücklich dazu angewiesen. Sie können dieses Verhalten steuern, indem Sie ` QJSEngine::setObjectOwnership()` auf das Singleton aufrufen, um das beabsichtigte Verhalten explizit festzulegen.

Um eine Klasse mit Standardkonstruktor als Singleton zu deklarieren, müssen Sie lediglich `QML_SINGLETON` hinzufügen:

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

Wenn die Singleton-Klasse nicht standardmäßig konstruierbar ist, Sie sie aber modifizieren können, können Sie ihr eine Factory-Funktion hinzufügen, um sie zugänglich zu machen:

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

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

    // members, Q_INVOKABLE functions, etc
};

Wenn Sie der Engine eine Instanz bereitstellen möchten, anstatt die Instanziierung bei Bedarf der Engine zu überlassen, können Sie das Makro ` QML_UNCREATABLE()` verwenden. In diesem Fall muss der Typ weder standardmäßig konstruierbar sein noch über eine Factory-Funktion verfügen:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    QML_UNCREATABLE("Provided by C++")
    // Q_PROPERTY( ... )
public:
    MySingleton(BackendObject* backend, QObject* parent);

    // members, Q_INVOKABLE functions, etc
};

Dazu muss vor dem ersten Zugriff auf das Singleton aus QML heraus eine Instanz von ` MySingleton ` über ` QQmlEngine::setExternalSingletonInstance() ` in der Engine festgelegt werden. Dies ist ein Ersatz für die Funktion ` qmlRegisterSingletonInstance `.

Wenn Sie die Klasse nicht ändern können und sie weder über einen Standardkonstruktor noch über eine geeignete Factory-Funktion verfügt, können Sie einen ` QML_FOREIGN `-Wrapper bereitstellen, um die Factory-Funktion zu definieren:

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

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

Der Ansatz mit ` QML_FOREIGN ` zur Deklaration eines Singletons, das Sie nicht ändern können, funktioniert auch in Kombination mit ` QML_UNCREATABLE()`. In diesem Fall ist keine Factory-Funktion erforderlich, aber wie zuvor muss die Instanz vor der ersten Verwendung in der Engine festgelegt werden:

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
    QML_UNCREATABLE("Provided from C++")
};

Siehe auch QML_ELEMENT, QML_NAMED_ELEMENT(), qmlRegisterSingletonInstance(), QQmlEngine::singletonInstance(), QQmlEngine::setExternalSingletonInstance() und Singletons in QML.

[since 6.5] QML_STRUCTURED_VALUE

Kennzeichnet den umgebenden Werttyp als strukturiert. Strukturierte Werttypen können und sollten vorzugsweise Eigenschaft für Eigenschaft aus einem JavaScript-Objekt aufgebaut werden. Ein strukturierter Werttyp ist jedoch immer auch ein „ QML_CONSTRUCTIBLE_VALUE “. Das bedeutet, dass Sie weiterhin „ Q_INVOKABLE “-Konstruktoren bereitstellen können, um die Erstellung aus primitiven Typen zu ermöglichen.

Sie können einen strukturierten Werttyp wie folgt deklarieren:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_STRUCTURED_VALUE
    Q_PROPERTY(double d READ d WRITE setD)
    Q_PROPERTY(string e READ e WRITE setE)

    // ...
};

Anschließend können Sie eine Eigenschaft dieses Typs wie folgt füllen:

QtObject {
    property myValueType v: ({d: 4.4, e: "a string"})
}

Die zusätzlichen Klammern sind erforderlich, um das JavaScript-Objekt von etwas zu unterscheiden, das als JavaScript-Codeblock interpretiert werden könnte.

Auf diese Weise können Sie auch Listen von Werten erstellen:

QtObject {
    property list<myValueType> v: [
        {d: 4.4, e: "a string"},
        {d: 7.1, e: "another string"}
    ]
}

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch QML_VALUE_TYPE und QML_CONSTRUCTIBLE_VALUE.

QML_UNAVAILABLE

Dieses Makro deklariert den übergeordneten Typ in QML als nicht verfügbar. Es registriert einen internen Dummy-Typ namens „ QQmlTypeNotAvailable “ als „ QML_FOREIGN()“-Typ unter Verwendung aller weiteren von Ihnen angegebenen QML-Makros.

Normalerweise sollten die von einem Modul exportierten Typen feststehen. 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 aussagekräftige Fehlermeldung anzeigen.

Beispiel:

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

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

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

Mit dieser Technik benötigen Sie lediglich eine ` Q_GADGET `-Struktur, um die Fehlermeldung anzupassen, und keine vollständige ` QObject`. Ohne ` QML_UNCREATABLE()` führt `QML_UNAVAILABLE` dennoch zu einer spezifischeren Fehlermeldung als das übliche „ist kein Typ“ bei völlig unbekannten Typen.

Siehe auch „ QML_ELEMENT“ , „ QML_NAMED_ELEMENT()“, „ QML_UNCREATABLE()“ und „ QML_FOREIGN()“.

QML_UNCREATABLE(reason)

Legt fest, dass der übergeordnete Typ nicht über QML erstellt werden darf. Dies tritt in Kraft, wenn der Typ in QML verfügbar ist, indem ein Makro „ QML_ELEMENT “ oder „ QML_NAMED_ELEMENT()“ vorhanden ist. Die Fehlermeldung „ reason “ wird ausgegeben, wenn versucht wird, den Typ über QML zu erstellen.

Einige QML-Typen sind implizit nicht erstellbar, insbesondere Typen, die mit ` QML_ANONYMOUS ` bereitgestellt werden, oder Namespaces, die mit ` QML_ELEMENT ` oder ` QML_NAMED_ELEMENT()` bereitgestellt werden.

Wenn es sich bei dem Typ um ein mit QML_SINGLETON deklariertes Singleton handelt, signalisiert das Hinzufügen von QML_UNCREATABLE die Zusage, dass eine Instanz des Typs explizit mithilfe von QQmlEngine::setExternalSingletonInstance in der Engine gesetzt wird.

Seit Qt 6.0 können Sie „“ anstelle eines Grundes verwenden, um stattdessen eine Standardmeldung zu verwenden.

Siehe auch QML_ELEMENT, QML_NAMED_ELEMENT() und QML_ANONYMOUS.

QML_VALUE_TYPE(name)

Deklariert den übergeordneten Typ oder Namespace in QML unter Verwendung von „ name “ als Namen. Der Typ muss ein Werttyp sein und der Name muss in Kleinbuchstaben geschrieben sein.

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)

    // ...
};

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