DelegateModel QML Type

Kapseln ein Modell und einen Delegaten. Mehr...

Import Statement: import QtQml.Models

Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

count : int
delegate : Component
delegateModelAccess : enumeration (since 6.10)
filterOnGroup : string
groups : list<DelegateModelGroup>
items : DelegateModelGroup
model : model
parts : object
persistedItems : DelegateModelGroup
rootIndex : QModelIndex

Zugehörige Eigenschaften

groups : list<string>
inItems : bool
inPersistedItems : bool
isUnresolved : bool
itemsIndex : int
model : model
persistedItemsIndex : int

Methoden

QModelIndex modelIndex(int index)
QModelIndex parentModelIndex()

Ausführliche Beschreibung

Der Typ „DelegateModel“ kapselt ein Modell und den Delegaten, der für Elemente im Modell instanziiert wird.

In der Regel ist es nicht erforderlich, ein „DelegateModel“ zu erstellen. Es kann jedoch nützlich sein, um das „ modelIndex “ zu bearbeiten und darauf zuzugreifen, wenn eine Unterklasse von „ QAbstractItemModel “ als Modell verwendet wird. Außerdem wird „DelegateModel“ zusammen mit „ Package “ verwendet, um Delegaten für mehrere Ansichten bereitzustellen, sowie mit „ DelegateModelGroup “, um Delegat-Elemente zu sortieren und zu filtern.

DelegateModel unterstützt nur eindimensionale Modelle – die Zuweisung eines Tabellenmodells zu DelegateModel und dieses wiederum zu „ TableView “ führt daher nur zur Anzeige einer Spalte.

Das folgende Beispiel veranschaulicht die Verwendung eines „DelegateModel“ mit einem „ ListView “.

import QtQuick
import QtQml.Models

Rectangle {
    width: 200; height: 100

    DelegateModel {
        id: visualModel
        model: ListModel {
            ListElement { name: "Apple" }
            ListElement { name: "Orange" }
        }
        delegate: Rectangle {
            height: 25
            width: 100
            Text { text: "Name: " + name}
        }
    }

    ListView {
        anchors.fill: parent
        model: visualModel
    }
}

Dokumentation zu den Eigenschaften

count : int

delegate : Component

Der Delegat stellt eine Vorlage bereit, die jedes von einer Ansicht instanziierte Element definiert. Der Index wird als zugängliche Eigenschaft „ index “ bereitgestellt. Je nach Typ des Datenmodells stehen auch Eigenschaften des Modells zur Verfügung.

delegateModelAccess : enumeration `[since 6.10]`

Diese Eigenschaft legt fest, wie Delegaten auf das Modell zugreifen können.

Konstante	Beschreibung
`DelegateModel.ReadOnly`	Verhindert, dass Delegaten das Modell über Kontexteigenschaften, das „ `model` “-Objekt oder erforderliche Eigenschaften schreiben können.
`DelegateModel.ReadWrite`	Erlaubt Delegaten, das Modell über Kontexteigenschaften, das „ `model` “-Objekt oder erforderliche Eigenschaften zu schreiben.
`DelegateModel.Qt5ReadWrite`	Erlaubt Delegaten, das Modell über das „ `model` “-Objekt und Kontexteigenschaften zu schreiben, jedoch nicht über erforderliche Eigenschaften.

Die Standardeinstellung ist „ DelegateModel.Qt5ReadWrite “.

Diese Eigenschaft wurde in Qt 6.10 eingeführt.

Siehe auch „Modelle und Ansichten in Qt Quick “ unter „Ändern von Modelldaten“.

filterOnGroup : string

Diese Eigenschaft enthält den Namen der Gruppe, die zum Filtern des Delegatenmodells verwendet wird.

Nur Elemente, die zu dieser Gruppe gehören, sind in einer Ansicht sichtbar.

Standardmäßig ist dies die Gruppe „ items “.

groups : list<DelegateModelGroup>

Diese Eigenschaft enthält die Gruppendefinitionen eines Delegatenmodells.

Gruppen definieren eine Teilmenge der Elemente in einem Delegatenmodell und können zum Filtern eines Modells verwendet werden.

Für jede in einem „ DelegateModel “ definierte Gruppe werden jedem Delegatenelement zwei zugehörige Pseudo-Eigenschaften hinzugefügt. Die erste in der Form „ DelegateModel.inGroupName“ gibt an, ob das Element zur Gruppe gehört, und die zweite „ DelegateModel.groupNameIndex“enthält den Index des Elements in dieser Gruppe.

Das folgende Beispiel veranschaulicht die Verwendung von Gruppen zur Auswahl von Elementen in einem Modell.

import QtQuick
import QtQml.Models

Rectangle {
    width: 200; height: 100

    DelegateModel {
        id: visualModel
        model: ListModel {
            ListElement { name: "Apple" }
            ListElement { name: "Orange" }
        }

        groups: [
            DelegateModelGroup { name: "selected" }
        ]

        delegate: Rectangle {
            id: item
            height: 25
            width: 200
            Text {
                text: {
                    var text = "Name: " + name
                    if (item.DelegateModel.inSelected)
                        text += " (" + item.DelegateModel.selectedIndex + ")"
                    return text;
                }
            }
            MouseArea {
                anchors.fill: parent
                onClicked: item.DelegateModel.inSelected = !item.DelegateModel.inSelected
            }
        }
    }

    ListView {
        anchors.fill: parent
        model: visualModel
    }
}

Warnung: Im Gegensatz zu normalen angehängten Eigenschaften können diese nicht deklarativ festgelegt werden. Folgender Code würde zu einem Fehler führen:

delegate: Rectangle {
    DelegateModel.inSelected: true
}

items : DelegateModelGroup

Diese Eigenschaft enthält die Standardgruppe, der alle neuen Elemente hinzugefügt werden.

model : model

Diese Eigenschaft enthält das Modell, das Daten für die „ DelegateModel “ bereitstellt.

Das Modell stellt einen Datensatz bereit, der zur Erstellung der Elemente einer Ansicht verwendet wird. Bei großen oder dynamischen Datensätzen wird das Modell in der Regel von einem C++-Modellobjekt bereitgestellt. Das C++-Modellobjekt muss eine Unterklasse von ` QAbstractItemModel ` oder eine einfache Liste sein.

Modelle können auch direkt in QML erstellt werden, beispielsweise mithilfe von ` ListModel`.

Siehe auch Datenmodelle.

parts : object

Die Eigenschaft „ parts “ wählt ein „ DelegateModel “ aus, das Delegaten aus dem genannten Teil erstellt. Dies wird in Verbindung mit dem Typ „ Package “ verwendet.

Der folgende Code wählt beispielsweise ein Modell aus, das Delegaten mit dem Namen „list“ aus einem „ Package “ erstellt:

DelegateModel {
    id: visualModel
    delegate: Package {
        Item { Package.name: "list" }
    }
    model: myModel
}

ListView {
    width: 200; height:200
    model: visualModel.parts.list
}

Siehe auch „ Package “.

persistedItems : DelegateModelGroup

Diese Eigenschaft enthält die Gruppe der persistierten Elemente des Delegatenmodells.

Elemente in dieser Gruppe werden nicht zerstört, wenn sie von einer Ansicht freigegeben werden, sondern bleiben so lange persistent, bis sie aus der Gruppe entfernt werden.

Ein Element kann aus der Gruppe „persistedItems“ entfernt werden, indem die Eigenschaft „ DelegateModel.inPersistedItems “ auf „false“ gesetzt wird. Wenn das Element zu diesem Zeitpunkt von keiner Ansicht referenziert wird, wird es gelöscht. Das Hinzufügen eines Elements zu dieser Gruppe führt nicht zur Erstellung einer neuen Instanz.

Elemente, die von der Funktion „ QtQml.Models::DelegateModelGroup::create()“ zurückgegeben werden, werden automatisch dieser Gruppe hinzugefügt.

rootIndex : QModelIndex

QAbstractItemModel stellt eine hierarchische Baumstruktur der Daten bereit, während QML ausschließlich mit Listendaten arbeitet. Mit „ rootIndex “ können die untergeordneten Elemente eines beliebigen Knotens in einem „ QAbstractItemModel “ von diesem Modell bereitgestellt werden.

Diese Eigenschaft wirkt sich nur auf Modelle vom Typ „ QAbstractItemModel “ aus, die hierarchisch sind (z. B. ein Baummodell).

Hier ist zum Beispiel ein einfacher interaktiver Dateisystembrowser. Wenn auf einen Verzeichnisnamen geklickt wird, wird die „ rootIndex “ der Ansicht auf den „ QModelIndex “-Knoten des angeklickten Verzeichnisses gesetzt, wodurch die Ansicht aktualisiert wird, um den Inhalt des neuen Verzeichnisses anzuzeigen.

main.cpp:

int main(int argc, char ** argv)
{
    QGuiApplication app(argc, argv);

    QQuickView view;

    QFileSystemModel model;
    // start populating the model (doesn't change the model's root)
    model.setRootPath(QDir::currentPath());

    qmlRegisterSingletonInstance("FileSystemModule", 1, 0, "FileSystemModel", &model);
    view.setSource(QUrl::fromLocalFile("view.qml"));
    view.show();

    return app.exec();
}

view.qml:

import QtQuick
import QtQml.Models
import FileSystemModule

pragma ComponentBehavior: Bound

ListView {
    id: view
    width: 300
    height: 400

    model: DelegateModel {
        id: delegateModel
        model: FileSystemModel // singleton

        delegate: Rectangle {
            id: delegate
            required property int index
            required property string filePath
            required property bool hasModelChildren

            width: 300; height: 25
            color: index % 2 ? palette.alternateBase : palette.base

            Text {
                anchors.verticalCenter: parent.verticalCenter
                color: palette.text
                text: delegate.filePath
            }

            TapHandler {
                onTapped: if (delegate.hasModelChildren)
                              delegateModel.rootIndex = delegateModel.modelIndex(delegate.index)
            }
        }
    }
}

Ist der „ model “ eine Unterklasse von „ QAbstractItemModel “, kann der Delegat auch auf die Eigenschaft „ hasModelChildren “ verweisen (optional mit dem Präfix „model.“), die angibt, ob das Modellelement des Delegaten über untergeordnete Knoten verfügt.

Siehe auch „ modelIndex()“ und „ parentModelIndex()“.

Dokumentation zu angehängten Eigenschaften

DelegateModel.groups : list<string> `[attached]`

Diese angehängte Eigenschaft enthält den Namen der „DelegateModelGroups“, zu denen das Element gehört.