En esta página

DelegateModel QML Type

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

Import Statement: import QtQml.Models

Propiedades

Propiedades adjuntas

Métodos

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 resultar útil para manipular y acceder a la clase « modelIndex » cuando se utiliza una subclase de « QAbstractItemModel » como modelo. Además, DelegateModel se utiliza junto con « Package » para proporcionar delegados a varias vistas, y con « DelegateModelGroup » para ordenar y filtrar elementos delegados.

DelegateModel solo admite modelos unidimensionales; por lo tanto, si se asigna un modelo de tabla a DelegateModel y este a TableView, solo 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 en función del tipo de modelo de datos.

delegateModelAccess : enumeration [since 6.10]

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

ConstanteDescripción
DelegateModel.ReadOnlyImpide que los delegados escriban en el modelo mediante propiedades de contexto, el objeto model o propiedades obligatorias.
DelegateModel.ReadWritePermite a los delegados escribir en el modelo mediante propiedades de contexto, el objeto ` model ` o propiedades obligatorias.
DelegateModel.Qt5ReadWritePermite a los delegados escribir en el modelo mediante el objeto ` model ` y las propiedades de contexto, pero no mediante las propiedades obligatorias.

El valor predeterminado es ` DelegateModel.Qt5ReadWrite`.

Esta propiedad se introdujo en Qt 6.10.

Véase también «Modelos y vistas» en Qt Quick, apartado «Modificación de los datos del modelo».

filterOnGroup : string

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

Solo los elementos que pertenecen a este grupo son visibles en una vista.

Por defecto, se trata del grupo « items ».

groups : list<DelegateModelGroup>

Esta propiedad contiene las definiciones de los grupos de un modelo delegado.

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

Por cada grupo definido en un « DelegateModel », se añaden dos pseudopropiedades asociadas a cada elemento delegado. La primera, con el formato DelegateModel.inGroupName, indica si el elemento pertenece al grupo, y la segunda, DelegateModel.groupNameIndex, contiene el índice del elemento en dicho 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
    }
}

Advertencia: A diferencia de las propiedades asociadas normales, estas no se pueden establecer de forma declarativa. Lo siguiente daría lugar a un error:

delegate: Rectangle {
    DelegateModel.inSelected: true
}

items : DelegateModelGroup

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

model : model

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

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

Los modelos también se pueden crear 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 a partir de la parte indicada. Se utiliza junto con el tipo ` Package `.

Por ejemplo, el código siguiente selecciona un modelo que crea delegados denominados «list» 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 persistidos del modelo delegado.

Los elementos de este grupo no se destruyen cuando una vista los libera, sino que se conservan hasta que se eliminan del grupo.

Un elemento puede eliminarse del grupo `persistedItems` estableciendo en `false` la propiedad ` DelegateModel.inPersistedItems `. Si en ese momento ninguna vista hace referencia al elemento, este se destruirá. Añadir un elemento a este grupo no 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 solo opera con datos en forma de lista. La propiedad « rootIndex » permite que los hijos de cualquier nodo de un « QAbstractItemModel » sean proporcionados por este modelo.

Esta propiedad solo afecta a los modelos de tipo « QAbstractItemModel » que sean jerárquicos (por ejemplo, un modelo de árbol).

Por ejemplo, aquí hay un sencillo explorador interactivo del sistema de archivos. Al hacer clic en el nombre de un directorio, el rootIndex de la vista se establece en el nodo QModelIndex del directorio seleccionado, 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 el model es una subclase de QAbstractItemModel, el delegado también puede hacer referencia a una propiedad hasModelChildren (opcionalmente calificada por el 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 sobre propiedades asociadas

DelegateModel.groups : list<string> [attached]

Esta propiedad adjunta contiene el nombre de «DelegateModelGroups» al que pertenece el elemento.

Se asocia a cada instancia del delegado.

DelegateModel.inItems : bool [attached]

Esta propiedad adjunta indica si el elemento pertenece al grupo de elementos por defecto « items » DelegateModelGroup.

Al modificar esta propiedad, el elemento se añadirá o se eliminará del grupo de elementos.

Se asocia a cada instancia del delegado.

DelegateModel.inPersistedItems : bool [attached]

Esta propiedad adjunta indica si el elemento pertenece al grupo « persistedItems » DelegateModelGroup.

Al modificar esta propiedad, el elemento se añadirá o eliminará del grupo de elementos. Modifícala con precaución, ya que eliminar un elemento del grupo « persistedItems » destruirá la instancia actual si ningún modelo hace referencia a ella.

Está asociada a cada instancia del delegado.

DelegateModel.isUnresolved : bool [attached]

Esta propiedad adjunta indica si el elemento visual está vinculado a un índice del modelo de datos. Devuelve «true» si el elemento no está vinculado al modelo, y «false» si lo está.

Un elemento sin resolver puede vincularse al modelo de datos mediante la función DelegateModelGroup::resolve().

Se adjunta a cada instancia del delegado.

DelegateModel.itemsIndex : int [attached]

Esta propiedad asociada contiene el índice del elemento en el objeto predeterminado items DelegateModelGroup .

Se adjunta a cada instancia del delegado.

DelegateModel.model : model [attached]

Esta propiedad asociada contiene el modelo de datos al que pertenece esta instancia del delegado.

Se adjunta a cada instancia del delegado.

DelegateModel.persistedItemsIndex : int [attached]

Esta propiedad adjunta contiene el índice del elemento en persistedItems DelegateModelGroup .

Se adjunta a cada instancia del delegado.

Documentación del método

QModelIndex modelIndex(int index)

QAbstractItemModel Proporciona un árbol jerárquico de datos, mientras que QML solo opera con datos en forma de lista. Esta función facilita el uso de modelos de árbol en QML.

Devuelve un ` QModelIndex ` para el ` index` especificado. Este valor se puede asignar a ` rootIndex`.

Véase también ` rootIndex`.

QModelIndex parentModelIndex()

QAbstractItemModel proporciona un árbol jerárquico de datos, mientras que QML solo opera con datos en forma de lista. Esta función facilita el uso de modelos de árbol en QML.

Devuelve un ` QModelIndex ` correspondiente al padre del ` rootIndex` actual. Este valor se puede asignar a ` rootIndex`.

Véase también ` rootIndex`.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.