QML-angeschlossene Typen

Angehängte Eigenschaften und Signale sind ein Mechanismus, mit dem Objekte mit zusätzlichen Eigenschaften oder Signalen versehen werden können, die nicht Teil ihres Basistyps sind. Der Zugriff auf angehängte Eigenschaften erfolgt über eine Syntax mit Namensraum, die den Typ identifiziert, der die angehängten Eigenschaften bereitstellt.

Übersicht

Einige Typen verfügen über Eigenschaften oder Signale, die an andere Objekte angehängt werden können und so zusätzliche Funktionalität bieten, ohne dass eine Vererbung erforderlich ist. Der Zugriff auf eine angehängte Eigenschaft oder ein Signal erfolgt, indem dem Namen der Eigenschaft oder des Signals der Name des anhängenden Typs vorangestellt wird.

Beispielsweise verfügt der Typ „ ListView “ über eine angehängte Eigenschaft namens „ isCurrentItem “, auf die von jedem Element innerhalb des Delegaten von „ ListView “ zugegriffen werden kann:

ListView {
    width: 240
    height: 320
    model: 3
    delegate: Rectangle {
        width: 100
        height: 30
        color: ListView.isCurrentItem ? "red" : "yellow"
    }
}

Hier ist „ ListView.isCurrentItem “ eine angehängte Eigenschaft, die jedem Element des Delegaten über „ ListView “ zur Verfügung gestellt wird.

Angehängte Eigenschaften

Mit angehängten Eigenschaften können Sie Objekten Eigenschaften hinzufügen, die ansonsten durch einen Basistyp definiert sind. Die Eigenschaftswerte werden außerhalb des Objekts gespeichert und über den Namen des anhängenden Typs abgerufen.

Häufige Beispiele sind:

• ListView angeschlossene Eigenschaften (isCurrentItem, view)
• GridView angeschlossene Eigenschaften
• Keys angeschlossene Eigenschaften für die Verarbeitung von Tastaturereignissen
• Component angeschlossene Eigenschaften (onCompleted, onDestruction)

Angehängte Signale

Ähnlich wie bei angehängten Eigenschaften ermöglichen angehängte Signale es Typen, Objekte mit zusätzlichen Signal-Handlern auszustatten. Diese werden häufig für Lebenszyklus-Ereignisse verwendet.

Beispielsweise stellt der Typ „Component“ angehängte Signale bereit:

Rectangle {
    Component.onCompleted: {
        console.log("Rectangle creation completed")
    }

    Component.onDestruction: {
        console.log("Rectangle is being destroyed")
    }
}

Erstellen von angehängten Eigenschaften in C++

Um aus C++ heraus angehängte Eigenschaften für Ihre eigenen Typen zu erstellen, müssen Sie Folgendes tun:

1. Erstellen Sie eine Klasse für angehängte Eigenschaften, die von QObject
2. Implementieren Sie die angehängten Eigenschaften in dieser Klasse
3. Fügen Sie das Makro „ QML_ATTACHED “ zu Ihrem Haupttyp hinzu
4. Implementieren Sie eine statische Methode „ qmlAttachedProperties() “

Beispiel:

class MyAttachedType : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
    QML_ANONYMOUS

public:
    MyAttachedType(QObject *parent = nullptr) : QObject(parent) {}

    int value() const { return m_value; }
    void setValue(int value)
    {
        if (m_value != value) {
            m_value = value;
            emit valueChanged();
        }
    }

signals:
    void valueChanged();

private:
    int m_value = 0;
};

class MyType : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_ATTACHED(MyAttachedType)

public:
    static MyAttachedType *qmlAttachedProperties(QObject *object)
    {
        return new MyAttachedType(object);
    }
};

Verwendung in QML:

Item {
    MyType.value: 42
}

Wenn der anbringende Typ (in diesem Fall `MyType `) nichts anderes tut, als Eigenschaften an andere Objekte anzuhängen, können Sie dies als einzelne Klasse formulieren:

class MyType : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
    QML_ELEMENT
    QML_ATTACHED(MyType)

public:
    static MyType *qmlAttachedProperties(QObject *object)
    {
        return new MyType(object);
    }

    MyType(QObject *parent = nullptr) : QObject(parent) {}

    int value() const { return m_value; }
    void setValue(int value)
    {
        if (m_value != value) {
            m_value = value;
            emit valueChanged();
        }
    }

signals:
    void valueChanged();

private:
    int m_value = 0;
};

Wann sollten angehängte Eigenschaften verwendet werden?

Angehängte Eigenschaften sind nützlich, wenn:

• Sie Elementen kontextspezifische Informationen hinzufügen möchten (wie z. B. „ isCurrentItem “ von „ ListView “)
• Eigenschaften logischerweise eher zu einem Container oder Kontext gehören als zum Element selbst
• Sie vermeiden möchten, Basistypen mit spezialisierten Eigenschaften zu überladen