QQmlComponent Class

Dokumentation zu Mitgliedsfunktionen

QQmlComponent::QQmlComponent(QQmlEngine *engine, QObject *parent = nullptr)

Erstellen Sie eine QQmlComponent ohne Daten und weisen Sie ihr die angegebenen Werte für „ engine “ und „ parent “ zu. Legen Sie die Daten mit „ setData()“ fest.

QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName, QObject *parent = nullptr)

Erstellen Sie eine `QQmlComponent` aus dem angegebenen ` fileName ` und weisen Sie ihr die angegebenen ` parent ` und ` engine` zu.

Siehe auch loadUrl().

QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, QObject *parent = nullptr)

Erstellen Sie eine QQmlComponent aus der angegebenen ` url ` und übergeben Sie ihr die angegebenen ` parent ` und ` engine`.

Stellen Sie sicher, dass die angegebene URL vollständig und korrekt ist; verwenden Sie insbesondere QUrl::fromLocalFile() beim Laden einer Datei aus dem lokalen Dateisystem.

Relative Pfade werden relativ zu QQmlEngine::baseUrl() aufgelöst, was, sofern nicht anders angegeben, dem aktuellen Arbeitsverzeichnis entspricht.

Siehe auch loadUrl().

QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName, QQmlComponent::CompilationMode mode, QObject *parent = nullptr)

Erstellen Sie eine `QQmlComponent` aus dem angegebenen ` fileName ` und weisen Sie ihr die angegebenen ` parent ` und ` engine` zu. Wenn ` mode ` den Wert ` Asynchronous` hat, wird die Komponente asynchron geladen und kompiliert.

Siehe auch loadUrl().

QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, QQmlComponent::CompilationMode mode, QObject *parent = nullptr)

Erstellen Sie eine QQmlComponent aus dem angegebenen „ url “ und übergeben Sie ihr die angegebenen „ parent “ und „ engine “. Wenn „ mode “ auf „ Asynchronous “ gesetzt ist, wird die Komponente asynchron geladen und kompiliert.

Stellen Sie sicher, dass die angegebene URL vollständig und korrekt ist; verwenden Sie insbesondere QUrl::fromLocalFile(), wenn Sie eine Datei aus dem lokalen Dateisystem laden.

Relative Pfade werden relativ zu QQmlEngine::baseUrl() aufgelöst, was, sofern nicht anders angegeben, das aktuelle Arbeitsverzeichnis ist.

Siehe auch loadUrl().

[explicit, since 6.5] QQmlComponent::QQmlComponent(QQmlEngine *engine, QAnyStringView uri, QAnyStringView typeName, QObject *parent = nullptr)

Erstelle eine `QQmlComponent` aus den angegebenen ` uri ` und ` typeName ` und weise ihr die angegebenen ` parent ` und ` engine` zu. Wenn möglich, wird die Komponente synchron geladen.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` loadFromModule()`.

[explicit, since 6.5] QQmlComponent::QQmlComponent(QQmlEngine *engine, QAnyStringView uri, QAnyStringView typeName, QQmlComponent::CompilationMode mode, QObject *parent = nullptr)

Erstelle eine `QQmlComponent` aus den angegebenen ` uri ` und ` typeName ` und weise ihr die angegebenen ` parent ` und ` engine` zu. Wenn ` mode ` den Wert ` Asynchronous` hat, wird die Komponente asynchron geladen und kompiliert.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` loadFromModule()`.

[override virtual noexcept] QQmlComponent::~QQmlComponent()

Zerstöre den „ QQmlComponent “.

[virtual] QObject *QQmlComponent::beginCreate(QQmlContext *context)

Erstellt eine Objektinstanz dieser Komponente innerhalb des angegebenen ` context`. Gibt ` nullptr ` zurück, wenn die Erstellung fehlgeschlagen ist.

Wenn „ QQmlComponent “ eine Instanz erstellt, erfolgt dies in drei Schritten:

1. Die Objekthierarchie wird erstellt, und es werden konstante Werte zugewiesen.
2. Eigenschaftsbindungen werden zum ersten Mal ausgewertet.
3. Falls zutreffend, wird ` QQmlParserStatus::componentComplete()` für Objekte aufgerufen.

„QQmlComponent::beginCreate()“ unterscheidet sich von „ QQmlComponent::create()“ darin, dass es nur Schritt 1 ausführt. Um die Schritte 2 und 3 abzuschließen, muss „ QQmlComponent::completeCreate()“ aufgerufen werden.

Dieser Haltepunkt ist manchmal nützlich, wenn angehängte Eigenschaften verwendet werden, um Informationen an eine instanziierte Komponente zu übermitteln, da er es ermöglicht, deren Anfangswerte zu konfigurieren, bevor die Eigenschaftsbindungen wirksam werden.

Die Eigentumsrechte an der zurückgegebenen Objektinstanz werden auf den Aufrufer übertragen.

Siehe auch completeCreate() und QQmlEngine::ObjectOwnership.

[virtual] void QQmlComponent::completeCreate()

Diese Methode ermöglicht eine erweiterte Steuerung bei der Erstellung von Komponenteninstanzen. Im Allgemeinen sollten Programmierer die Funktion „ QQmlComponent::create()“ verwenden, um eine Komponente zu erstellen.

Diese Funktion schließt die mit ` QQmlComponent::beginCreate()` begonnene Komponentenerstellung ab und muss anschließend aufgerufen werden.

Siehe auch ` beginCreate()`.

[virtual] QObject *QQmlComponent::create(QQmlContext *context = nullptr)

Erstellt eine Objektinstanz dieser Komponente innerhalb des angegebenen „ context “. Gibt „ nullptr “ zurück, wenn die Erstellung fehlgeschlagen ist.

Wenn „ context “ auf „ nullptr “ gesetzt ist (Standard), wird die Instanz im „ root context “ der Engine erstellt.

Die Eigentumsrechte an der zurückgegebenen Objektinstanz werden auf den Aufrufer übertragen.

Wenn es sich bei dem aus dieser Komponente erstellten Objekt um ein visuelles Element handelt, muss es ein visuelles übergeordnetes Element haben, das durch Aufruf von ` QQuickItem::setParentItem()` festgelegt werden kann. Weitere Details finden Sie unter „Konzepte – Visuelles übergeordnetes Element“ in Qt Quick.

Siehe auch „ QQmlEngine::ObjectOwnership “.

void QQmlComponent::create(QQmlIncubator &incubator, QQmlContext *context = nullptr, QQmlContext *forContext = nullptr)

Erstellen Sie mithilfe der bereitgestellten Methode „ incubator “ eine Objektinstanz aus dieser Komponente. „ context “ gibt den Kontext an, in dem die Objektinstanz erstellt werden soll.

Wenn ` context ` gleich ` nullptr ` ist (Standard), wird die Instanz im ` root context ` der Engine erstellt.

forContext Gibt einen Kontext an, von dem diese Objekterstellung abhängt. Wenn die „ forContext “ asynchron erstellt wird und die „ QQmlIncubator::IncubationMode “ auf „ QQmlIncubator::AsynchronousIfNested “ gesetzt ist, wird dieses Objekt ebenfalls asynchron erstellt. Wenn „ forContext “ auf „ nullptr “ gesetzt ist (Standard), wird die „ context “ für diese Entscheidung herangezogen.

Das erstellte Objekt und sein Erstellungsstatus sind über die Methode „ incubator “ abrufbar.

Siehe auch „ QQmlIncubator “.

QObject *QQmlComponent::createWithInitialProperties(const QVariantMap &initialProperties, QQmlContext *context = nullptr)

Erstellen Sie eine Objektinstanz dieser Komponente innerhalb der angegebenen „ context “ und initialisieren Sie deren Eigenschaften der obersten Ebene mit „ initialProperties “.

Wenn eine der Eigenschaften unter „ initialProperties “ nicht festgelegt werden kann, wird eine Warnung ausgegeben. Sind erforderliche Eigenschaften nicht festgelegt, schlägt die Objekterstellung fehl und gibt „ nullptr “ zurück; in diesem Fall gibt „ isError()“ „ true “ zurück.

Wenn „ context “ auf „ nullptr “ gesetzt ist (Standard), wird die Instanz im „ root context “ der Engine erstellt.

Das Eigentumsrecht an der zurückgegebenen Objektinstanz wird auf den Aufrufer übertragen.

Siehe auch „ QQmlComponent::create “.

QQmlContext *QQmlComponent::creationContext() const

Gibt den „ QQmlContext “ zurück, in dem die Komponente erstellt wurde. Dies gilt nur für Komponenten, die direkt aus QML erstellt wurden.

QQmlEngine *QQmlComponent::engine() const

Gibt die „ QQmlEngine “ dieser Komponente zurück.

QList<QQmlError> QQmlComponent::errors() const

Gibt die Liste der Fehler zurück, die beim letzten Kompilierungs- oder Erstellungsvorgang aufgetreten sind. Wenn ` isError()` nicht gesetzt ist, wird eine leere Liste zurückgegeben.

[since 6.5] bool QQmlComponent::isBound() const

Gibt „true“ zurück, wenn die Komponente in einer QML-Datei erstellt wurde, in der „ pragma ComponentBehavior: Bound “ angegeben ist; andernfalls wird „false“ zurückgegeben.

Diese Funktion wurde in Qt 6.5 eingeführt.

bool QQmlComponent::isError() const

Gibt „true“ zurück, wenn status() == QQmlComponent::Error ist.

bool QQmlComponent::isLoading() const

Gibt „true“ zurück, wenn „ status()“ == „ QQmlComponent::Loading “ ist.

bool QQmlComponent::isNull() const

Gibt „true“ zurück, wenn „ status()“ == „ QQmlComponent::Null “ ist.

bool QQmlComponent::isReady() const

Gibt „true“ zurück, wenn status() == QQmlComponent::Ready ist.

[slot, since 6.5] void QQmlComponent::loadFromModule(QAnyStringView uri, QAnyStringView typeName, QQmlComponent::CompilationMode mode = PreferSynchronous)

Laden Sie den „ QQmlComponent “ für „ typeName “ im Modul „ uri “. Wenn der Typ über eine QML-Datei implementiert ist, wird er über „ mode “ geladen. Von C++ unterstützte Typen werden immer synchron geladen.

QQmlEngine engine;
QQmlComponent component(&engine);
component.loadFromModule("QtQuick", "Item");
// once the component is ready
std::unique_ptr<QObject> item(component.create());
Q_ASSERT(item->metaObject() == &QQuickItem::staticMetaObject);

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch „ loadUrl()“.

[slot] void QQmlComponent::loadUrl(const QUrl &url)

Laden Sie die Datei „ QQmlComponent “ von der angegebenen Adresse url herunter.

Stellen Sie sicher, dass die angegebene URL vollständig und korrekt ist; verwenden Sie insbesondere QUrl::fromLocalFile(), wenn Sie eine Datei aus dem lokalen Dateisystem laden.

Relative Pfade werden relativ zu ` QQmlEngine::baseUrl()` aufgelöst, was, sofern nicht anders angegeben, das aktuelle Arbeitsverzeichnis ist.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        qmlComponent, qOverload(&QQmlComponent::loadUrl));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        qmlComponent, [receiver = qmlComponent](const QUrl &url) { receiver->loadUrl(url); });

[slot] void QQmlComponent::loadUrl(const QUrl &url, QQmlComponent::CompilationMode mode)

Laden Sie die „ QQmlComponent “ von der angegebenen Adresse url. Wenn mode gleich Asynchronous ist, wird die Komponente asynchron geladen und kompiliert.

Stellen Sie sicher, dass die angegebene URL vollständig und korrekt ist; verwenden Sie insbesondere ` QUrl::fromLocalFile()` beim Laden einer Datei aus dem lokalen Dateisystem.

Relative Pfade werden relativ zu QQmlEngine::baseUrl() aufgelöst, was dem aktuellen Arbeitsverzeichnis entspricht, sofern nicht anders angegeben.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        qmlComponent, qOverload(&QQmlComponent::loadUrl));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        qmlComponent, [receiver = qmlComponent](const QUrl &url, QQmlComponent::CompilationMode mode) { receiver->loadUrl(url, mode); });

[signal] void QQmlComponent::progressChanged(qreal progress)

Wird immer dann ausgelöst, wenn sich der Ladefortschritt der Komponente ändert. „ progress “ gibt den aktuellen Fortschritt zwischen 0,0 (noch nichts geladen) und 1,0 (fertig) an.

[slot] void QQmlComponent::setData(const QByteArray &data, const QUrl &url)

Legt die „ QQmlComponent “ so fest, dass die angegebene QML- data verwendet wird. Wenn „ url “ angegeben wird, wird dieser Wert verwendet, um den Komponentennamen festzulegen und einen Basispfad für Elemente bereitzustellen, die von dieser Komponente aufgelöst werden. Die Komponente wird synchron geladen und kompiliert.

void QQmlComponent::setInitialProperties(QObject *object, const QVariantMap &properties)

Legen Sie die oberste „ properties “ der „ object “ fest, die aus einem „ QQmlComponent “ erstellt wurde.

Diese Methode bietet erweiterte Kontrolle über die Erstellung von Komponenteninstanzen. Im Allgemeinen sollten Programmierer ` QQmlComponent::createWithInitialProperties ` verwenden, um eine Objektinstanz aus einer Komponente zu erstellen.

Verwenden Sie diese Methode, nachdem „ beginCreate “ und vor dem Aufruf von „ completeCreate “ aufgerufen wurde. Wenn eine übergebene Eigenschaft nicht existiert, wird eine Warnung ausgegeben.

Diese Methode erlaubt es nicht, verschachtelte Eigenschaften direkt bei der Initialisierung festzulegen. Stattdessen kann die Festlegung eines Anfangswerts für Eigenschaften vom Typ „Wert“ mit verschachtelten Eigenschaften erreicht werden, indem dieser Werttyp erstellt, seine verschachtelte Eigenschaft zugewiesen und der Werttyp anschließend als Anfangseigenschaft des zu erstellenden Objekts übergeben wird.

Um beispielsweise `fond.bold` festzulegen, können Sie eine ` QFont` erstellen, deren `weight` auf „bold“ setzen und die Schriftart anschließend als Anfangseigenschaft übergeben.

[signal] void QQmlComponent::statusChanged(QQmlComponent::Status status)

Wird immer dann ausgelöst, wenn sich der Status der Komponente ändert. „ status “ ist der neue Status.