DelegateModel QML Type

Encapsule un modèle et un délégué. En savoir plus…

Import Statement: import QtQml.Models

Liste de tous les membres, y compris les membres hérités

Propriétés

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

Propriétés associées

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

Méthodes

QModelIndex modelIndex(int index)
QModelIndex parentModelIndex()

Description détaillée

Le type DelegateModel encapsule un modèle et le délégué qui sera instancié pour les éléments du modèle.

Il n’est généralement pas nécessaire de créer un DelegateModel. Cependant, cela peut s’avérer utile pour manipuler et accéder à l’ modelIndex lorsqu’une sous-classe de QAbstractItemModel est utilisée comme modèle. De plus, DelegateModel est utilisé conjointement avec Package pour fournir des délégués à plusieurs vues, et avec DelegateModelGroup pour trier et filtrer les éléments délégués.

DelegateModel ne prend en charge que les modèles unidimensionnels : l’affectation d’un modèle de table à DelegateModel, puis de celui-ci à TableView, n’affichera donc qu’une seule colonne.

L'exemple ci-dessous illustre l'utilisation d'un DelegateModel avec un 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
    }
}

Documentation sur les propriétés

count : int

delegate : Component

Le délégué fournit un modèle définissant chaque élément instancié par une vue. L'index est accessible via la propriété ` index `. Les propriétés du modèle sont également disponibles, en fonction du type de modèle de données.

delegateModelAccess : enumeration `[since 6.10]`

Cette propriété détermine la manière dont les délégués peuvent accéder au modèle.

Constante	Description
`DelegateModel.ReadOnly`	Interdit aux délégués d'écrire dans le modèle via les propriétés de contexte, l'objet ` `model` ` ou les propriétés obligatoires.
`DelegateModel.ReadWrite`	Autorise les délégués à modifier le modèle via les propriétés de contexte, l'objet ` `model` ` ou les propriétés obligatoires.
`DelegateModel.Qt5ReadWrite`	Autorise les délégués à modifier le modèle via l'objet ` `model` ` et les propriétés de contexte, mais pas via les propriétés obligatoires.

La valeur par défaut est « DelegateModel.Qt5ReadWrite ».

Cette propriété a été introduite dans Qt 6.10.

Voir également Modèles et vues dans Qt Quick#Modification des données du modèle.

filterOnGroup : string

Cette propriété contient le nom du groupe utilisé pour filtrer le modèle de délégué.

Seuls les éléments appartenant à ce groupe sont visibles dans une vue.

Par défaut, il s'agit du groupe « items ».

groups : list<DelegateModelGroup>

Cette propriété contient les définitions de groupes d'un modèle délégué.

Les groupes définissent un sous-ensemble des éléments d'un modèle de délégué et peuvent être utilisés pour filtrer un modèle.

Pour chaque groupe défini dans un « DelegateModel », deux pseudo-propriétés associées sont ajoutées à chaque élément du délégué. La première, de la forme DelegateModel.inGroupName, indique si l'élément appartient au groupe, et la seconde, DelegateModel.groupNameIndex, contient l'index de l'élément dans ce groupe.

L’exemple suivant illustre l’utilisation des groupes pour sélectionner des éléments dans un modèle.

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
    }
}

Avertissement : contrairement aux propriétés associées normales, celles-ci ne peuvent pas être définies de manière déclarative. Le code suivant générerait une erreur :

delegate: Rectangle {
    DelegateModel.inSelected: true
}

items : DelegateModelGroup

Cette propriété définit le groupe par défaut auquel tous les nouveaux éléments sont ajoutés.

model : model

Cette propriété contient le modèle fournissant les données pour l'DelegateModel.

Le modèle fournit un ensemble de données utilisées pour créer les éléments d’une vue. Pour les ensembles de données volumineux ou dynamiques, le modèle est généralement fourni par un objet modèle C++. L’objet modèle C++ doit être une sous-classe de ` QAbstractItemModel ` ou une simple liste.

Les modèles peuvent également être créés directement en QML, par exemple à l'aide de ` ListModel`.

Voir également Modèles de données.

parts : object

La propriété ` parts ` sélectionne un ` DelegateModel ` qui crée des délégués à partir de la partie indiquée. Elle s'utilise conjointement avec le type ` Package `.

Par exemple, le code ci-dessous sélectionne un modèle qui crée des délégués nommés « list » à partir d’un Package:

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

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

Voir également Package.

persistedItems : DelegateModelGroup

Cette propriété contient le groupe d'éléments persistés du modèle délégué.

Les éléments de ce groupe ne sont pas détruits lorsqu’ils sont libérés par une vue ; ils sont au contraire persistés jusqu’à ce qu’ils soient supprimés du groupe.

Un élément peut être retiré du groupe `persistedItems` en définissant la propriété ` DelegateModel.inPersistedItems ` sur `false`. Si l'élément n'est pas référencé par une vue à ce moment-là, il sera détruit. L'ajout d'un élément à ce groupe ne créera pas de nouvelle instance.

Les éléments renvoyés par la fonction ` QtQml.Models::DelegateModelGroup::create()` sont automatiquement ajoutés à ce groupe.

rootIndex : QModelIndex

QAbstractItemModel fournit une arborescence hiérarchique de données, alors que QML ne traite que des données sous forme de liste. La propriété ` rootIndex ` permet à ce modèle de fournir les enfants de n'importe quel nœud d'une arborescence ( QAbstractItemModel ).

Cette propriété n'affecte que les modèles de type « QAbstractItemModel » qui sont hiérarchiques (par exemple, un modèle arborescent).

Voici par exemple un simple navigateur interactif de système de fichiers. Lorsqu’on clique sur le nom d’un répertoire, la propriété ` rootIndex ` de la vue est définie sur le nœud ` QModelIndex ` du répertoire sur lequel on a cliqué, ce qui met à jour la vue pour afficher le contenu du nouveau répertoire.

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)
            }
        }
    }
}

Si l’ model est une sous-classe de QAbstractItemModel, le délégué peut également référencer une propriété hasModelChildren (éventuellement préfixée par « model. ») qui indique si l’élément de modèle du délégué possède des nœuds enfants.

Voir également modelIndex() et parentModelIndex().