TableView QML Type

Proporciona una vista de tabla de elementos para mostrar datos de un modelo. Más...

• Lista de todos los miembros, incluidos los heredados
• Miembros obsoletos

Propiedades

• alternatingRows : bool
• animate : bool (since 6.4)
• bottomRow : int
• columnSpacing : real
• columnWidthProvider : var
• columns : int
• contentHeight : real
• contentWidth : real
• currentColumn : int
• currentRow : int
• delegate : Component
• delegateModelAccess : enumeration (since 6.10)
• editTriggers : enumeration (since 6.5)
• keyNavigationEnabled : bool (since 6.4)
• leftColumn : int
• model : model
• pointerNavigationEnabled : bool (since 6.4)
• resizableColumns : bool (since 6.5)
• resizableRows : bool (since 6.5)
• reuseItems : bool
• rightColumn : int
• rowHeightProvider : var
• rowSpacing : real
• rows : int
• selectionBehavior : enumeration (since 6.4)
• selectionMode : enumeration (since 6.6)
• selectionModel : ItemSelectionModel (since 6.2)
• syncDirection : Qt::Orientations
• syncView : TableView
• topRow : int

Propiedades anexas

• editDelegate : Component
• view : TableView

Señales

• columnMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) (since 6.8)
• layoutChanged() (since 6.5)
• rowMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) (since 6.8)

Señales adjuntas

• commit()
• pooled()
• reused()

Métodos

• point cellAtIndex(QModelIndex modelIndex) (since 6.4)
• Point cellAtPosition(point position, bool includeSpacing)
• Point cellAtPosition(real x, real y, bool includeSpacing)
• void clearColumnReordering() (since 6.8)
• void clearColumnWidths()
• void clearRowHeights()
• void clearRowReordering() (since 6.8)
• void closeEditor() (since 6.5)
• int columnAtIndex(QModelIndex modelIndex) (since 6.4)
• real columnWidth(int column) (since 6.2)
• void edit(QModelIndex modelIndex) (since 6.5)
• real explicitColumnWidth(int column)
• real explicitRowHeight(int row)
• void forceLayout()
• real implicitColumnWidth(int column) (since 6.2)
• real implicitRowHeight(int row) (since 6.2)
• QModelIndex index(int row, int column) (since 6.4.3)
• bool isColumnLoaded(int column) (since 6.2)
• bool isRowLoaded(int row) (since 6.2)
• Item itemAtCell(point cell)
• Item itemAtIndex(QModelIndex index) (since 6.5)
• QModelIndex modelIndex(point cell) (since 6.4)
• void moveColumn(int source, int destination) (since 6.8)
• void moveRow(int source, int destination) (since 6.8)
• void positionViewAtCell(point cell, PositionMode mode, point offset, rect subRect)
• void positionViewAtColumn(int column, PositionMode mode, real offset, rect subRect)
• void positionViewAtIndex(QModelIndex index, PositionMode mode, point offset, rect subRect) (since 6.5)
• void positionViewAtRow(int row, PositionMode mode, real offset, rect subRect)
• int rowAtIndex(QModelIndex modelIndex) (since 6.4)
• real rowHeight(int row) (since 6.2)
• void setColumnWidth(int column, real size)
• void setRowHeight(int row, real size)

Descripción detallada

Un TableView tiene un model que define los datos a mostrar, y un delegate que define cómo deben mostrarse los datos.

TableView hereda Flickable. Esto significa que mientras el modelo puede tener cualquier número de filas y columnas, sólo una subsección de la tabla es normalmente visible dentro de la ventana gráfica. Tan pronto como se hace un "flick", nuevas filas y columnas entran en la ventana gráfica, mientras que las antiguas salen y son eliminadas de la ventana. Las filas y columnas que salen se reutilizan para construir las filas y columnas que entran en la ventana. De este modo, TableView admite modelos de cualquier tamaño sin afectar al rendimiento.

Una VistaTabla muestra datos de modelos creados a partir de tipos QML incorporados como ListModel y XmlListModel, que sólo rellenan la primera columna en una VistaTabla. Para crear modelos con varias columnas, utilice TableModel o un modelo C++ que herede de QAbstractItemModel.

Un TableView no incluye cabeceras por defecto. Puede añadir cabeceras utilizando HorizontalHeaderView y VerticalHeaderView de Qt Quick Controls.

Ejemplo de uso

Modelos C

El siguiente ejemplo muestra cómo crear un modelo desde C++ con múltiples columnas:

#include <qqml.h>
#include <QAbstractTableModel>

class TableModel : public QAbstractTableModel
{
    Q_OBJECT
    QML_ELEMENT

public:
    int rowCount(const QModelIndex & = QModelIndex()) const override
    {
        return 200;
    }

    int columnCount(const QModelIndex & = QModelIndex()) const override
    {
        return 200;
    }

    QVariant data(const QModelIndex &index, int role) const override
    {
        switch (role) {
            case Qt::DisplayRole:
                return QString("%1, %2").arg(index.column()).arg(index.row());
            default:
                break;
        }

        return QVariant();
    }

    QHash<int, QByteArray> roleNames() const override
    {
        return { {Qt::DisplayRole, "display"} };
    }
};

Y luego el TableViewDelegate utiliza automáticamente el modelo para establecer/obtener datos hacia/desde el modelo. El TableViewDelegate utiliza el Qt::DisplayRole para mostrar texto y Qt::EditRole para editar datos en el modelo.

El siguiente fragmento muestra cómo utilizar el modelo desde QML en un delegado personalizado:

import QtQuick
import TableModel

TableView {
    anchors.fill: parent
    columnSpacing: 1
    rowSpacing: 1
    clip: true

    model: TableModel {}

    delegate: Rectangle {
        implicitWidth: 100
        implicitHeight: 50
        Text {
            text: display
        }
    }
}

Modelos QML

Para crear prototipos y mostrar datos muy sencillos (de una API web, por ejemplo), se puede utilizar TableModel:

import QtQuick
import Qt.labs.qmlmodels

TableView {
    anchors.fill: parent
    columnSpacing: 1
    rowSpacing: 1
    clip: true

    model: TableModel {
        TableModelColumn { display: "name" }
        TableModelColumn { display: "color" }

        rows: [
            {
                "name": "cat",
                "color": "black"
            },
            {
                "name": "dog",
                "color": "brown"
            },
            {
                "name": "bird",
                "color": "white"
            }
        ]
    }

    delegate: Rectangle {
        implicitWidth: 100
        implicitHeight: 50
        border.width: 1

        Text {
            text: display
            anchors.centerIn: parent
        }
    }
}

Como TableViewDelegate utiliza Qt::EditRole para establecer los datos, es necesario especificar el rol de edición en TableModelColumn cuando el delegado es TableViewDelegate:

model: TableModel {
    TableModelColumn { display: "name", edit: "name" }
    TableModelColumn { display: "color", edit: "color" }

    rows: [
        {
            "name": "cat",
            "color": "black"
        },
        {
            "name": "dog",
            "color": "brown"
        },
        {
            "name": "bird",
            "color": "white"
        }
    ]
 }

Reutilización de elementos

TableView recicla los elementos delegados por defecto, en lugar de instanciarlos desde delegate cada vez que se muestran nuevas filas y columnas. Este enfoque proporciona un gran aumento de rendimiento, dependiendo de la complejidad del delegado.

Cuando se retira un elemento, pasa a la reserva de reutilización, que es una caché interna de elementos no utilizados. Cuando esto ocurre, se emite la señal TableView::pooled para informar al elemento de ello. Del mismo modo, cuando el elemento se vuelve a mover desde la reserva, se emite la señal TableView::reused.

Cualquier propiedad del elemento que provenga del modelo se actualiza cuando se reutiliza el elemento. Esto incluye index, row, y column, pero también cualquier rol del modelo.

Si un elemento tiene temporizadores o animaciones, considera ponerlos en pausa al recibir la señal TableView::pooled. Así evitarás utilizar recursos de la CPU para elementos que no son visibles. Del mismo modo, si un elemento tiene recursos que no se pueden reutilizar, se podrían liberar.

Si no desea reutilizar elementos o si delegate no puede soportarlo, puede establecer la propiedad reuseItems a false.

El siguiente ejemplo muestra un delegado que anima un rectángulo giratorio. Cuando se agrupa, la animación se detiene temporalmente:

Component {
    id: tableViewDelegate
    Rectangle {
        implicitWidth: 100
        implicitHeight: 50

        TableView.onPooled: rotationAnimation.pause()
        TableView.onReused: rotationAnimation.resume()

        Rectangle {
            id: rect
            anchors.centerIn: parent
            width: 40
            height: 5
            color: "green"

            RotationAnimation {
                id: rotationAnimation
                target: rect
                duration: (Math.random() * 2000) + 200
                from: 0
                to: 359
                running: true
                loops: Animation.Infinite
            }
        }
    }
}

Alturas de fila y anchuras de columna

Cuando una nueva columna es desplazada a la vista, TableView determinará su anchura llamando a la función columnWidthProvider. Si está establecida, esta función decidirá por sí sola la anchura de la columna. En caso contrario, comprobará si se ha establecido una anchura explícita con setColumnWidth(). En caso contrario, se utilizará implicitColumnWidth(). La anchura implícita de una columna es la misma que la mayor implicit width encontrada entre los elementos delegados actualmente cargados en esa columna. Intentar establecer un width explícito directamente en un delegado no tiene ningún efecto, y será ignorado y sobrescrito. La misma lógica se aplica a la altura de las filas.

Una implementación de columnWidthProvider equivalente a la lógica por defecto sería:

columnWidthProvider: function(column) {
    let w = explicitColumnWidth(column)
    if (w >= 0)
        return w;
    return implicitColumnWidth(column)
}

Una vez resuelta la anchura de la columna, todos los demás elementos de la misma columna se redimensionan a esta anchura, incluidos los elementos que se desplacen a la vista posteriormente.

Si cambia los valores que un rowHeightProvider o un columnWidthProvider devuelven para filas y columnas dentro de la ventana gráfica, debe llamar a forceLayout. Esto informa a TableView que necesita utilizar las funciones del proveedor de nuevo para recalcular y actualizar el diseño.

Desde Qt 5.13, si quieres ocultar una columna específica, puedes devolver 0 desde columnWidthProvider para esa columna. Del mismo modo, puede devolver 0 desde rowHeightProvider para ocultar una fila. Si devuelve un número negativo o undefined, TableView volverá a calcular el tamaño basándose en los elementos delegados.

El siguiente ejemplo muestra cómo configurar un simple columnWidthProvider junto con un temporizador que modifica los valores que devuelve la función. Cuando se modifica el array, se llama a forceLayout para que los cambios surtan efecto:

TableView {
    id: tableView

    property var columnWidths: [100, 50, 80, 150]
    columnWidthProvider: function (column) { return columnWidths[column] }

    Timer {
        running: true
        interval: 2000
        onTriggered: {
            tableView.columnWidths[2] = 150
            tableView.forceLayout();
        }
    }
}

Edición de celdas

Puedes permitir que el usuario edite las celdas de la tabla proporcionando un delegado de edición. El delegado de edición se instanciará según editTriggers, que por defecto es cuando el usuario pulsa dos veces sobre una celda, o pulsa por ejemplo Qt::Key_Enter o Qt::Key_Return. El delegado de edición se establece usando TableView::editDelegate, que es una propiedad adjunta que se establece en delegate. El siguiente fragmento muestra cómo hacerlo:

    TableView {
        id: tableView
        anchors.fill: parent
        clip: true

        model: TableModel {
            TableModelColumn { display: "name" }
            rows: [ { "name": "Harry" }, { "name": "Hedwig" } ]
        }

        selectionModel: ItemSelectionModel {}

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 50

            Text {
                anchors.centerIn: parent
                text: display
            }

            TableView.editDelegate: TextField {
                anchors.fill: parent
                text: display
                horizontalAlignment: TextInput.AlignHCenter
                verticalAlignment: TextInput.AlignVCenter
                Component.onCompleted: selectAll()

                TableView.onCommit: {
                    display = text
                    // 'display = text' is short-hand for:
                    // let index = TableView.view.index(row, column)
                    // TableView.view.model.setData(index, "display", text)
                }
            }
        }
    }

Si el usuario pulsa Qt::Key_Enter o Qt::Key_Return mientras el delegado de edición está activo, TableView emitirá la señal TableView::commit al delegado de edición, para que pueda volver a escribir los datos modificados en el modelo.

Qt::ItemFlags QAbstractItemModelSubClass::flags(const QModelIndex &index) const override
{
    Q_UNUSED(index)
    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
}

Si TableView delegate tiene una propiedad required property bool editing definida, se establecerá en true para el delegado que se está editando. Consulte la documentación de editDelegate para ver un ejemplo de cómo utilizarla.

Sobreimpresiones y subimpresiones

Todos los nuevos elementos que se instancian desde el delegado se vinculan a contentItem con el valor z, 1. Puedes añadir tus propios ítems dentro de la Tableview, como ítems hijos del Flickable. Controlando su valor z, puedes hacer que estén encima o debajo de los elementos de la tabla.

Aquí hay un ejemplo que muestra cómo añadir un texto encima de la tabla, que se mueve junto con la tabla al deslizar:

TableView {
    id: tableView

    topMargin: header.implicitHeight

    Text {
        id: header
        text: "A table header"
    }
}

Aquí hay otro ejemplo que muestra cómo crear un elemento superpuesto que permanece encima de una celda en particular. Esto requiere un poco más de código, ya que la ubicación de una celda será change si el usuario, por ejemplo, está cambiando el tamaño de una columna delante de ella.

Rectangle {
    id: overlay
    width: 20
    height: 20
    radius: 10
    color: "blue"

    z: 10
    parent: tableView.contentItem

    Connections {
        target: tableView
        function onLayoutChanged() {
            let item = tableView.itemAtCell(5, 5)
            let insideViewport = item !== null

            overlay.visible = insideViewport
            if (insideViewport) {
                overlay.x = item.x
                overlay.y = item.y
            }
        }
    }
}

También puedes emparentar la superposición directamente con la celda en lugar de hacerlo con contentItem. Pero esto será frágil, ya que la celda se descarga o se reutiliza cada vez que se desplaza fuera de la ventana gráfica.

Seleccionar elementos

Puede añadir soporte de selección a TableView asignando un ItemSelectionModel a la propiedad selectionModel. Utilizará este modelo para controlar qué elementos delegados deben mostrarse como seleccionados y qué elemento debe mostrarse como actual. Puede configurar selectionBehavior para controlar si el usuario puede seleccionar celdas individuales, filas o columnas.

Para saber si un delegado está seleccionado o es actual, declare las siguientes propiedades (a menos que el delegado sea un TableViewDelegate, en cuyo caso las propiedades ya se han añadido):

delegate: Item {
    required property bool selected
    required property bool current
    // ...
}

El siguiente fragmento muestra cómo una aplicación puede renderizar el delegado de forma diferente dependiendo de la propiedad selected:

    TableView {
        id: tableView
        anchors.fill: parent
        clip: true

        model: TableModel {
            TableModelColumn { display: "name" }
            rows: [ { "name": "Harry" }, { "name": "Hedwig" } ]
        }

        selectionModel: ItemSelectionModel {}

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 30
            color: selected ? "blue" : "lightgray"

            required property bool selected

            Text { text: display }
        }
    }

Las propiedades currentRow y currentColumn también pueden ser útiles si necesita representar un delegado de forma diferente dependiendo de si se encuentra en la misma fila o columna que el elemento actual.

Navegación por teclado

Para soportar la navegación por teclado, necesita asignar un ItemSelectionModel a la propiedad selectionModel. TableView utilizará entonces este modelo para manipular el modelo currentIndex.

Es responsabilidad del delegado representarse a sí mismo como current. Puedes hacer esto añadiéndole una propiedad required property bool current, y dejar que la apariencia dependa de su estado. El valor de la propiedad current es establecido por el TableView. También puedes deshabilitar completamente la navegación por teclado (en caso de que quieras implementar tus propios manejadores de teclado) estableciendo keyNavigationEnabled a false.

El siguiente ejemplo demuestra cómo puede utilizar la navegación por teclado junto con las propiedades current y selected en un delegado personalizado:

ApplicationWindow {
    width: 800
    height: 600
    visible: true
    ScrollView {
        anchors.fill: parent
        TableView {
            id: tableView
            clip: true
            interactive: true
            rowSpacing: 1
            columnSpacing: 1
            model: TableModel {
                TableModelColumn { display: "checked" }
                TableModelColumn { display: "amount" }
                TableModelColumn { display: "fruitType" }
                TableModelColumn { display: "fruitName" }
                TableModelColumn { display: "fruitPrice" }

                rows: [
                    {
                        checked: false,
                        amount: 1,
                        fruitType: "Apple",
                        fruitName: "Granny Smith",
                        fruitPrice: 1.50
                    },
                    {
                        checked: true,
                        amount: 4,
                        fruitType: "Orange",
                        fruitName: "Navel",
                        fruitPrice: 2.50
                    },
                    {
                        checked: false,
                        amount: 1,
                        fruitType: "Banana",
                        fruitName: "Cavendish",
                        fruitPrice: 3.50
                    }
                ]
            }
            selectionModel: ItemSelectionModel {}
            delegate: Rectangle {
                implicitWidth: 100
                implicitHeight: 50
                required property bool selected
                required property bool current
                border.width: current ? 2 : 0
                color: selected ? "lightblue" : palette.base
                Text{
                    text: model.display
                    padding: 12
                }
            }
        }
    }
    SelectionRectangle {
        target: tableView
    }
}

Copiar y pegar

La implementación de operaciones de copiar y pegar para una TableView normalmente incluye también el uso de QUndoStack (o algún otro framework de deshacer/rehacer). El QUndoStack se puede utilizar para almacenar las diferentes operaciones realizadas en el modelo, como añadir o eliminar filas, o pegar datos desde el portapapeles, con una forma de deshacerlo de nuevo más tarde. Sin embargo, un QUndoStack que describa las posibles operaciones, y cómo deshacerlas, debe ser diseñado de acuerdo a las necesidades del modelo y de la aplicación. Como tal, TableView no ofrece una API incorporada para manejar copiar y pegar.

El siguiente fragmento puede utilizarse como referencia para añadir soporte de copiar y pegar a su modelo y TableView. Utiliza la API de datos mime existente en QAbstractItemModel, junto con QClipboard. El fragmento funcionará tal cual, pero también puede ampliarse para utilizar QUndoStack.

// Inside your C++ QAbstractTableModel subclass:

Q_INVOKABLE void copyToClipboard(const QModelIndexList &indexes) const
{
    QGuiApplication::clipboard()->setMimeData(mimeData(indexes));
}

Q_INVOKABLE bool pasteFromClipboard(const QModelIndex &targetIndex)
{
    const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData();
    // Consider using a QUndoCommand for the following call. It should store
    // the (mime) data for the model items that are about to be overwritten, so
    // that a later call to undo can revert it.
    return dropMimeData(mimeData, Qt::CopyAction, -1, -1, targetIndex);
}

Las dos funciones pueden, por ejemplo, usarse desde QML así:

TableView {
    id: tableView
    model: tableModel
    selectionModel: ItemSelectionModel {}

    Shortcut {
       sequence: StandardKey.Copy
       onActivated: {
           let indexes = tableView.selectionModel.selectedIndexes
           tableView.model.copyToClipboard(indexes)
       }
    }

    Shortcut {
       sequence: StandardKey.Paste
       onActivated: {
           let targetIndex = tableView.selectionModel.currentIndex
           tableView.model.pasteFromClipboard(targetIndex)
       }
    }
}

Véase también TableView::editDelegate, TableView::commit, editTriggers, edit(), closeEditor(), layoutChanged(), QAbstractItemModel::mimeData(), QAbstractItemModel::dropMimeData(), QUndoStack, QUndoCommand, y QClipboard.

Documentación de propiedades

alternatingRows : bool

Esta propiedad controla si el color de fondo de las filas debe alternarse. El valor por defecto depende del estilo.

background: Rectangle {
    color: control.row === control.tableView.currentRow
           ? control.palette.highlight
           : (control.tableView.alternatingRows && control.row % 2 !== 0
           ? control.palette.alternateBase
           : control.palette.base)
}

animate : bool [since 6.4]

Esta propiedad se puede establecer para controlar si TableView debe animar el contentItem (contentX y contentY). Es utilizada por positionViewAtCell(), y cuando se navega por the current index con el teclado. El valor por defecto es true.

Si se establece a false, cualquier animación en curso se detendrá inmediatamente.

Esta propiedad se introdujo en Qt 6.4.

Véase también positionViewAtCell().

bottomRow : int

Esta propiedad contiene la fila inferior visible en la vista.

Véase también leftColumn, rightColumn, y topRow.

columnSpacing : real

Esta propiedad contiene el espaciado entre las columnas.

El valor por defecto es 0.

columnWidthProvider : var

Esta propiedad puede contener una función que devuelva el ancho de columna para cada columna del modelo. Se llama siempre que TableView necesite conocer la anchura de una columna específica. La función toma un argumento, column, para el que TableView necesita conocer el ancho.

Desde Qt 5.13, si quieres ocultar una columna específica, puedes devolver 0 width para esa columna. Si devuelve un número negativo o undefined, TableView calcula el ancho basándose en los elementos delegados.

Véase también rowHeightProvider, isColumnLoaded(), y Row heights and column widths.

columns : int [read-only]

Esta propiedad contiene el número de columnas de la tabla.

Si el modelo es una lista, las columnas serán 1.

Esta propiedad es de sólo lectura.

contentHeight : real

Esta propiedad contiene la altura de la tabla necesaria para acomodar el número de filas del modelo de datos. No suele coincidir con height de view, lo que significa que la altura de la tabla puede ser mayor o menor que la altura de la ventana gráfica. Como TableView no siempre puede conocer la altura exacta de la tabla sin cargar todas las filas del modelo, contentHeight suele ser una estimación basada en la tabla cargada inicialmente.

Si sabe cuál será la altura de la tabla, asigne un valor a contentHeight, para evitar cálculos y actualizaciones innecesarias de TableView.

Véase también contentWidth y rowHeightProvider.

contentWidth : real

Esta propiedad contiene la anchura de la tabla necesaria para acomodar el número de columnas del modelo. Normalmente no es la misma que la width de view, lo que significa que la anchura de la tabla puede ser mayor o menor que la anchura de la ventana gráfica. Como TableView no siempre puede conocer la anchura exacta de la tabla sin cargar todas las columnas del modelo, contentWidth suele ser una estimación basada en la tabla cargada inicialmente.

Si sabe cuál será la anchura de la tabla, asigne un valor a contentWidth, para evitar cálculos y actualizaciones innecesarias de TableView.

Véase también contentHeight y columnWidthProvider.

currentColumn : int [read-only]

Esta propiedad de sólo lectura contiene la columna de la vista que contiene el elemento que es current.. Si no hay ningún elemento actual, será -1.

Véase también currentRow, selectionModel, y Selecting items.

currentRow : int [read-only]

Esta propiedad de sólo lectura contiene la fila de la vista que contiene el elemento que es current.. Si no hay ningún elemento actual, será -1.

Véase también currentColumn, selectionModel, y Selecting items.

delegate : Component

El delegado proporciona una plantilla que define cada elemento de celda instanciado por la vista. Puede ser cualquier componente personalizado, pero se recomienda utilizar TableViewDelegate, ya que se adapta al estilo de la aplicación y ofrece funcionalidad inmediata.

Para utilizar TableViewDelegate, basta con establecerlo como delegado:

delegate: TableViewDelegate { }

El índice del modelo se expone como una propiedad accesible de index. Lo mismo ocurre con row y column. Las propiedades del modelo también están disponibles en función del tipo de modelo de datos.

Un delegado debe especificar su tamaño utilizando implicitWidth y implicitHeight. TableView distribuye los elementos basándose en esa información. Los ajustes explícitos de anchura o altura se ignoran y sobrescriben.

Dentro del delegado, puede añadir opcionalmente una o más de las siguientes propiedades (a menos que el delegado sea un TableViewDelegate, en cuyo caso las propiedades ya han sido añadidas). TableView modifica los valores de estas propiedades para informar al delegado en qué estado se encuentra. Esto puede ser utilizado por el delegado para representarse a sí mismo de forma diferente según su propio estado.

• propiedad requerida bool current - true si el delegado está current.
• propiedad requerida bool selected - true si el delegado es selected.
• propiedad requerida bool editing - true si el delegado está siendo edited.
• propiedad requerida bool containsDrag - true si se está arrastrando una columna o fila sobre este delegado. Esta propiedad sólo es compatible con HorizontalHeaderView y VerticalHeaderView. (desde Qt 6.8)

El siguiente ejemplo muestra cómo utilizar estas propiedades en un delegado personalizado:

delegate: Rectangle {
    required property bool current
    required property bool selected
    border.width: current ? 1 : 0
    color: selected ? palette.highlight : palette.base
}

Véase también Row heights and column widths, Reusing items, Propiedades requeridas, TableViewDelegate, y Personalización de TableViewDelegate.

delegateModelAccess : enumeration [since 6.10]

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

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.

editTriggers : enumeration [default: TableView.DoubleTapped | TableView.EditKeyPressed., since 6.5]

Esta propiedad contiene las diferentes formas en que el usuario puede empezar a editar una celda. Puede ser una combinación de los siguientes valores:

Para que TableView.SelectedTapped, TableView.EditKeyPressed, y TableView.AnyKeyPressed tengan algún efecto, TableView necesita tener un selection model asignado, ya que dependen de que se establezca un current index. Para poder recibir cualquier evento de tecla, TableView también necesitará tener QQuickItem::activeFocus.

Al editar una celda, el usuario puede pulsar Qt::Key_Tab o Qt::Key_Backtab para commit los datos, y mover la edición a la siguiente celda. Este comportamiento puede desactivarse configurando QQuickItem::activeFocusOnTab en TableView a false.

Qt::ItemFlags QAbstractItemModelSubClass::flags(const QModelIndex &index) const override
{
    Q_UNUSED(index)
    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
}

Esta propiedad se introdujo en Qt 6.5.

Ver también TableView::editDelegate, TableView::commit, y Editing cells.

keyNavigationEnabled : bool [since 6.4]

Esta propiedad puede establecerse para controlar si el usuario debe poder cambiar the current index utilizando el teclado. El valor por defecto es true.

Esta propiedad se introdujo en Qt 6.4.

Véase también Keyboard navigation, selectionModel, selectionBehavior, pointerNavigationEnabled, y interactive.

leftColumn : int

Esta propiedad contiene la columna más a la izquierda que es actualmente visible dentro de la vista.

Véase también rightColumn, topRow, y bottomRow.

model : model

Esta propiedad contiene el modelo que proporciona los datos para la tabla.

El modelo proporciona el conjunto de datos que se utiliza para crear los elementos de la vista. Los modelos pueden crearse directamente en QML utilizando TableModel, ListModel, ObjectModel, o proporcionarse mediante una clase de modelo C++ personalizada. El modelo C++ debe ser una subclase de QAbstractItemModel o una lista simple.

Véase también Modelos de datos.

pointerNavigationEnabled : bool [since 6.4]

Esta propiedad puede establecerse para controlar si el usuario debe poder cambiar the current index utilizando el ratón o el tacto. El valor por defecto es true.

Esta propiedad se introdujo en Qt 6.4.

Ver también selectionModel, keyNavigationEnabled, y interactive.

resizableColumns : bool [since 6.5]

Esta propiedad indica si se permite al usuario cambiar el tamaño de las columnas arrastrando entre las celdas. El valor por defecto es false.

Esta propiedad se introdujo en Qt 6.5.

resizableRows : bool [since 6.5]

Esta propiedad indica si se permite al usuario cambiar el tamaño de las filas arrastrando entre las celdas. El valor por defecto es false.

Esta propiedad se introdujo en Qt 6.5.

reuseItems : bool

Esta propiedad indica si los elementos creados a partir de delegate deben reutilizarse o no. Si se establece a false, se destruyen todos los elementos agrupados actualmente.

Véase también Reusing items, TableView::pooled, y TableView::reused.

rightColumn : int

Esta propiedad contiene la columna más a la derecha que es actualmente visible dentro de la vista.

Véase también leftColumn, topRow, y bottomRow.

rowHeightProvider : var

Esta propiedad puede contener una función que devuelva la altura de cada fila del modelo. Se llama siempre que TableView necesita conocer la altura de una fila específica. La función toma un argumento, row, para el que TableView necesita conocer la altura.

Desde Qt 5.13, si quieres ocultar una fila específica, puedes devolver 0 height para esa fila. Si devuelves un número negativo, TableView calcula la altura basándose en los elementos delegados.

Véase también columnWidthProvider, isRowLoaded(), y Row heights and column widths.

rowSpacing : real

Esta propiedad contiene el espaciado entre las filas.

El valor por defecto es 0.

rows : int [read-only]

Esta propiedad contiene el número de filas de la tabla.

Esta propiedad es de sólo lectura.

selectionBehavior : enumeration [since 6.4]

Esta propiedad indica si el usuario puede seleccionar celdas, filas o columnas.

Esta propiedad se introdujo en Qt 6.4.

Véase también Selecting items, selectionMode, selectionModel, y keyNavigationEnabled.

selectionMode : enumeration [since 6.6]

Si selectionBehavior es igual a TableView.SelectCells, esta propiedad indica si el usuario puede seleccionar una celda cada vez o varias celdas. Si selectionBehavior es igual a TableView.SelectRows, esta propiedad indica si el usuario puede seleccionar una fila cada vez o varias filas. Si selectionBehavior es igual a TableView.SelectColumns, esta propiedad indica si el usuario puede seleccionar una columna cada vez o varias columnas.

Están disponibles los siguientes modos:

Esta propiedad se introdujo en Qt 6.6.

Véase también Selecting items, selectionBehavior, selectionModel, y keyNavigationEnabled.

selectionModel : ItemSelectionModel [since 6.2]

Esta propiedad puede establecerse para controlar qué elementos del delegado deben mostrarse como seleccionados y qué elemento debe mostrarse como actual. Si el delegado tiene definido un required property bool selected, TableView lo mantendrá sincronizado con el estado de selección del elemento del modelo correspondiente en el modelo de selección. Si el delegado tiene un required property bool current definido, TableView lo mantendrá sincronizado con selectionModel.currentIndex.

Esta propiedad se introdujo en Qt 6.2.

Véase también Selecting items, SelectionRectangle, keyNavigationEnabled, y pointerNavigationEnabled.

syncDirection : Qt::Orientations

Si se establece syncView en TableView, esta propiedad controla la sincronización de la(s) dirección(es) de desplazamiento de ambas mesas. El valor predeterminado es Qt.Horizontal | Qt.Vertical, lo que significa que si se mueve una tabla en cualquier dirección, la otra tabla se moverá en la misma dirección.

Esta propiedad y syncView se pueden utilizar para hacer que dos tableViews se sincronicen entre sí suavemente en el aleteo, independientemente de las diferentes animaciones de sobreimpulso/desimpulso, velocidad, aceleración/deceleración o rebote, etc.

Un caso de uso típico es hacer que varias cabeceras parpadeen junto con la tabla.

Véase también syncView.

syncView : TableView

Si esta propiedad de un TableView se establece en otro TableView, ambas tablas se sincronizarán con respecto al desplazamiento, anchura de columnas/altura de filas y espaciado según syncDirection.

Si syncDirection contiene Qt.Horizontal, el ancho de columna, el espaciado de columna y el movimiento horizontal de la tabla actual se sincronizarán con los de syncView.

Si syncDirection contiene Qt.Vertical, la altura de las filas, el espaciado entre filas y el movimiento vertical de la tabla actual se sincronizan con los de syncView.

Véase también syncDirection.

topRow : int

Esta propiedad contiene la fila superior actualmente visible dentro de la vista.

Véase también leftColumn, rightColumn, y bottomRow.

Documentación de la propiedad Attached

TableView.editDelegate : Component

Esta propiedad adjunta contiene el delegado de edición. Es instanciada cuando comienza la edición, y emparentada con el delegado que edita. Soporta las mismas propiedades requeridas que TableView delegate, incluyendo index, row y column. Las propiedades del modelo, como display y edit, también están disponibles (dependiendo de la role names expuesta por el modelo).

La edición comienza cuando se cumplen las acciones especificadas por editTriggers, y la celda actual es editable.

También puede abrir y cerrar manualmente el delegado de edición llamando a edit() y closeEditor(), respectivamente.

La edición finaliza cuando el usuario pulsa Qt::Key_Enter o Qt::Key_Return (y también Qt::Key_Tab o Qt::Key_Backtab, si TableView tiene QQuickItem::activeFocusOnTab configurado). En ese caso, se emitirá la señal TableView::commit, para que el delegado de edición pueda responder escribiendo los datos modificados de nuevo en el modelo. Si la edición finaliza por otros motivos (por ejemplo, si el usuario pulsa Qt::Key_Escape), no se emitirá la señal. En ningún caso se emitirá destruction() al final.

Mientras se esté mostrando el delegado de edición, la celda de debajo seguirá siendo visible, y por lo tanto brillará a través de ella si el delegado de edición es translúcido, o de otro modo no cubre toda la celda. Si no desea que esto ocurra, puede dejar que el elemento raíz de la edición delegada sea un sólido Rectangle, u ocultar algunos de los elementos dentro de TableView delegate.. Esto último puede hacerse definiendo una propiedad required property bool editing dentro de ella, que se vincula a la propiedad visible de algunos de los elementos hijos. El siguiente fragmento muestra cómo hacerlo en un delegado personalizado:

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 50

            required property bool editing

            Text {
                id: textField
                anchors.fill: parent
                anchors.margins: 5
                text: display
                visible: !editing
            }

            TableView.editDelegate: TextField {
                x: textField.x
                y: textField.y
                width: textField.width
                height: textField.height
                text: display
                TableView.onCommit: display = text
            }
        }

Cuando se instancie el delegado de edición, TableView llamará a QQuickItem::forceActiveFocus(). Si quieres que el foco activo se establezca en un elemento hijo del delegado de edición, deja que el delegado de edición sea un FocusScope.

Por defecto, TableViewDelegate proporciona un delegado de edición, y también puedes establecer el tuyo propio:

delegate: TableViewDelegate {
    TableView.editDelegate: TextField {
        width: parent.width
        height: parent.height
        text: display
        TableView.onCommit: display = text
    }
}

Véase también editTriggers, TableView::commit, edit(), closeEditor(), Editing cells, y TableViewDelegate.

TableView.view : TableView

Esta propiedad adjunta contiene la vista que gestiona la instancia del delegado. Se adjunta a cada instancia del delegado.

Documentación sobre señales

[since 6.8] columnMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)

Esta señal se emite cuando se mueve una columna. El índice lógico de la columna se especifica mediante logicalIndex, el índice antiguo mediante oldVisualIndex, y la nueva posición del índice mediante newVisualIndex.

Esta señal se introdujo en Qt 6.8.

[since 6.5] layoutChanged()

Esta señal se emite siempre que el diseño de las filas y columnas de loaded haya cambiado potencialmente. Esto ocurrirá especialmente cuando se llame a forceLayout(), pero también cuando, por ejemplo, se cambie el tamaño de una fila o columna, o cuando una fila o columna haya entrado o salido de la ventana gráfica.

Esta señal puede utilizarse, por ejemplo, para actualizar la geometría de las superposiciones.

Esta señal se introdujo en Qt 6.5.

Véase también forceLayout() y Overlays and underlays.

[since 6.8] rowMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)

Esta señal se emite cuando se mueve una fila. El índice lógico de la fila se especifica mediante logicalIndex, el índice antiguo mediante oldVisualIndex, y la nueva posición del índice mediante newVisualIndex.

Esta señal se introdujo en Qt 6.8.

Documentación de la señal adjunta

commit()

Esta señal es emitida por el edit delegate

Esta señal adjunta se emite cuando el edit delegate está activo, y el usuario pulsa Qt::Key_Enter o Qt::Key_Return. También se emitirá si TableView tiene QQuickItem::activeFocusOnTab configurado, y el usuario pulsa Qt::Key_Tab o Qt::Key_Backtab.

Esta señal no se emitirá si la edición finaliza por motivos distintos a los mencionados. Esto incluye, por ejemplo, si el usuario pulsa Qt::Key_Escape, toca fuera del delegado, la fila o columna que se está editando se borra, o si la aplicación llama a closeEditor().

Al recibir la señal, el delegado de edición debe volver a escribir los datos modificados en el modelo.

Véase también TableView::editDelegate, editTriggers, y Editing cells.

pooled()

Esta señal se emite después de que un elemento se haya añadido a la reserva de reutilización. Se puede utilizar para pausar temporizadores o animaciones en curso dentro del elemento, o para liberar recursos que no se pueden reutilizar.

Esta señal sólo se emite si la propiedad reuseItems es true.

Véase también Reusing items, reuseItems, y reused.

reused()

Esta señal se emite después de que un elemento haya sido reutilizado. En este punto, el elemento ha sido sacado del pool y colocado dentro de la vista de contenido, y las propiedades del modelo como índice, fila y columna han sido actualizadas.

Otras propiedades que no son proporcionadas por el modelo no cambian cuando un elemento es reutilizado. Debes evitar almacenar cualquier estado dentro de un delegado, pero si lo haces, restablece manualmente ese estado al recibir esta señal.

Esta señal se emite cuando se reutiliza un elemento, y no la primera vez que se crea.

Esta señal sólo se emite si la propiedad reuseItems es true.

Véase también Reusing items, reuseItems, y pooled.

Documentación del método

[since 6.4] point cellAtIndex(QModelIndex modelIndex)

Devuelve la celda de la vista que corresponde a modelIndex en el modelo. Función de conveniencia para hacer:

Qt.point(columnAtIndex(modelIndex), rowAtIndex(modelIndex))

Una celda es simplemente un point que combina fila y columna en un solo tipo.

Este método fue introducido en Qt 6.4.

Point cellAtPosition(point position, bool includeSpacing)

Devuelve la celda en el position dado en la tabla. position debe ser relativo al contentItem. Si ninguna celda loaded interseca con position, el valor de retorno será point(-1, -1).

Si includeSpacing se establece en true, se considerará que el cuadro delimitador de una celda incluye la mitad de las celdas adyacentes rowSpacing y columnSpacing a cada lado. El valor por defecto es false.

Véase también columnSpacing y rowSpacing.

Point cellAtPosition(real x, real y, bool includeSpacing)

Comodidad para llamar a cellAtPosition(Qt.point(x, y), includeSpacing).

[since 6.8] void clearColumnReordering()

Restablece cualquier reordenación de columnas aplicada previamente.

Este método se introdujo en Qt 6.8.

void clearColumnWidths()

Borra todos los anchos de columna establecidos con setColumnWidth().

Véase también setColumnWidth(), clearRowHeights(), y Row heights and column widths.

void clearRowHeights()

Borra todas las alturas de fila establecidas con setRowHeight().

Véase también setRowHeight(), clearColumnWidths(), y Row heights and column widths.

[since 6.8] void clearRowReordering()

Restablece cualquier reordenación de filas aplicada previamente.

Este método se introdujo en Qt 6.8.

[since 6.5] void closeEditor()

Si el usuario está editando una celda, al llamar a esta función se detendrá la edición y se destruirá la instancia del delegado de edición.

Este método se introdujo en Qt 6.5.

Ver también edit(), TableView::editDelegate, y Editing cells.

[since 6.4] int columnAtIndex(QModelIndex modelIndex)

Devuelve la columna de la vista que corresponde a modelIndex en el modelo.

Este método se introdujo en Qt 6.4.

Véase también rowAtIndex() y index().

[since 6.2] real columnWidth(int column)

Devuelve la anchura de la columna column. Si la columna no está cargada (y por lo tanto no es visible), el valor devuelto será -1.

Este método se introdujo en Qt 6.2.

Véase también setColumnWidth(), columnWidthProvider, implicitColumnWidth(), isColumnLoaded(), y Row heights and column widths.

[since 6.5] void edit(QModelIndex modelIndex)

Esta función inicia una sesión de edición para la celda que representa modelIndex. Si el usuario ya está editando otra celda, esa sesión finaliza.

Normalmente puede especificar las diferentes formas de iniciar una sesión de edición utilizando editTriggers en su lugar. Si eso no es suficiente, puede utilizar esta función. Para tener un control total sobre la edición de celdas y evitar que TableView interfiera, establezca editTriggers en TableView.NoEditTriggers.

Este método se introdujo en Qt 6.5.

Véase también closeEditor(), editTriggers, TableView::editDelegate, y Editing cells.

real explicitColumnWidth(int column)

Devuelve la anchura de la columna column establecida con setColumnWidth(). Esta anchura puede diferir de la anchura real de la columna, si se está utilizando columnWidthProvider. Para obtener la anchura real de una columna, utilice columnWidth().

Un valor de retorno igual a 0 significa que se ha indicado a la columna que se oculte. Un valor de retorno igual a -1 significa que no se ha establecido una anchura explícita para la columna.

Véase también setColumnWidth(), columnWidth(), y Row heights and column widths.

real explicitRowHeight(int row)

Devuelve la altura de la columna row establecida con setRowHeight(). Esta altura puede diferir de la altura real de la columna, si se está utilizando rowHeightProvider. Para obtener la altura real de una fila, utilice rowHeight().

Un valor de retorno igual a 0 significa que se ha indicado a la fila que se oculte. Un valor de retorno igual a -1 significa que no se ha establecido una altura explícita para la fila.

Véase también setRowHeight(), rowHeight(), y Row heights and column widths.

void forceLayout()

Las respuestas a los cambios en el modelo se procesan por lotes, de modo que sólo se gestionan una vez por fotograma. Esto significa que TableView retrasa la visualización de los cambios mientras se ejecuta un script. Lo mismo ocurre cuando se cambian propiedades, como rowSpacing o leftMargin.

Este método fuerza a TableView a actualizar inmediatamente el diseño para que cualquier cambio reciente tenga efecto.

Al llamar a esta función se reevalúa el tamaño y la posición de cada fila y columna visible. Esto es necesario si las funciones asignadas a rowHeightProvider o columnWidthProvider devuelven valores diferentes a los ya asignados.

[since 6.2] real implicitColumnWidth(int column)

Devuelve la anchura implícita del column dado. Se trata del mayor implicitWidth encontrado entre los elementos delegados actualmente loaded dentro de esa columna.

Si el column no está cargado (y por lo tanto no es visible), el valor devuelto es -1.

Este método se introdujo en Qt 6.2.

Véase también columnWidth(), isRowLoaded(), y Row heights and column widths.

[since 6.2] real implicitRowHeight(int row)

Devuelve la altura implícita del row dado. Se trata de la mayor implicitHeight encontrada entre los elementos delegados actualmente loaded dentro de esa fila.

Si el row no está cargado (y por lo tanto no es visible), el valor devuelto es -1.

Este método se introdujo en Qt 6.2.

Véase también rowHeight(), isColumnLoaded(), y Row heights and column widths.

[since 6.4.3] QModelIndex index(int row, int column)

Devuelve el QModelIndex que corresponde a row y column en la vista.

row y column deben ser la fila y la columna de la vista (fila y columna de la tabla), y no una fila y una columna del modelo. Para TableView, esto es equivalente a llamar a model.index(row, column). Pero para una subclase de TableView, como TreeView, donde el modelo de datos está envuelto dentro de un modelo proxy interno que aplana la estructura de árbol en una tabla, necesitas usar esta función para resolver el índice del modelo.

Este método se introdujo en Qt 6.4.3.

Véase también rowAtIndex() y columnAtIndex().

[since 6.2] bool isColumnLoaded(int column)

Devuelve true si la columna column está cargada.

Una columna está cargada cuando TableView ha cargado los elementos delegados necesarios para mostrar la columna dentro de la vista. Esto también suele significar que la columna es visible para el usuario, pero no siempre.

Esta función puede utilizarse siempre que necesites iterar sobre los elementos delegados de una columna, por ejemplo desde columnWidthProvider, para asegurarte de que los elementos delegados están disponibles para la iteración.

Este método se introdujo en Qt 6.2.

[since 6.2] bool isRowLoaded(int row)

Devuelve true si el row dado está cargado.

Una fila está cargada cuando TableView ha cargado los elementos delegados necesarios para mostrar la fila dentro de la vista. Esto también suele significar que la fila es visible para el usuario, pero no siempre.

Esta función puede utilizarse siempre que sea necesario iterar sobre los elementos delegados de una fila, por ejemplo desde rowHeightProvider, para asegurarse de que los elementos delegados están disponibles para la iteración.

Este método se introdujo en Qt 6.2.

Item itemAtCell(point cell)

Devuelve el elemento delegado en cell si está cargado, en caso contrario null.

[since 6.5] Item itemAtIndex(QModelIndex index)

Devuelve el elemento delegado instanciado para la celda que representa index. Si el elemento no es loaded, el valor será null.

Este método se introdujo en Qt 6.5.

[since 6.4] QModelIndex modelIndex(point cell)

Función de conveniencia para hacer:

index(cell.y, cell.x)

Un cell es simplemente un point que combina fila y columna en un solo tipo.

Este método se introdujo en Qt 6.4.

Véase también index().

[since 6.8] void moveColumn(int source, int destination)

Mueve una columna de la posición source a la posición destination.

Este método se introdujo en Qt 6.8.

[since 6.8] void moveRow(int source, int destination)

Mueve una fila de la posición source a la posición destination.

Este método se introdujo en Qt 6.8.

void positionViewAtCell(point cell, PositionMode mode, point offset, rect subRect)

Posiciones contentX y contentY tales que cell está en la posición especificada por mode. mode puede ser una combinación or-ed de las siguientes:

Si no se especifica una alineación vertical, se ignorará el posicionamiento vertical. Lo mismo ocurre con la alineación horizontal.

Opcionalmente, puede especificar offset para mover contentX y contentY un número extra de píxeles más allá de la alineación objetivo. Por ejemplo, si quieres posicionar la vista para que la celda [10, 10] termine en la esquina superior izquierda con un margen de 5px, podrías hacerlo:

positionViewAtCell(Qt.point(10, 10), TableView.AlignLeft | TableView.AlignTop, Qt.point(-5, -5))

A partir de Qt 6.4, puedes especificar un subRect para posicionar en un rectángulo dentro del cell, en lugar de en el rectángulo delimitador de toda la celda. Esto puede ser útil si la celda es, por ejemplo, más grande que la vista, y quieres asegurarte de que una parte específica de ella es visible. La dirección subRect debe ser valid para que se tenga en cuenta.

Los métodos sólo deben ser llamados después de que el Componente se haya completado. Para posicionar la vista al inicio, este método debe ser llamado por Component.onCompleted. Por ejemplo, para posicionar la vista al final:

Component.onCompleted: positionViewAtCell(Qt.point(columns - 1, rows - 1), TableView.AlignRight | TableView.AlignBottom)

Véase también animate.

void positionViewAtColumn(int column, PositionMode mode, real offset, rect subRect)

Posiciona contentX de tal forma que column se encuentra en la posición especificada por mode, offset y subRect.

Método práctico para llamar a

positionViewAtCell(Qt.point(column, 0), mode & Qt.AlignHorizontal_Mask, offset, subRect)

[since 6.5] void positionViewAtIndex(QModelIndex index, PositionMode mode, point offset, rect subRect)

Posiciona la vista de forma que index se encuentre en la posición especificada por mode, offset y subRect.

Método de conveniencia para llamar a

positionViewAtRow(rowAtIndex(index), mode & Qt.AlignVertical_Mask, offset.y, subRect)
positionViewAtColumn(columnAtIndex(index), mode & Qt.AlignVertical_Mask, offset.x, subRect)

Este método se introdujo en Qt 6.5.

void positionViewAtRow(int row, PositionMode mode, real offset, rect subRect)

Posiciona contentY de tal manera que row se encuentra en la posición especificada por mode, offset y subRect.

Método práctico para llamar a

positionViewAtCell(Qt.point(0, row), mode & Qt.AlignVertical_Mask, offset, subRect)

[since 6.4] int rowAtIndex(QModelIndex modelIndex)

Devuelve la fila de la vista que corresponde a modelIndex en el modelo.

Este método se introdujo en Qt 6.4.

Véase también columnAtIndex() y index().

[since 6.2] real rowHeight(int row)

Devuelve la altura de la fila dada row. Si la fila no está cargada (y por lo tanto no es visible), el valor devuelto será -1.

Este método se introdujo en Qt 6.2.

Véase también setRowHeight(), rowHeightProvider, implicitRowHeight(), isRowLoaded(), y Row heights and column widths.

void setColumnWidth(int column, real size)

Establece el ancho de columna explícito de la columna column en size.

Si desea volver a leer los valores establecidos con esta función, debe utilizar explicitColumnWidth(). columnWidth() devolverá el tamaño real de la columna, que puede ser diferente si se establece columnWidthProvider.

Cuando TableView necesite resolver la anchura de column, primero intentará llamar a columnWidthProvider. Sólo si no se establece un proveedor, se utilizarán por defecto las anchuras establecidas con esta función. No obstante, puede llamar a explicitColumnWidth() desde el proveedor y, si es necesario, moderar los valores para que, por ejemplo, estén siempre dentro de un intervalo determinado. El siguiente fragmento muestra un ejemplo de cómo hacerlo:

columnWidthProvider: function(column) {
    let w = explicitColumnWidth(column)
    if (w >= 0)
        return Math.max(100, w);
    return implicitColumnWidth(column)
}

Si size es igual a 0, la columna se ocultará. Si size es igual a -1, la columna volverá a utilizar implicitColumnWidth(). Se le permite especificar tamaños de columna para columnas que están fuera del tamaño del modelo.

Véase también columnWidth(), explicitColumnWidth(), setRowHeight(), clearColumnWidths(), y Row heights and column widths.

void setRowHeight(int row, real size)

Establece la altura explícita de la fila row en size.

Si desea volver a leer los valores establecidos con esta función, debe utilizar explicitRowHeight(). rowHeight() devolverá la altura real de la fila, que puede ser diferente si se establece un rowHeightProvider.

Cuando TableView necesite resolver la altura de row, primero intentará llamar a rowHeightProvider. Sólo si no se establece un proveedor, se utilizarán por defecto las alturas establecidas con esta función. Sin embargo, se puede llamar a explicitRowHeight() desde el proveedor y, si es necesario, moderar los valores para que, por ejemplo, estén siempre dentro de un intervalo determinado. El siguiente fragmento muestra un ejemplo de cómo hacerlo:

rowHeightProvider: function(row) {
    let h = explicitRowHeight(row)
    if (h >= 0)
        return Math.max(100, h);
    return implicitRowHeight(row)
}

Si size es igual a 0, la fila se ocultará. Si size es igual a -1, la fila volverá a utilizar implicitRowHeight(). Se le permite especificar tamaños de fila para filas que están fuera del tamaño del modelo.

Véase también rowHeight(), explicitRowHeight(), setColumnWidth(), y Row heights and column widths.