DelegateModel QML Type

Encapsula un modelo y un delegado. Más...

Import Statement: import QtQml.Models

Lista de todos los miembros, incluidos los heredados

Propiedades

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

Propiedades anexas

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

Métodos

QModelIndex modelIndex(int index)
QModelIndex parentModelIndex()

Descripción detallada

El tipo DelegateModel encapsula un modelo y el delegado que se instanciará para los elementos del modelo.

Normalmente no es necesario crear un DelegateModel. Sin embargo, puede ser útil para manipular y acceder a modelIndex cuando se utiliza una subclase de QAbstractItemModel como modelo. Además, DelegateModel se utiliza junto con Package para proporcionar delegados a múltiples vistas, y con DelegateModelGroup para ordenar y filtrar elementos delegados.

DelegateModel sólo admite modelos unidimensionales: si se asigna un modelo de tabla a DelegateModel y éste a TableView, sólo se mostrará una columna.

El ejemplo siguiente ilustra el uso de un DelegateModel con 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
    }
}

Documentación de propiedades

count : int

delegate : Component

El delegado proporciona una plantilla que define cada elemento instanciado por una vista. El índice se expone como una propiedad accesible index. Las propiedades del modelo también están disponibles dependiendo del tipo de Modelo de Datos.

delegateModelAccess : enumeration `[since 6.10]`

Esta propiedad determina cómo los delegados pueden acceder al modelo.

Constante	Descripción
`DelegateModel.ReadOnly`	Prohíbe a los delegados escribir el modelo a través de las propiedades de contexto, el objeto `model` o las propiedades requeridas.
`DelegateModel.ReadWrite`	Permite a los delegados escribir el modelo a través de las propiedades de contexto, el objeto `model` o las propiedades requeridas.
`DelegateModel.Qt5ReadWrite`	Permitir a los delegados escribir el modelo a través del objeto `model` y las propiedades de contexto, pero no a través de las propiedades requeridas.

El valor por defecto es DelegateModel.Qt5ReadWrite.

Esta propiedad se introdujo en Qt 6.10.

Ver también Modelos y Vistas en Qt Quick#CambiandoDatos del Modelo.

filterOnGroup : string

Esta propiedad contiene el nombre del grupo que se utiliza para filtrar el modelo de delegado.

Sólo los elementos que pertenecen a este grupo son visibles para una vista.

Por defecto es el grupo items.

groups : list<DelegateModelGroup>

Esta propiedad contiene las definiciones de grupo de un modelo de delegado.

Los grupos definen un subconjunto de los elementos de un modelo de delegado y pueden utilizarse para filtrar un modelo.

Por cada grupo definido en DelegateModel se añaden dos pseudopropiedades adjuntas a cada elemento delegado. La primera, del tipo DelegateModel.inGroupName, indica si el elemento pertenece al grupo y la segunda, DelegateModel.groupNameIndex, contiene el índice del elemento en ese grupo.

El siguiente ejemplo ilustra el uso de grupos para seleccionar elementos en un modelo.

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

Atención: A diferencia de las propiedades adjuntas normales, éstas no pueden establecerse de forma declarativa. Lo siguiente daría lugar a un error:

delegate: Rectangle {
    DelegateModel.inSelected: true
}

items : DelegateModelGroup

Esta propiedad contiene el grupo por defecto al que se añaden todos los nuevos elementos.

model : model

Esta propiedad contiene el modelo que proporciona los datos para DelegateModel.

El modelo proporciona un conjunto de datos que se utiliza para crear los elementos de una vista. Para conjuntos de datos grandes o dinámicos, el modelo suele proporcionarlo un objeto modelo C++. El objeto modelo C++ debe ser una subclase de QAbstractItemModel o una lista simple.

Los modelos también pueden crearse directamente en QML, por ejemplo utilizando ListModel.

Véase también Modelos de datos.

parts : object

La propiedad parts selecciona un DelegateModel que crea delegados de la parte nombrada. Se utiliza junto con el tipo Package.

Por ejemplo, el código siguiente selecciona un modelo que crea delegados denominados lista a partir de un Package:

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

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

Véase también Package.

persistedItems : DelegateModelGroup

Esta propiedad contiene el grupo de elementos persistentes del modelo delegado.

Los elementos de este grupo no se destruyen cuando son liberados por una vista, sino que se mantienen hasta que se eliminan del grupo.

Un elemento puede ser eliminado del grupo persistedItems estableciendo la propiedad DelegateModel.inPersistedItems a false. Si el elemento no es referenciado por una vista en ese momento será destruido. Al añadir un elemento a este grupo no se creará una nueva instancia.

Los elementos devueltos por la función QtQml.Models::DelegateModelGroup::create() se añaden automáticamente a este grupo.

rootIndex : QModelIndex

QAbstractItemModel proporciona un árbol jerárquico de datos, mientras que QML sólo opera con datos de lista. rootIndex permite que los hijos de cualquier nodo de un modelo QAbstractItemModel sean proporcionados por este modelo.

Esta propiedad sólo afecta a los modelos de tipo QAbstractItemModel que son jerárquicos (por ejemplo, un modelo de árbol).

Por ejemplo, he aquí un sencillo navegador interactivo de sistemas de archivos. Cuando se hace clic en un nombre de directorio, el rootIndex de la vista se establece en el nodo QModelIndex del directorio sobre el que se ha hecho clic, actualizando así la vista para mostrar el contenido del nuevo directorio.

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 model es una subclase de QAbstractItemModel, el delegado también puede hacer referencia a una propiedad hasModelChildren (opcionalmente calificada por un prefijo model.) que indica si el elemento del modelo del delegado tiene algún nodo hijo.

Véase también modelIndex() y parentModelIndex().

Documentación de propiedades adjuntas

DelegateModel.groups : list<string>

Esta propiedad adjunta contiene el nombre de los DelegateModelGroups a los que pertenece el elemento.