En esta página

Modelos y vistas en Qt Quick

La mayoría de las aplicaciones necesitan dar formato a los datos y mostrarlos. Qt Quick cuenta con los conceptos de modelos, vistas y delegados para mostrar datos. Estos elementos modularizan la visualización de los datos con el fin de proporcionar al desarrollador o diseñador control sobre los diferentes aspectos de los datos. Un desarrollador puede sustituir una vista de lista por una vista de cuadrícula con apenas cambios en los datos. Del mismo modo, encapsular una instancia de los datos en un delegado permite al desarrollador determinar cómo presentar o gestionar los datos.

Diagrama que muestra el flujo de datos hacia los componentes «Modelo», «Vista» y «Delegado»

  • Modelo: contiene los datos y su estructura. Existen varios tipos de QML para crear modelos.
  • Vista: un contenedor que muestra los datos. La vista puede mostrar los datos en una lista o en una cuadrícula.
  • Delegado: determina cómo deben aparecer los datos en la vista. El delegado toma cada unidad de datos del modelo y la encapsula. Se puede acceder a los datos a través del delegado. El delegado también puede volver a escribir datos en modelos editables (por ejemplo, en el manejador onAccepted de un « TextField »).

Para visualizar los datos, vincula la propiedad « model » de la vista a un modelo y la propiedad « delegate » a un componente u otro tipo compatible.

Visualización de datos con vistas

Las vistas son contenedores de colecciones de elementos. Cuentan con numerosas funciones y se pueden personalizar para adaptarse a los requisitos de estilo o comportamiento.

En el conjunto básico de tipos gráficos de Qt Quick se incluye un conjunto de vistas estándar:

Estos tipos tienen propiedades y comportamientos exclusivos de cada uno de ellos. Consulta su documentación respectiva para obtener más información.

Además, «Qt Quick Controls» contiene algunas vistas y delegados adicionales cuyo estilo se adapta al de la aplicación; por ejemplo, HorizontalHeaderView y VerticalHeaderView.

Decoración de vistas

Las vistas permiten la personalización visual mediante propiedades de decoración, como las propiedades header, footer y section. Al vincular un objeto —normalmente otro objeto visual— a estas propiedades, las vistas se pueden decorar. Un pie de página puede incluir un tipo Rectangle que muestre bordes, o un encabezado que muestre un logotipo en la parte superior de la lista.

Supongamos que un club concreto quiere decorar su lista de socios con los colores de su marca. La lista de socios se encuentra en un ` model ` y el ` delegate ` mostrará el contenido del modelo.

ListModel {
    id: nameModel
    ListElement { name: "Alice" }
    ListElement { name: "Bob" }
    ListElement { name: "Jane" }
    ListElement { name: "Harry" }
    ListElement { name: "Wendy" }
}
Component {
    id: nameDelegate
    Text {
        required property string name
        text: name
        font.pixelSize: 24
        width: ListView.view.width
    }
}

El club puede decorar la lista de socios vinculando objetos visuales a las propiedades header y footer. El objeto visual puede definirse en línea, en otro archivo o en un tipo Component.

ListView {
    anchors.fill: parent
    clip: true
    model: nameModel
    delegate: nameDelegate
    header: bannercomponent
    footer: Rectangle {
        width: parent.width; height: 30;
        gradient: clubcolors
    }
    highlight: Rectangle {
        color: "lightgray"
    }
}

Component {     //instantiated when header is processed
    id: bannercomponent
    Rectangle {
        id: banner
        width: parent.width; height: 50
        gradient: clubcolors
        border {color: "#9EDDF2"; width: 2}
        Text {
            anchors.centerIn: parent
            text: "Club Members"
            font.pixelSize: 32
        }
    }
}
Gradient {
    id: clubcolors
    GradientStop { position: 0.0; color: "#8EE2FE"}
    GradientStop { position: 0.66; color: "#7ED2EE"}
}

Lista con el encabezado «Miembros del club» resaltado encima de Alice, Bob, Jane, Harry y Wendy

Gestión del ratón y de los toques

Las vistas gestionan el arrastre y los gestos rápidos de su contenido; sin embargo, no gestionan la interacción táctil con los delegados individuales. Para que los delegados reaccionen a las entradas táctiles, por ejemplo, para establecer la propiedad ` currentIndex`, el delegado debe proporcionar un ` MouseArea ` con la lógica de gestión táctil adecuada.

Ten en cuenta que, si ` highlightRangeMode ` se establece en ` StrictlyEnforceRange `, el `currentIndex` se verá afectado al arrastrar o deslizar la vista, ya que la vista siempre se asegurará de que el ` currentIndex ` se encuentre dentro del rango de resaltado especificado.

Secciones de ListView

ListView El contenido puede agruparse en secciones, en las que los elementos relacionados de la lista se etiquetan según su sección. Además, las secciones pueden decorarse con delegados.

Una lista puede contener otra lista en la que se indiquen los nombres de las personas y el equipo al que pertenece cada una de ellas.

ListModel {
    id: nameModel
    ListElement { name: "Alice"; team: "Crypto" }
    ListElement { name: "Bob"; team: "Crypto" }
    ListElement { name: "Jane"; team: "QA" }
    ListElement { name: "Victor"; team: "QA" }
    ListElement { name: "Wendy"; team: "Graphics" }
}
Component {
    id: nameDelegate
    Text {
        required property string name
        text: name;
        font.pixelSize: 24
        anchors.left: parent.left
        anchors.leftMargin: 2
    }
}

El tipo « ListView » tiene la propiedad adjunta « section », que permite combinar tipos adyacentes y relacionados en una sección. La propiedad « section.property » determina qué propiedad del tipo de lista se utilizará como secciones. La propiedad « section.criteria » puede establecer cómo se muestran los nombres de las secciones, y la propiedad « section.delegate » es similar a la propiedad «delegate» de las vistas.

ListView {
    anchors.fill: parent
    model: nameModel
    delegate: nameDelegate
    focus: true
    highlight: Rectangle {
        color: "lightblue"
        width: parent.width
    }
    section {
        property: "team"
        criteria: ViewSection.FullString
        delegate: Rectangle {
            color: "#b0dfb0"
            width: parent.width
            height: childrenRect.height + 4
            Text { anchors.horizontalCenter: parent.horizontalCenter
                font.pixelSize: 16
                font.bold: true
                text: section
            }
        }
    }
}

Lista agrupada por equipos: Criptografía con Alice y Bob, Control de calidad con Jane y Víctor, Gráficos con Wendy

Delegados de vista

Las vistas necesitan un delegado para representar visualmente un elemento de una lista. Una vista visualizará cada elemento de la lista según la plantilla definida por el delegado. Se puede acceder a los elementos de un modelo a través de la propiedad index, así como de las propiedades del propio elemento.

Component {
    id: petdelegate
    Text {
        id: label
        font.pixelSize: 24
        text: index === 0 ? type + " (default)" : type

        required property int index
        required property string type
    }
}

Lista en la que aparecen: Gato (por defecto), Perro, Ratón, Conejo, Caballo

Posicionamiento de los delegados de vista

El tipo de vista determinará cómo se posicionan los elementos. « ListView » colocará los elementos en línea recta, dependiendo de « orientation », mientras que « GridView » puede distribuirlos en una cuadrícula bidimensional. No se recomienda vincular directamente « x » y « y », ya que el comportamiento de diseño de la vista siempre tendrá prioridad sobre cualquier vinculación posicional.

Acceso a vistas y modelos desde delegados

Se puede acceder a la vista de lista a la que está vinculado el delegado a través de la propiedad ListView.view. Del mismo modo, el GridView GridView.view está disponible para los delegados. Por lo tanto, el modelo correspondiente y sus propiedades están disponibles a través de ListView.view.model. Además, también se puede acceder a cualquier señal o método definido en el modelo.

Este mecanismo resulta útil cuando, por ejemplo, se desea utilizar el mismo delegado para varias vistas, pero se quiere que las decoraciones u otras características sean diferentes para cada vista, y se desea que estas diferentes configuraciones sean propiedades de cada una de las vistas. Del mismo modo, puede resultar interesante acceder a algunas propiedades del modelo o mostrarlas.

En el siguiente ejemplo, el delegado muestra la propiedad «language» del modelo, y el color de uno de los campos depende de la propiedad «fruit_color» de la vista.

Rectangle {
     width: 200; height: 200

    ListModel {
        id: fruitModel
        property string language: "en"
        ListElement {
            name: "Apple"
            cost: 2.45
        }
        ListElement {
            name: "Orange"
            cost: 3.25
        }
        ListElement {
            name: "Banana"
            cost: 1.95
        }
    }

    Component {
        id: fruitDelegate
        Row {
            id: fruit
            required property string name
            required property real cost
            Text {
                text: " Fruit: " + fruit.name
                color: fruit.ListView.view.fruit_color
            }
            Text {
                text: " Cost: $" + fruit.cost
            }
            Text {
                text: " Language: " + fruit.ListView.view.model.language
            }
        }
    }

    ListView {
        property color fruit_color: "green"
        model: fruitModel
        delegate: fruitDelegate
        anchors.fill: parent
    }
}

Modelos

Los datos se proporcionan al delegado a través de roles de datos con nombre a los que el delegado puede vincularse. A continuación se muestra un ` ListModel ` con dos roles, `type` y `age`, y un ` ListView ` con un delegado que se vincula a estos roles para mostrar sus valores:

import QtQuick

Item {
    width: 200
    height: 250

    ListModel {
        id: myModel
        ListElement { type: "Dog"; age: 8; noise: "meow" }
        ListElement { type: "Cat"; age: 5; noise: "woof" }
    }

    component MyDelegate : Text {
        required property string type
        required property int age
        text: type + ", " + age
        // WRONG: Component.onCompleted: () => console.log(noise)
        // The above line would cause a ReferenceError
        // as there is no required property noise,
        // and the presence of the required properties prevents
        // noise from being injected into the scope
    }

    ListView {
        anchors.fill: parent
        model: myModel
        delegate: MyDelegate {}
    }
}

En la mayoría de los casos, debes utilizar propiedades obligatorias para pasar datos del modelo a tus delegados. Si un delegado contiene propiedades obligatorias, el motor QML comprobará si el nombre de una propiedad obligatoria coincide con el de un rol del modelo. Si es así, esa propiedad se vinculará al valor correspondiente del modelo.

En casos excepcionales, es posible que desees transferir las propiedades del modelo a través del contexto de QML en lugar de como propiedades obligatorias. Si no hay propiedades obligatorias en tu delegado, los roles con nombre se proporcionan como propiedades de contexto:

import QtQuick

Item {
    width: 200; height: 250

    ListModel {
        id: myModel
        ListElement { type: "Dog"; age: 8 }
        ListElement { type: "Cat"; age: 5 }
    }

    Component {
        id: myDelegate
        Text { text: type + ", " + age }
    }

    ListView {
        anchors.fill: parent
        model: myModel
        delegate: myDelegate
    }
}

Las propiedades de contexto son invisibles para las herramientas y impiden que el compilador de «Qt Quick » optimice el código. Dificultan la comprensión de los datos específicos que espera el delegado. No hay forma de rellenar explícitamente el contexto QML desde QML. Si tu componente espera que se le pasen datos a través del contexto QML, solo podrás utilizarlo en aquellos lugares donde el contexto adecuado esté disponible mediante medios nativos. Esto puede ser tu propio código C++ o las implementaciones específicas de los elementos circundantes. Por el contrario, las propiedades obligatorias se pueden establecer de diversas formas desde QML o mediante medios nativos. Por lo tanto, pasar datos a través del contexto QML reduce la reutilización de tus componentes.

Si se produce un conflicto de nombres entre las propiedades del modelo y las del delegado, se puede acceder a los roles utilizando en su lugar el nombre calificado del modelo. Por ejemplo, si un tipo « Text » tuviera propiedades (no obligatorias) como «type» o «age», el texto del ejemplo anterior mostraría los valores de esas propiedades en lugar de los valores «type» y «age» del elemento del modelo. En este caso, se podría haber hecho referencia a las propiedades como model.type y model.age para garantizar que el delegado muestre los valores de las propiedades del elemento del modelo. Para que esto funcione, es necesario que la propiedad model sea obligatoria en el delegado (a menos que se utilicen propiedades de contexto).

El delegado también tiene a su disposición un rol de índice especial que contiene el índice del elemento en el modelo. Ten en cuenta que este índice se establece en -1 si el elemento se elimina del modelo. Si se realiza un enlace al rol de índice, asegúrate de que la lógica tenga en cuenta la posibilidad de que el índice sea -1, es decir, que el elemento ya no sea válido. (Normalmente, el elemento se destruirá en breve, pero es posible retrasar la destrucción del delegado en algunas vistas mediante una propiedad adjunta delayRemove.)

Recuerda que puedes utilizar números enteros o matrices como modelo:

Repeater {
    model: 5
    Text {
        required property int modelData
        text: modelData
    }
}
Repeater {
    model: ["one", "two", "three"]
    Text {
        required property string modelData
        text: modelData
    }
}

Estos modelos proporcionan un dato único y anónimo a cada instancia del delegado. El acceso a este dato es la razón principal para utilizar modelData, aunque hay otros modelos que también proporcionan modelData.

El objeto proporcionado a través del rol «model» tiene una propiedad con un nombre vacío. Esta propiedad anónima contiene el «modelData». Además, el objeto proporcionado a través del rol «model» tiene otra propiedad llamada «modelData». Esta propiedad está en desuso y también contiene el «modelData».

Además del rol «model», se proporciona un rol «modelData ». El rol «modelData » contiene los mismos datos que la propiedad «modelData» y la propiedad anónima del objeto proporcionado a través del rol «model ».

Las diferencias entre el rol «model» y las distintas formas de acceder a «modelData» son las siguientes:

  • Los modelos que no tienen roles con nombre (como los enteros o un array de cadenas) proporcionan sus datos a través del rol «modelData ». En este caso, el rol «modelData» no contiene necesariamente un objeto. En el caso de un modelo de tipo entero, contendría un entero (el índice del elemento actual del modelo). En el caso de una matriz de cadenas, contendría una cadena. El rol «model» sigue conteniendo un objeto, pero sin propiedades para los roles con nombre. No obstante, «model» sigue conteniendo sus propiedades habituales «modelData» y «anonymous».
  • Si el modelo tiene solo un rol con nombre, el rol «modelData» contiene los mismos datos que el rol con nombre. No es necesariamente un objeto y no contiene el rol con nombre como una propiedad con nombre, tal y como ocurriría habitualmente. El rol «model» sigue conteniendo un objeto con el rol con nombre como propiedad, así como las propiedades «modelData» y las anónimas en este caso.
  • En el caso de los modelos con varios roles, el rol «modelData» solo se proporciona como propiedad obligatoria, no como propiedad de contexto. Esto se debe a la compatibilidad con versiones anteriores de Qt.

La propiedad «anonymous» de «model» te permite escribir de forma clara delegados que reciben tanto sus datos del modelo como el nombre del rol al que deben reaccionar como propiedades desde el exterior. Puedes proporcionar un modelo sin ningún rol con nombre o con uno solo, y una cadena vacía como rol. En ese caso, un enlace que simplemente acceda a « model[role] » hará lo que esperas. No es necesario añadir código especial para este caso.

Nota: No se puede acceder alos roles «model», «index» y «modelData» si el delegado contiene propiedades obligatorias, a menos que también tenga propiedades obligatorias con nombres coincidentes.

QML proporciona varios tipos de modelos de datos entre el conjunto integrado de tipos de QML. Además, los modelos se pueden crear con Qt C++ y, a continuación, ponerse a disposición de QQmlEngine para que los utilicen los componentes de QML. Para obtener información sobre cómo crear estos modelos, consulta los artículos «Uso de modelos de C++ con vistas de Qt Quick » y «Creación de tipos de QML ».

El posicionamiento de elementos procedentes de un modelo se puede realizar utilizando un ` Repeater`.

Modelo de lista

ListModel es una jerarquía sencilla de tipos especificada en QML. Los roles disponibles se definen mediante las propiedades de ListElement.

ListModel {
    id: fruitModel

    ListElement {
        name: "Apple"
        cost: 2.45
    }
    ListElement {
        name: "Orange"
        cost: 3.25
    }
    ListElement {
        name: "Banana"
        cost: 1.95
    }
}

El modelo anterior tiene dos roles: «name » y «cost». Estos pueden vincularse mediante un delegado de « ListView », por ejemplo:

ListView {
    anchors.fill: parent
    model: fruitModel
    delegate: Row {
        id: delegate
        required property string name
        required property real cost

        Text { text: "Fruit: " + delegate.name }
        Text { text: "Cost: $" + delegate.cost }
    }
}

ListModel proporciona métodos para manipular el ListModel directamente a través de JavaScript. En este caso, el primer elemento insertado determina los roles disponibles para cualquier vista que utilice el modelo. Por ejemplo, si se crea un ListModel vacío y se rellena mediante JavaScript, los roles proporcionados por la primera inserción serán los únicos que se mostrarán en la vista:

ListModel { id: fruitModel }
    ...
MouseArea {
    anchors.fill: parent
    onClicked: fruitModel.append({"cost": 5.95, "name":"Pizza"})
}

Al hacer clic en MouseArea, fruitModel tendrá dos roles: «cost » y «name». Aunque se añadan roles posteriores, las vistas que utilicen el modelo solo gestionarán los dos primeros. Para restablecer los roles disponibles en el modelo, llama a ListModel::clear().

Modelo XML

XmlListModel permite crear un modelo a partir de una fuente de datos XML. Los roles se especifican mediante el tipo XmlListModelRole. Es necesario importar este tipo.

import QtQml.XmlListModel

El siguiente modelo tiene tres roles: title, link y pubDate:

XmlListModel {
     id: feedModel
     source: "http://rss.news.yahoo.com/rss/oceania"
     query: "/rss/channel/item"
     XmlListModelRole { name: "title"; elementName: "title" }
     XmlListModelRole { name: "link"; elementName: "link" }
     XmlListModelRole { name: "pubDate"; elementName: "pubDate" }
}

La propiedad « query » especifica que el « XmlListModel » genera un elemento del modelo por cada « <item> » del documento XML.

La demostración de RSS News muestra cómo se puede utilizar XmlListModel para mostrar una fuente RSS.

Modelo de objetos

ObjectModel contiene los elementos visuales que se van a utilizar en una vista. Cuando se utiliza un ObjectModel en una vista, esta no requiere un delegado, ya que el ObjectModel ya contiene el delegado visual (elementos).

El ejemplo siguiente coloca tres rectángulos de colores en un ` ListView`.

import QtQuick 2.0
import QtQml.Models 2.1

Rectangle {
    ObjectModel {
        id: itemModel
        Rectangle { height: 30; width: 80; color: "red" }
        Rectangle { height: 30; width: 80; color: "green" }
        Rectangle { height: 30; width: 80; color: "blue" }
    }

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

Números enteros como modelos

Un entero puede utilizarse como modelo que contenga un determinado número de tipos. En este caso, el modelo no tiene ningún rol de datos.

El siguiente ejemplo crea un « ListView » con cinco elementos:

Item {
    width: 200; height: 250

    Component {
        id: itemDelegate

        Text {
            required property int index
            text: "I am item number: " + index
        }
    }

    ListView {
        anchors.fill: parent
        model: 5
        delegate: itemDelegate
    }

}

Nota: El límite del número de elementos en un modelo entero es de 100 000 000.

Instancias de objetos como modelos

Una instancia de objeto puede utilizarse para especificar un modelo con un único tipo de objeto. Las propiedades del objeto se proporcionan como roles.

El ejemplo siguiente crea una lista con un elemento, que muestra el color del texto myText. Obsérvese el uso de la propiedad model.color, con su nombre completo, para evitar conflictos con la propiedad color del tipo Text en el delegado.

Rectangle {
    width: 200; height: 250

    Text {
        id: myText
        text: "Hello"
        color: "#dd44ee"
    }

    Component {
        id: myDelegate

        Text {
            required property var model
            text: model.color
        }
    }

    ListView {
        anchors.fill: parent
        anchors.topMargin: 30
        model: myText
        delegate: myDelegate
    }
}

Modelos de datos en C++

Los modelos se pueden definir en C++ y, a continuación, ponerlos a disposición de QML. Este mecanismo resulta útil para exponer a QML modelos de datos existentes en C++ o conjuntos de datos complejos de otro tipo.

Para obtener más información, consulta el artículo «Uso de modelos de C++ con vistas de Qt Quick ».

Modelos de matriz

Se pueden utilizar matrices de JavaScript y diversos tipos de listas QML como modelos. Los elementos de la lista estarán disponibles como «model» y «modelData» según las reglas descritas anteriormente: los datos singulares, como los enteros o las cadenas de caracteres, estarán disponibles como «modelData» singular; los datos estructurados, como los objetos de JavaScript o los QObjects, estarán disponibles como «model» y «modelData» estructurados.

Las funciones de modelo individuales también están disponibles si se solicitan como propiedades obligatorias. Dado que no podemos saber de antemano qué objetos aparecerán en un array, cualquier propiedad obligatoria de un delegado se rellenará, posiblemente mediante una conversión de « undefined » al tipo requerido. Sin embargo, las funciones de modelo individuales no están disponibles a través del contexto de QML, ya que anularían todas las demás propiedades del contexto.

Repetidores

Elementos de texto que muestran «Soy el elemento 0» hasta «Soy el elemento 9»

Los repetidores crean elementos a partir de una plantilla para su uso con posicionadores, utilizando datos de un modelo. Combinar repetidores y posicionadores es una forma sencilla de distribuir muchos elementos. Se coloca un elemento de « Repeater » dentro de un posicionador, y este genera elementos que el posicionador que lo envuelve organiza.

Cada repetidor crea una serie de elementos combinando cada dato del modelo —especificado mediante la propiedad « model »— con el elemento de plantilla, definido como un elemento secundario dentro del repetidor. El número total de elementos viene determinado por la cantidad de datos del modelo.

El siguiente ejemplo muestra un «Repeater» utilizado junto con un elemento «Grid» para organizar un conjunto de elementos «Rectangle». El elemento «Repeater» crea una serie de 24 rectángulos para que el elemento «Grid» los coloque en una disposición de 5 por 5.

import QtQuick

Rectangle {
    width: 400
    height: 400
    color: "black"

    Grid {
        x: 5
        y: 5
        rows: 5
        columns: 5
        spacing: 10

        Repeater {
            model: 24
            Rectangle {
                id: delegate

                required property int index

                width: 70
                height: 70
                color: "lightgreen"

                Text {
                    text: delegate.index
                    font.pointSize: 30
                    anchors.centerIn: parent
                }
            }
        }
    }
}

El número de elementos creados por un «Repeater» viene determinado por su propiedad « count ». No es posible configurar esta propiedad para determinar el número de elementos que se van a crear. En su lugar, como en el ejemplo anterior, utilizamos un número entero como modelo.

Para obtener más detalles, consulta el documento «Modelos de datos de QML ».

Si el modelo es una lista de cadenas, el delegado también tiene acceso a la propiedad habitual « modelData », de solo lectura, que contiene la cadena. Por ejemplo:

Column {
    Repeater {
        model: ["apples", "oranges", "pears"]
        Text {
            required property string modelData
            text: "Data: " + modelData
        }
    }
}

Texto que muestra «Datos: manzanas», «Datos: naranjas», «Datos: peras»

También es posible utilizar un delegado como plantilla para los elementos creados por un «Repeater». Esto se especifica mediante la propiedad « delegate ».

Modificación de los datos del modelo

Todas las vistas relevantes tienen una propiedad llamada `delegateModelAccess ` que determina si se pueden modificar los datos del modelo desde el delegado y cómo hacerlo. En la mayoría de los casos, debes establecerla en `DelegateModel.ReadWrite`. Esto permitirá que tu delegado modifique los datos del modelo de la forma más flexible. Como alternativa, puedes establecerla en ` DelegateModel.ReadOnly` si no quieres que el delegado modifique ningún dato del modelo.

La siguiente tabla describe en detalle todos los valores que puede adoptar la propiedad.

DelegateModel.Qt5ReadWriteEl delegado puede asignar valores a cualquier propiedad de contexto proporcionada por la vista con el fin de modificar el elemento correspondiente del modelo. Además, también puede asignar valores a las propiedades del objeto ` model `, ya sean propiedades de contexto o propiedades obligatorias, con el mismo efecto. Sin embargo, el delegado no puede modificar los datos del modelo asignando valores a propiedades obligatorias rellenadas por la vista. Si se asigna un valor a una propiedad obligatoria de un delegado, se rompe el enlace que actualiza dicha propiedad a partir de los datos del modelo. Esto hace que la propiedad obligatoria conserve el valor que se le ha asignado, incluso si el modelo cambia posteriormente. DelegateModel.Qt5ReadWrite es el valor por defecto de delegateModelAccess.
DelegateModel.ReadOnlyEl delegado no puede asignar valores a las propiedades de contexto proporcionadas por la vista, ni tampoco a las propiedades del objeto ` model `. Asignar un valor a una propiedad obligatoria rellenada por la vista no rompe el enlace interno, ni tampoco modificará ningún dato del modelo. La propiedad obligatoria conservará el valor que se le haya asignado hasta que el elemento del modelo vuelva a cambiar.
DelegateModel.ReadWriteEl delegado puede asignar valores a cualquier propiedad de contexto proporcionada por la vista con el fin de modificar el elemento del modelo correspondiente. Además, también puede asignar valores a las propiedades del objeto ` model `, ya sea como propiedad de contexto o como propiedad obligatoria, con el mismo efecto. El delegado también puede modificar los datos del modelo asignando valores a las propiedades obligatorias rellenadas por la vista. La asignación de un valor a una propiedad obligatoria propagará dicho valor al elemento del modelo correspondiente sin romper los enlaces internos.

Algunos modelos son objetos con identidades independientes a los que hace referencia la vista. El objeto original es la única fuente de verdad para la creación de delegados. No se copia. Dichos modelos se actualizarán de forma visible al escribir a través de los delegados.

Otros modelos no tienen una identidad independiente y se copian al asignarlos a la vista. En el caso de estos modelos, solo se actualizan los componentes internos de la vista al escribir a través del delegado. El modelo original permanece inalterado.

En general, los tipos de objeto de QML tienen identidades independientes, mientras que los tipos de valor de QML no. Así pues, ListModel, cualquier elemento derivado de QAbstractItemModel, así como una instancia única de un tipo de objeto o una lista de instancias de tipos de objeto, se actualizarán cuando se pasen como modelo y se escriba a través del delegado. Sin embargo, las matrices de JavaScript, las listas de tipos de valor o los números simples no se actualizan cuando se modifican los datos del modelo a través del delegado.

Además, al implementar tu propio modelo en C++, debes implementar ` setData ` para recibir cualquier actualización pasada desde los delegados.

Supongamos que se registra un modelo de C++ basado en « QAbstractItemModel » que implementa el método « setData » como un tipo QML denominado « EditableModel ». Los datos se podrían escribir en el modelo de la siguiente manera:

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

    // Make sure that changes to the required property are propagated
    delegateModelAccess: DelegateModel.ReadWrite

    delegate: TextEdit {
        required property string edit

        width: ListView.view.width
        height: 30
        text: edit
        Keys.onReturnPressed: edit = text
    }
}

También puedes modificar los datos del modelo manipulando el objeto ` model ` de la siguiente manera:

ListView {
    anchors.fill: parent
    model: EditableModel {}
    delegate: TextEdit {
        required property QtObject model

        width: ListView.view.width
        height: 30
        text: model.edit
        Keys.onReturnPressed: model.edit = text
    }
}

Nota: El rol « edit » es equivalente a « Qt::EditRole ». Consulte « roleNames()» para ver los nombres de los roles integrados. Sin embargo, en los modelos reales se suelen registrar roles personalizados.

Para obtener más información, consulta el artículo «Uso de modelos C++ con vistas de Qt Quick ».

Uso de transiciones

Las transiciones se pueden utilizar para animar elementos que se añaden a un posicionador, se mueven dentro de él o se eliminan de él.

Las transiciones para añadir elementos se aplican tanto a los elementos creados como parte de un posicionador como a aquellos a los que se les cambia la relación de parentesco para que pasen a ser hijos de un posicionador.

Las transiciones para eliminar elementos se aplican a los elementos que se eliminan de un posicionador, así como a aquellos que se retiran de un posicionador y se les asignan nuevos padres en un documento.

Nota: Cambiar la opacidad de los elementos a cero no hará que desaparezcan del posicionador. Se pueden eliminar y volver a añadir cambiando la propiedad «visible».

© 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.