QML angehängte 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 Namespaced-Syntax, 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 Vererbung erforderlich ist. Auf eine angehängte Eigenschaft oder ein Signal wird zugegriffen, indem dem Eigenschafts- oder Signalnamen der Name des anhängenden Typs vorangestellt wird.

Der Typ ListView verfügt beispielsweise über eine angehängte Eigenschaft namens isCurrentItem, auf die bei 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 für jedes Delegatenelement durch ListView verfügbar gemacht wird.

Angehängte Eigenschaften

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

Übliche Beispiele sind:

• ListView angehängte Eigenschaften (isCurrentItem, view)
• GridView angehängte Eigenschaften
• Keys angehängte Eigenschaften für die Behandlung von Tastaturereignissen
• Component angehängte Eigenschaften (onCompleted, onDestruction)

Angehängte Signale

Ähnlich wie bei angehängten Eigenschaften ermöglichen angehängte Signale die Bereitstellung zusätzlicher Signalhandler für Objekte. Diese werden in der Regel für Lebenszyklusereignisse verwendet.

Der Typ Component bietet zum Beispiel angehängte Signale:

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

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

Angeschlossene Eigenschaften in C++ erstellen

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

1. Eine Klasse für angehängte Eigenschaften erstellen, die von Component erbt. 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 anhängende Typ (in diesem FallMyType ) nichts anderes tut, als Eigenschaften an andere Objekte anzuhängen, können Sie dies als eine einzige 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 werden angehängte Eigenschaften verwendet?

Angehängte Eigenschaften sind nützlich, wenn:

• Sie möchten kontextspezifische Informationen zu Objekten hinzufügen (wie ListView's isCurrentItem)
• Eigenschaften logischerweise zu einem Container oder Kontext gehören und nicht zum Element selbst
• Sie wollen vermeiden, dass Basistypen mit spezialisierten Eigenschaften überladen werden.