En esta página

Tutorial de Modelo/Vista

Todo desarrollador de interfaces de usuario debería conocer la programación Modelo/Vista, y el objetivo de este tutorial es ofrecerte una introducción fácil de entender sobre este tema.

Los widgets de tabla, lista y árbol son componentes que se utilizan con frecuencia en las interfaces gráficas de usuario (GUI). Existen dos formas diferentes en las que estos widgets pueden acceder a sus datos. La forma tradicional consiste en que los widgets incluyan contenedores internos para almacenar datos. Este enfoque es muy intuitivo; sin embargo, en muchas aplicaciones complejas, da lugar a problemas de sincronización de datos. El segundo enfoque es la programación Modelo/Vista, en la que los widgets no mantienen contenedores de datos internos. Acceden a datos externos a través de una interfaz estandarizada y, por lo tanto, evitan la duplicación de datos. Esto puede parecer complicado al principio, pero una vez que lo analizas más detenidamente, no solo resulta fácil de comprender, sino que también quedan más claras las numerosas ventajas de la programación Modelo/Vista.

Directorio y su contenido en una vista en árbol

A lo largo del proceso, aprenderemos algunas tecnologías básicas que ofrece Qt, tales como:

  • La diferencia entre los widgets estándar y los de modelo/vista
  • Los adaptadores entre formularios y modelos
  • El desarrollo de una aplicación sencilla de modelo/vista
  • Modelos predefinidos
  • Temas intermedios como:
    • Vistas en árbol
    • Selección
    • Delegados
    • Depuración con pruebas de modelos

También descubrirás si tu nueva aplicación se puede desarrollar más fácilmente con programación modelo-vista o si los widgets clásicos funcionarán igual de bien.

Este tutorial incluye código de ejemplo que puedes editar e integrar en tu proyecto. El código fuente del tutorial se encuentra en el directorio examples/widgets/tutorials/modelview de Qt Widgets.

Si deseas obtener información más detallada, también puedes consultar la documentación de referencia.

1. Introducción

El modelo/vista es una tecnología que se utiliza para separar los datos de las vistas en los widgets que gestionan conjuntos de datos. Los widgets estándar no están diseñados para separar los datos de las vistas y, por eso, Qt cuenta con dos tipos diferentes de widgets. Ambos tipos de widgets tienen el mismo aspecto, pero interactúan con los datos de forma diferente.

Los widgets estándar utilizan datos que forman parte del propio widget.

Estructura en la que la «vista» está separada de los «datos»

Las clases de vista operan con datos externos (el modelo)

Estructura que utiliza una «vista» y un «modelo» para los datos

1.1 Widgets estándar

Echemos un vistazo más de cerca a un widget de tabla estándar. Un widget de tabla es una matriz bidimensional de elementos de datos que el usuario puede modificar. El widget de tabla puede integrarse en el flujo de un programa leyendo y escribiendo los elementos de datos que proporciona. Este método es muy intuitivo y útil en muchas aplicaciones, pero mostrar y editar una tabla de base de datos con un widget de tabla estándar puede resultar problemático. Hay que coordinar dos copias de los datos: una fuera del widget y otra dentro del mismo. El desarrollador es responsable de sincronizar ambas versiones. Además, el estrecho acoplamiento entre la presentación y los datos dificulta la redacción de pruebas unitarias.

1.2 El modelo/vista al rescate

El modelo/vista ha dado un paso al frente para ofrecer una solución que utiliza una arquitectura más versátil. El modelo/vista elimina los problemas de coherencia de datos que pueden surgir con los widgets estándar. El modelo/vista también facilita el uso de más de una vista de los mismos datos, ya que un modelo puede pasarse a muchas vistas. La diferencia más importante es que los widgets de modelo/vista no almacenan datos detrás de las celdas de la tabla. De hecho, operan directamente a partir de tus datos. Dado que las clases de vista desconocen la estructura de tus datos, debes proporcionar un envoltorio (wrapper) para que tus datos se ajusten a la interfaz ` QAbstractItemModel `. Una vista utiliza esta interfaz para leer y escribir en tus datos. Cualquier instancia de una clase que implemente ` QAbstractItemModel ` se considera un modelo. Una vez que la vista recibe un puntero a un modelo, leerá y mostrará su contenido, y actuará como su editor.

1.3 Descripción general de los widgets de modelo/vista

A continuación se ofrece una descripción general de los widgets de modelo/vista y sus correspondientes widgets estándar.

WidgetWidget estándar
(una clase de conveniencia basada en elementos)
Clase de vista «Modelo/Vista»
(para usar con datos externos)
Directorio que muestra su contenido en forma de listaQListWidgetQListView
Directorio que muestra su contenido en forma de tablaQTableWidgetQTableView
Directorio que muestra su contenido en forma de árbolQTreeWidgetQTreeView
Directorio que muestra su contenido en columnasQColumnView muestra un árbol como una jerarquía de listas
Cuadro combinado que muestra una entrada del modeloQComboBox puede funcionar tanto como clase de vista como widget tradicional

1.4 Uso de adaptadores entre formularios y modelos

Disponer de adaptadores entre formularios y modelos puede resultar muy útil.

Podemos editar los datos almacenados en las tablas directamente desde la propia tabla, pero resulta mucho más cómodo editarlos en campos de texto. No existe un equivalente directo en el modelo/vista que separe los datos y las vistas para los widgets que operan sobre un valor (QLineEdit, QCheckBox...) en lugar de un conjunto de datos, por lo que necesitamos un adaptador para conectar el formulario a la fuente de datos.

QDataWidgetMapper es una solución estupenda porque asigna los widgets del formulario a una fila de la tabla y facilita mucho la creación de formularios para tablas de bases de datos.

Formulario con datos personales y de otro tipo

Otro ejemplo de adaptador es QCompleter. Qt cuenta con QCompleter para proporcionar autocompletado en Qt Widgets como QComboBox y, tal y como se muestra a continuación, QLineEdit. QCompleter utiliza un modelo como fuente de datos.

Completa con sugerencias para los personajes «Em»

2. Una aplicación sencilla de modelo/vista

Si quieres desarrollar una aplicación modelo/vista, ¿por dónde deberías empezar? Te recomendamos comenzar con un ejemplo sencillo y ampliarlo paso a paso. Esto facilita mucho la comprensión de la arquitectura. Intentar comprender la arquitectura de modelo/vista en detalle antes de abrir el IDE ha resultado ser menos práctico para muchos desarrolladores. Es mucho más sencillo empezar con una aplicación sencilla de modelo/vista que contenga datos de demostración. ¡Pruébalo! Solo tienes que sustituir los datos de los ejemplos siguientes por los tuyos propios.

A continuación se muestran siete aplicaciones muy sencillas e independientes que muestran diferentes aspectos de la programación Modelo-Vista. El código fuente se encuentra en el directorio « examples/widgets/tutorials/modelview ».

2.1 Una tabla de solo lectura

Comenzamos con una aplicación que utiliza un QTableView para mostrar datos. Más adelante añadiremos funciones de edición.

(archivo fuente: examples/widgets/tutorials/modelview/1_readonly/main.cpp)

// main.cpp
#include <QApplication>
#include <QTableView>
#include "mymodel.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QTableView tableView;
    MyModel myModel;
    tableView.setModel(&myModel);
    tableView.show();
    return a.exec();
}

Tenemos la función main() habitual:

Aquí viene lo interesante: creamos una instancia de `MyModel` y utilizamos ` tableView.setModel(&myModel);` para pasar un puntero a la misma a ` tableView`. ` tableView ` invocará los métodos del puntero que ha recibido para averiguar dos cosas:

  • Cuántas filas y columnas deben mostrarse.
  • Qué contenido debe mostrarse en cada celda.

El modelo necesita algo de código para responder a esto.

Tenemos un conjunto de datos en forma de tabla, así que empecemos con ` QAbstractTableModel `, ya que es más fácil de usar que el más general ` QAbstractItemModel`.

(fuente del archivo: examples/widgets/tutorials/modelview/1_readonly/mymodel.h)

// mymodel.h
#include <QAbstractTableModel>

class MyModel : public QAbstractTableModel
{
    Q_OBJECT
public:
    explicit MyModel(QObject *parent = nullptr);

    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
};

QAbstractTableModel requiere la implementación de tres métodos abstractos.

(archivo fuente: examples/widgets/tutorials/modelview/1_readonly/mymodel.cpp)

// mymodel.cpp
#include "mymodel.h"

MyModel::MyModel(QObject *parent)
    : QAbstractTableModel(parent)
{
}

int MyModel::rowCount(const QModelIndex & /*parent*/) const
{
   return 2;
}

int MyModel::columnCount(const QModelIndex & /*parent*/) const
{
    return 3;
}

QVariant MyModel::data(const QModelIndex &index, int role) const
{
    if (role == Qt::DisplayRole)
       return QString("Row%1, Column%2")
                   .arg(index.row() + 1)
                   .arg(index.column() +1);

    return QVariant();
}

El número de filas y columnas se proporciona mediante MyModel::rowCount() y MyModel::columnCount(). Cuando la vista necesita conocer el texto de la celda, llama al método MyModel::data(). La información de la fila y la columna se especifica con el parámetro index y la función se establece en Qt::DisplayRole. En la siguiente sección se tratan otras funciones. En nuestro ejemplo, los datos que deben mostrarse se generan. En una aplicación real, ` MyModel ` tendría un miembro llamado ` MyData`, que serviría como destino para todas las operaciones de lectura y escritura.

Este pequeño ejemplo ilustra la naturaleza pasiva de un modelo. El modelo no sabe cuándo se utilizará ni qué datos se necesitan. Simplemente proporciona datos cada vez que la vista los solicita.

¿Qué ocurre cuando es necesario modificar los datos del modelo? ¿Cómo se da cuenta la vista de que los datos han cambiado y deben leerse de nuevo? El modelo tiene que emitir una señal que indique qué rango de celdas ha cambiado. Esto se demostrará en la sección 2.3.

2.2 Ampliación del ejemplo «solo lectura» con roles

Además de controlar qué texto muestra la vista, el modelo también controla el aspecto de dicho texto. Cuando modificamos ligeramente el modelo, obtenemos el siguiente resultado:

Tabla con formato personalizado aplicado a sus celdas

De hecho, para configurar las fuentes, el color de fondo, la alineación y una casilla de selección, no es necesario cambiar nada más que el método ` data()`. A continuación se muestra el método ` data()` que produce el resultado mostrado anteriormente. La diferencia es que, en esta ocasión, utilizamos el parámetro `int role` para devolver información diferente en función de su valor.

(archivo fuente: examples/widgets/tutorials/modelview/2_formatting/mymodel.cpp)

// mymodel.cpp
QVariant MyModel::data(const QModelIndex&index, int role) const
{
    int row = index.row();
    int col = index.column();
    // generar un mensaje de registro cuando se llame a este método
    qDebug() << QString("row %1, col%2, role %3")
           .arg(fila).arg(columna).arg(papel);

    switch (papel) {
    case Qt::DisplayRole:
        if (row== 0&& col== 1) return QString("<--izquierda");
        if (fila== 1&& columna== 1) return QString("derecha-->");

        return QString("Fila%1, Columna%2")
                .arg(row + 1)
                .arg(col+ 1);
    case Qt::FontRole:
        if (row== 0&& col== 0) { // cambia la fuente solo para la celda (0,0)
            QFont boldFont;
            boldFont.setBold(true);
            return boldFont;
        }
        break;
    case Qt::BackgroundRole:
        if (row== 1&& col== 2)  // cambiar el fondo solo para la celda (1,2)
            return QBrush(Qt::red);
        break;
    case Qt::TextAlignmentRole:
        if (fila== 1&& columna== 1) // cambia la alineación del texto solo para la celda (1,1)
            return int(Qt::AlignRight | Qt::AlignVCenter);
        break;
    case Qt::CheckStateRole:
        if (row== 1&& col== 0) // añadir una casilla de selección a la celda (1,0)
            return Qt::Checked;
        break;
    }
    return QVariant();
}

Cada propiedad de formato se solicitará al modelo mediante una llamada independiente al método data(). El parámetro role se utiliza para indicar al modelo qué propiedad se está solicitando:

enum Qt::ItemDataRoleSignificadoTipo
Qt::DisplayRoletextQString
Qt::FontRolefuenteQFont
BackgroundRolepincel para el fondo de la celdaQBrush
Qt::TextAlignmentRolealineación del textoenum Qt::AlignmentFlag
Qt::CheckStateRoleoculta las casillas de selección con « QVariant() »,

establece casillas de verificación con Qt::Checked

o Qt::Unchecked

enum Qt::ItemDataRole

Consulta la documentación del espacio de nombres Qt para obtener más información sobre las capacidades de la enumeración « Qt::ItemDataRole ».

Ahora tenemos que determinar cómo afecta al rendimiento de la aplicación el uso de un modelo separado, así que vamos a rastrear con qué frecuencia la vista llama al método ` data()`. Para hacer un seguimiento de la frecuencia con la que la vista llama al modelo, hemos incluido una instrucción de depuración en el método ` data()`, que registra la información en el flujo de salida de errores. En nuestro pequeño ejemplo, se llamará a ` data()` 42 veces. Cada vez que pases el cursor por encima del campo, se volverá a llamar a ` data()`: 7 veces por cada celda. Por eso es importante asegurarse de que los datos estén disponibles cuando se invoque a ` data()` y de que las operaciones de búsqueda que consumen muchos recursos se almacenen en caché.

2.3 Un reloj dentro de una celda de la tabla

Tabla que muestra la hora en una celda

Seguimos teniendo una tabla de solo lectura, pero esta vez el contenido cambia cada segundo porque estamos mostrando la hora actual.

(archivo fuente: examples/widgets/tutorials/modelview/3_changingmodel/mymodel.cpp)

QVariant MyModel::data(const QModelIndex &index, int role) const
{
    int row = index.row();
    int col = index.column();

    if (role == Qt::DisplayRole && row == 0 && col == 0)
        return QTime::currentTime().toString();

    return QVariant();
}

Falta algo para que el reloj funcione. Tenemos que indicar a la vista cada segundo que la hora ha cambiado y que debe volver a leerla. Para ello utilizamos un temporizador. En el constructor, establecemos su intervalo en 1 segundo y conectamos su señal de tiempo de espera.

(archivo fuente: examples/widgets/tutorials/modelview/3_changingmodel/mymodel.cpp)

MyModel::MyModel(QObject *parent)
    : QAbstractTableModel(parent)
    , timer(new QTimer(this))
{
    timer->setInterval(1000);
    connect(timer, &QTimer::timeout , this, &MyModel::timerHit);
    timer->start();
}

Aquí está el slot correspondiente:

(archivo fuente: examples/widgets/tutorials/modelview/3_changingmodel/mymodel.cpp)

void MyModel::timerHit()
{
    // we identify the top left cell
    QModelIndex topLeft = createIndex(0,0);
    // emit a signal to make the view reread identified data
    emit dataChanged(topLeft, topLeft, {Qt::DisplayRole});
}

Le pedimos a la vista que vuelva a leer los datos de la celda superior izquierda emitiendo la señal « dataChanged()». Fíjate en que no hemos conectado explícitamente la señal « dataChanged()» a la vista. Esto se ha producido automáticamente al llamar a « setModel()».

2.4 Configuración de los encabezados de columnas y filas

Los encabezados se pueden ocultar mediante un método de la vista: tableView->verticalHeader()->hide();

Tabla en la que se muestran los encabezados de las columnas

Sin embargo, el contenido de los encabezados se configura a través del modelo, por lo que reimplementamos el método ` headerData()`:

(fuente del archivo: examples/widgets/tutorials/modelview/4_headers/mymodel.cpp)

QVariant MyModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
        switch (section) {
        case 0:
            return QString("first");
        case 1:
            return QString("second");
        case 2:
            return QString("third");
        }
    }
    return QVariant();
}

Ten en cuenta que el método headerData() también tiene un parámetro «role», que tiene el mismo significado que en MyModel::data().

2.5 El ejemplo de edición mínima

En este ejemplo, vamos a crear una aplicación que rellene automáticamente el título de una ventana con el contenido obtenido al repetir los valores introducidos en las celdas de una tabla. Para poder acceder fácilmente al título de la ventana, colocamos el método QTableView dentro de un QMainWindow.

El modelo decide si las funciones de edición están disponibles. Solo tenemos que modificar el modelo para que se habiliten las funciones de edición disponibles. Esto se consigue reimplementando los siguientes métodos virtuales: ` setData()` y ` flags()`.

(archivo fuente: examples/widgets/tutorials/modelview/5_edit/mymodel.h)

// mymodel.h
#include <QAbstractTableModel>
#include <QString>

const int COLS= 3;
const int ROWS= 2;

class MyModel : public QAbstractTableModel
{
    Q_OBJECT
public:
    MyModel(QObject *parent = nullptr);
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
private:
    QString m_gridData[ROWS][COLS];  //holds text entered into QTableView
signals:
    void editCompleted(const QString &);
};

Utilizamos the, la matriz bidimensional QString y m_gridData para almacenar nuestros datos. Esto convierte a m_gridData en el núcleo de MyModel. El resto de MyModel actúa como un envoltorio y adapta m_gridData a la interfaz QAbstractItemModel. También hemos introducido la señal editCompleted(), que permite transferir el texto modificado al título de la ventana.

(archivo fuente: examples/widgets/tutorials/modelview/5_edit/mymodel.cpp)

bool MyModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (role == Qt::EditRole) {
        if (!checkIndex(index))
            return false;
        //save value from editor to member m_gridData
        m_gridData[index.row()][index.column()] = value.toString();
        //for presentation purposes only: build and emit a joined string
        QString result;
        for (int row = 0; row < ROWS; row++) {
            for (int col= 0; col < COLS; col++)
                result += m_gridData[row][col] + ' ';
        }
        emit editCompleted(result);
        return true;
    }
    return false;
}

setData() se llamará cada vez que el usuario edite una celda. El parámetro index nos indica qué campo se ha editado y value proporciona el resultado del proceso de edición. El rol siempre se establecerá en « Qt::EditRole », ya que nuestras celdas solo contienen texto. Si hubiera una casilla de selección y los permisos del usuario estuvieran configurados para permitir su selección, las llamadas también se realizarían con el rol establecido en « Qt::CheckStateRole ».

(archivo fuente: examples/widgets/tutorials/modelview/5_edit/mymodel.cpp)

Qt::ItemFlags MyModel::flags(const QModelIndex &index) const
{
    return Qt::ItemIsEditable | QAbstractTableModel::flags(index);
}

Se pueden ajustar diversas propiedades de una celda con flags().

Basta con devolver Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled para indicar al editor que una celda puede seleccionarse.

Si al editar una celda se modifican más datos que los que contiene esa celda en concreto, el modelo debe emitir una señal « dataChanged()» para que se lean los datos que se han modificado.

3. Temas intermedios

3.1 TreeView

Puedes convertir el ejemplo anterior en una aplicación con una vista en árbol. Basta con sustituir QTableView por QTreeView, lo que da como resultado un árbol de lectura y escritura. No es necesario realizar ningún cambio en el modelo. El árbol no tendrá jerarquías, ya que no hay jerarquías en el propio modelo.

Vista en árbol que muestra los datos de una tabla sin jerarquía

QListView, tanto QTableView como QTreeView utilizan una abstracción del modelo, que es una combinación de lista, tabla y árbol. Esto permite utilizar varios tipos diferentes de clases de vista a partir del mismo modelo.

Diagrama en el que se comparan el modelo de lista, el modelo de tabla y el modelo de árbol

Así es como se ve nuestro modelo de ejemplo hasta ahora:

Esquema de la estructura del modelo actual

Queremos mostrar un árbol real. En los ejemplos anteriores hemos envuelto nuestros datos para crear un modelo. En esta ocasión utilizamos QStandardItemModel, que es un contenedor de datos jerárquicos que también implementa QAbstractItemModel. Para mostrar un árbol, QStandardItemModel debe rellenarse con elementos QStandardItem, que pueden contener todas las propiedades estándar de los elementos, como texto, fuentes, casillas de selección o pinceles.

Esquema del modelo y la vista

(archivo fuente: examples/widgets/tutorials/modelview/6_treeview/mainwindow.cpp)

// modelview.cpp
#include "mainwindow.h"

#include <QTreeView>
#include <QStandardItemModel>
#include <QStandardItem>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , treeView(new QTreeView(this))
    , standardModel(new QStandardItemModel(this))
{
    setCentralWidget(treeView);

    QList<QStandardItem *> preparedRow = prepareRow("first", "second", "third");
    QStandardItem *item = standardModel->invisibleRootItem();
    // adding a row to the invisible root item produces a root element
    item->appendRow(preparedRow);

    QList<QStandardItem *> secondRow = prepareRow("111", "222", "333");
    // adding a row to an item starts a subtree
    preparedRow.first()->appendRow(secondRow);

    treeView->setModel(standardModel);
    treeView->expandAll();
}

QList<QStandardItem *> MainWindow::prepareRow(const QString &first,
                                              const QString &second,
                                              const QString &third) const
{
    return {new QStandardItem(first),
            new QStandardItem(second),
            new QStandardItem(third)};
}

Simplemente instanciamos un ` QStandardItemModel ` y añadimos un par de ` QStandardItems ` al constructor. A continuación, podemos crear una estructura de datos jerárquica, ya que un ` QStandardItem ` puede contener otros ` QStandardItems`. Los nodos se contraen y se expanden dentro de la vista.

3.2 Trabajar con selecciones

Queremos acceder al contenido de un elemento seleccionado para mostrarlo en el título de la ventana junto con el nivel jerárquico.

Vista de un modelo en el que el contenido seleccionado aparece en azul

Así pues, creemos un par de elementos:

(archivo fuente: examples/widgets/tutorials/modelview/7_selections/mainwindow.cpp)

#include "mainwindow.h"

#include <QTreeView>
#include <QStandardItemModel>
#include <QItemSelectionModel>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , treeView(new QTreeView(this))
    , standardModel(new QStandardItemModel(this))
{
    setCentralWidget(treeView);
    auto *rootNode = standardModel->invisibleRootItem();

    // defining a couple of items
    auto *americaItem = new QStandardItem("America");
    auto *mexicoItem =  new QStandardItem("Canada");
    auto *usaItem =     new QStandardItem("USA");
    auto *bostonItem =  new QStandardItem("Boston");
    auto *europeItem =  new QStandardItem("Europe");
    auto *italyItem =   new QStandardItem("Italy");
    auto *romeItem =    new QStandardItem("Rome");
    auto *veronaItem =  new QStandardItem("Verona");

    // building up the hierarchy
    rootNode->    appendRow(americaItem);
    rootNode->    appendRow(europeItem);
    americaItem-> appendRow(mexicoItem);
    americaItem-> appendRow(usaItem);
    usaItem->     appendRow(bostonItem);
    europeItem->  appendRow(italyItem);
    italyItem->   appendRow(romeItem);
    italyItem->   appendRow(veronaItem);

    // register the model
    treeView->setModel(standardModel);
    treeView->expandAll();

    // selection changes shall trigger a slot
    QItemSelectionModel *selectionModel = treeView->selectionModel();
    connect(selectionModel, &QItemSelectionModel::selectionChanged,
            this, &MainWindow::selectionChangedSlot);
}

Las vistas gestionan las selecciones dentro de un modelo de selección independiente, al que se puede acceder mediante el método selectionModel(). Obtenemos el modelo de selección para conectar un slot a su señal selectionChanged().

(archivo fuente: examples/widgets/tutorials/modelview/7_selections/mainwindow.cpp)

void MainWindow::selectionChangedSlot(const QItemSelection & /*newSelection*/, const QItemSelection & /*oldSelection*/)
{
    // get the text of the selected item
    const QModelIndex index = treeView->selectionModel()->currentIndex();
    QString selectedText = index.data(Qt::DisplayRole).toString();
    // find out the hierarchy level of the selected item
    int hierarchyLevel = 1;
    QModelIndex seekRoot = index;
    while (seekRoot.parent().isValid()) {
        seekRoot = seekRoot.parent();
        hierarchyLevel++;
    }
    QString showString = QString("%1, Level %2").arg(selectedText)
                         .arg(hierarchyLevel);
    setWindowTitle(showString);
}

Obtenemos el índice del modelo que corresponde a la selección llamando a ` treeView->selectionModel()->currentIndex()` y obtenemos la cadena del campo utilizando dicho índice. A continuación, simplemente calculamos el ` hierarchyLevel` del elemento. Los elementos de nivel superior no tienen padres y el método ` parent()` devolverá un ` QModelIndex()` construido por defecto. Por eso utilizamos el método ` parent()` para iterar hasta el nivel superior mientras contamos los pasos realizados durante la iteración.

El modelo de selección (tal y como se muestra arriba) se puede recuperar, pero también se puede establecer con ` QAbstractItemView::setSelectionModel`. Así es como es posible tener tres clases de vista con selecciones sincronizadas, ya que solo se utiliza una instancia de un modelo de selección. Para compartir un modelo de selección entre tres vistas, utiliza selectionModel() y asigna el resultado a la segunda y tercera clase de vista con setSelectionModel().

3.3 Modelos predefinidos

La forma habitual de utilizar el modelo/vista consiste en envolver datos específicos para que puedan utilizarse con las clases de vista. Sin embargo, Qt también proporciona modelos predefinidos para estructuras de datos subyacentes comunes. Si alguna de las estructuras de datos disponibles resulta adecuada para su aplicación, un modelo predefinido puede ser una buena opción.

QRangeModelAdapta un contenedor o rango de C++ existente
QStringListModelAlmacena una lista de cadenas
QStandardItemModelAlmacena elementos jerárquicos arbitrarios
QFileSystemModelEncapsula el sistema de archivos local
QSqlQueryModelEncapsula un conjunto de resultados SQL
QSqlTableModelEncapsula una tabla SQL
QSqlRelationalTableModelEncapsula una tabla SQL con claves foráneas
QSortFilterProxyModelOrdena y/o filtra otro modelo

3.4 Delegados

En todos los ejemplos anteriores, los datos se presentan como texto o una casilla de selección en una celda y se editan como texto o una casilla de selección. El componente que proporciona estos servicios de presentación y edición se denomina delegado. Apenas estamos empezando a trabajar con el delegado, ya que la vista utiliza un delegado por defecto. Pero imaginemos que queremos utilizar un editor diferente (por ejemplo, un control deslizante o una lista desplegable). O imaginemos que queremos presentar los datos en forma de gráficos. Veamos un ejemplo llamado «Star Delegate», en el que se utilizan estrellas para mostrar una valoración:

Tabla en la que se muestran las canciones y sus valoraciones por estrellas

La vista dispone de un método ` setItemDelegate()` que sustituye al delegado predeterminado e instala un delegado personalizado. Se puede escribir un nuevo delegado creando una clase que herede de ` QStyledItemDelegate`. Para escribir un delegado que muestre estrellas y no tenga capacidades de entrada, solo necesitamos sobrescribir dos métodos.

class StarDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    StarDelegate(QWidget *parent = nullptr);
    void paint(QPainter *painter, const QStyleOptionViewItem &option,
               const QModelIndex &index) const;
    QSize sizeHint(const QStyleOptionViewItem &option,
                   const QModelIndex &index) const;
};

paint() dibuja estrellas en función del contenido de los datos subyacentes. Los datos se pueden consultar llamando a index.data(). El método sizeHint() del delegado se utiliza para obtener las dimensiones de cada estrella, de modo que la celda proporcione la altura y la anchura suficientes para albergar las estrellas.

Escribir delegados personalizados es la opción adecuada si deseas mostrar tus datos con una representación gráfica personalizada dentro de la cuadrícula de la clase de vista. Si deseas salir de la cuadrícula, no deberías utilizar un delegado personalizado, sino una clase de vista personalizada.

Otras referencias a los delegados en la documentación de Qt:

3.5 Depuración con ModelTest

La naturaleza pasiva de los modelos plantea nuevos retos a los programadores. Las inconsistencias en el modelo pueden provocar que la aplicación se cuelgue. Dado que el modelo recibe numerosas llamadas desde la vista, resulta difícil averiguar qué llamada ha provocado el fallo de la aplicación y qué operación ha generado el problema.

Qt Labs ofrece un software llamado ModelTest, que comprueba los modelos mientras se ejecuta el código. Cada vez que se modifica el modelo, ModelTest lo analiza e informa de los errores mediante un assert. Esto es especialmente importante para los modelos de árbol, ya que su naturaleza jerárquica da lugar a muchas posibilidades de inconsistencias sutiles.

A diferencia de las clases de vista, ModelTest utiliza índices fuera de rango para probar el modelo. Esto significa que tu aplicación podría bloquearse con ModelTest incluso si funciona perfectamente sin él. Por lo tanto, también debes gestionar todos los índices que estén fuera de rango cuando utilices ModelTest.

Ejemplos

Qt incluye varios ejemplos de modelo/vista. Los encontrarás en la página de ejemplos de vistas de elementos.

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