QAbstractItemModel Class

Documentación de las funciones miembro

[explicit] QAbstractItemModel::QAbstractItemModel(QObject *parent = nullptr)

Construye un modelo abstracto de artículo con la dirección parent.

[virtual noexcept] QAbstractItemModel::~QAbstractItemModel()

Destruye el modelo abstracto de artículo.

[protected] void QAbstractItemModel::beginInsertColumns(const QModelIndex &parent, int first, int last)

Inicia una operación de inserción de columnas.

Al reimplementar insertColumns() en una subclase, debes llamar a esta función antes de insertar datos en el almacén de datos subyacente del modelo.

El índice parent corresponde al padre en el que se insertan las nuevas columnas; first y last son los números de columna que tendrán las nuevas columnas una vez insertadas.

Inserción de columnas	Especifique el primer y el último número de columna del tramo de columnas que desea insertar en un elemento de un modelo. Por ejemplo, como se muestra en el diagrama, insertamos tres columnas antes de la columna 4, por lo que first es 4 y last es 6: beginInsertColumns(parent, 4, 6); Esto inserta las tres nuevas columnas como columnas 4, 5 y 6.
Añadir columnas	Para añadir columnas, insértelas después de la última columna. Por ejemplo, como se muestra en el diagrama, añadimos tres columnas a una colección de seis columnas existentes (que terminan en la columna 5), por lo que first es 6 y last es 8: beginInsertColumns(parent, 6, 8); Esto añade las dos nuevas columnas como columnas 6, 7 y 8.

Véase también endInsertColumns().

[protected] void QAbstractItemModel::beginInsertRows(const QModelIndex &parent, int first, int last)

Inicia una operación de inserción de filas.

Al reimplementar insertRows() en una subclase, debes llamar a esta función antes de insertar datos en el almacén de datos subyacente del modelo.

El índice parent corresponde al padre en el que se insertan las nuevas filas; first y last son los números de fila que tendrán las nuevas filas una vez insertadas.

Inserción de filas	Especifique el primer y el último número de fila del intervalo de filas que desea insertar en un elemento de un modelo. Por ejemplo, como se muestra en el diagrama, insertamos tres filas antes de la fila 2, por lo que first es 2 y last es 4: beginInsertRows(parent, 2, 4); Esto inserta las tres nuevas filas como filas 2, 3 y 4.
Añadir filas	Para añadir filas, insértelas después de la última fila. Por ejemplo, como se muestra en el diagrama, añadimos dos filas a una colección de 4 filas existentes (que terminan en la fila 3), por lo que first es 4 y last es 5: beginInsertRows(parent, 4, 5); Esto añade las dos nuevas filas como filas 4 y 5.

Véase también endInsertRows().

[protected] bool QAbstractItemModel::beginMoveColumns(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)

Inicia una operación de movimiento de columna.

Al reimplementar una subclase, este método simplifica el movimiento de entidades en el modelo. Este método es responsable de mover índices persistentes en el modelo, lo que de otra forma tendrías que hacer tú mismo. Utilizar beginMoveColumns y endMoveColumns es una alternativa a emitir layoutAboutToBeChanged y layoutChanged directamente junto con changePersistentIndex.

El índice sourceParent corresponde al padre desde el que se mueven las columnas; sourceFirst y sourceLast son el primer y último número de columna de las columnas que se van a mover. El índice destinationParent corresponde al padre al que se mueven esas columnas. El destinationChild es la columna a la que se moverán las columnas. Es decir, el índice de la columna sourceFirst en sourceParent se convertirá en la columna destinationChild en destinationParent, seguida de todas las demás columnas hasta sourceLast.

Sin embargo, al mover columnas hacia abajo en el mismo padre (sourceParent y destinationParent son iguales), las columnas se colocarán antes del índice destinationChild. Es decir, si desea mover las columnas 0 y 1 para que se conviertan en las columnas 1 y 2, destinationChild deberá ser 3. En este caso, el nuevo índice para la columna de origen i (que está entre sourceFirst y sourceLast) es igual a (destinationChild-sourceLast-1+i).

Tenga en cuenta que si sourceParent y destinationParent son iguales, debe asegurarse de que destinationChild no está dentro del rango de sourceFirst y sourceLast + 1. También debe asegurarse de que no intenta mover una columna a uno de sus propios hijos o ancestros. Este método devuelve false si cualquiera de las dos condiciones es cierta, en cuyo caso deberá abortar la operación de desplazamiento.

Véase también endMoveColumns().

[protected] bool QAbstractItemModel::beginMoveRows(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)

Inicia una operación de movimiento de filas.

Al reimplementar una subclase, este método simplifica el movimiento de entidades en el modelo. Este método es responsable de mover los índices persistentes en el modelo, lo que de otra forma tendrías que hacer tú mismo. Utilizar beginMoveRows y endMoveRows es una alternativa a emitir layoutAboutToBeChanged y layoutChanged directamente junto con changePersistentIndex.

El índice sourceParent corresponde al padre desde el que se mueven las filas; sourceFirst y sourceLast son el primer y último número de fila de las filas que se van a mover. El índice destinationParent corresponde al padre al que se mueven esas filas. El destinationChild es la fila a la que se moverán las filas. Es decir, el índice de la fila sourceFirst en sourceParent se convertirá en la fila destinationChild en destinationParent, seguida de todas las demás filas hasta sourceLast.

Sin embargo, al mover filas hacia abajo en el mismo padre (sourceParent y destinationParent son iguales), las filas se colocarán antes del índice destinationChild. Es decir, si desea mover las filas 0 y 1 para que se conviertan en las filas 1 y 2, destinationChild deberá ser 3. En este caso, el nuevo índice para la fila de origen i (que está entre sourceFirst y sourceLast) es igual a (destinationChild-sourceLast-1+i).

Tenga en cuenta que si sourceParent y destinationParent son iguales, debe asegurarse de que destinationChild no está dentro del rango de sourceFirst y sourceLast + 1. También debe asegurarse de que no intenta mover una fila a uno de sus propios hijos o antepasados. Este método devuelve false si alguna de las dos condiciones es cierta, en cuyo caso deberá abortar la operación de movimiento.

Mover filas a otro padre	Especifique los números de la primera y la última fila del tramo de filas del padre de origen que desea mover en el modelo. Especifique también la fila del padre de destino a la que desea mover el tramo. Por ejemplo, como se muestra en el diagrama, movemos tres filas de la fila 2 a la 4 en el origen, por lo que sourceFirst es 2 y sourceLast es 4. Movemos esos elementos por encima de la fila 2 en el destino, por lo que destinationChild es 2. beginMoveRows(sourceParent, 2, 4, destinationParent, 2); Esto desplaza las tres filas 2, 3 y 4 en el origen para convertirse en 2, 3 y 4 en el destino. Los demás hermanos afectados se desplazan en consecuencia.
Mover filas para añadirlas a otro padre	Para añadir filas a otro padre, muévalas después de la última fila. Por ejemplo, como se muestra en el diagrama, movemos tres filas a una colección de 6 filas existentes (que terminan en la fila 5), por lo que destinationChild es 6: beginMoveRows(sourceParent, 2, 4, destinationParent, 6); Esto mueve las filas de destino al final del padre de destino como 6, 7 y 8.
Mover filas en el mismo padre hacia arriba	Para mover filas dentro del mismo padre, especifique la fila a la que desea moverlas. Por ejemplo, como se muestra en el diagrama, movemos un elemento de la fila 2 a la fila 0, por lo que sourceFirst y sourceLast son 2 y destinationChild es 0. beginMoveRows(parent, 2, 2, parent, 0); Tenga en cuenta que otras filas pueden desplazarse en consecuencia. Observe también que al mover elementos dentro del mismo padre no debe intentar movimientos inválidos o no-op. En el ejemplo anterior, el elemento 2 está en la fila 2 antes del movimiento, por lo que no se puede mover a la fila 2 (donde ya está) o a la fila 3 (no-op ya que fila 3 significa por encima de la fila 3, donde ya está).
Mover filas del mismo padre hacia abajo	Para mover filas dentro del mismo padre, especifique la fila a la que desea moverlas. Por ejemplo, como se muestra en el diagrama, movemos un elemento de la fila 2 a la fila 4, por lo que sourceFirst y sourceLast son 2 y destinationChild es 4. beginMoveRows(parent, 2, 2, parent, 4); Tenga en cuenta que otras filas pueden desplazarse en consecuencia.

Véase también endMoveRows().

[protected] void QAbstractItemModel::beginRemoveColumns(const QModelIndex &parent, int first, int last)

Inicia una operación de eliminación de columnas.

Al reimplementar removeColumns() en una subclase, debes llamar a esta función antes de eliminar datos del almacén de datos subyacente del modelo.

El índice parent corresponde al padre del que se eliminan las nuevas columnas; first y last son los números de columna de la primera y la última columna que se eliminan.

Eliminación de columnas

Especifique el número de la primera y la última columna del intervalo de columnas que desea eliminar de un elemento de un modelo. Por ejemplo, como se muestra en el diagrama, eliminamos las tres columnas de la columna 4 a la columna 6, por lo que first es 4 y last es 6: beginRemoveColumns(parent, 4, 6);

Véase también endRemoveColumns().

[protected] void QAbstractItemModel::beginRemoveRows(const QModelIndex &parent, int first, int last)

Inicia una operación de eliminación de filas.

Al reimplementar removeRows() en una subclase, debes llamar a esta función antes de eliminar datos del almacén de datos subyacente del modelo.

El índice parent corresponde al padre del que se eliminan las nuevas filas; first y last son los números de fila de las filas que se van a eliminar.

Eliminación de filas

Especifique el primer y el último número de fila del intervalo de filas que desea eliminar de un elemento de un modelo. Por ejemplo, como se muestra en el diagrama, eliminamos las dos filas de la fila 2 a la fila 3, por lo que first es 2 y last es 3: beginRemoveRows(parent, 2, 3);

Véase también endRemoveRows().

[protected] void QAbstractItemModel::beginResetModel()

Inicia una operación de restablecimiento del modelo.

Una operación de reinicio restablece el modelo a su estado actual en cualquier vista adjunta.

Cuando se restablece un modelo, los datos anteriores del modelo no son válidos y deben volver a consultarse. Esto también significa que el elemento actual y los elementos seleccionados dejarán de ser válidos.

Cuando un modelo cambia radicalmente sus datos, a veces puede ser más fácil simplemente llamar a esta función en lugar de emitir dataChanged() para informar a otros componentes cuando la fuente de datos subyacente, o su estructura, ha cambiado.

Debes llamar a esta función antes de reiniciar cualquier estructura de datos interna en tu modelo o modelo proxy.

Esta función emite la señal modelAboutToBeReset().

Véase también modelAboutToBeReset(), modelReset() y endResetModel().

[virtual] QModelIndex QAbstractItemModel::buddy(const QModelIndex &index) const

Devuelve un índice del modelo para el compañero del elemento representado por index. Cuando el usuario quiera editar un elemento, la vista llamará a esta función para comprobar si otro elemento del modelo debe ser editado en su lugar. A continuación, la vista construirá un delegado utilizando el índice del modelo devuelto por el elemento amigo.

La implementación por defecto de esta función tiene cada elemento como su propio amigo.

[virtual] bool QAbstractItemModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const

Devuelve true si un modelo puede aceptar una caída de data. Esta implementación por defecto sólo comprueba si data tiene al menos un formato en la lista de mimeTypes() y si action está entre los supportedDropActions() del modelo.

Reimplemente esta función en su modelo personalizado, si desea comprobar si el data se puede soltar en row, column, parent con action. Si no necesita esa comprobación, no es necesario reimplementar esta función.

Ver también dropMimeData() y Usar arrastrar y soltar con vistas de elementos.

[virtual invokable] bool QAbstractItemModel::canFetchMore(const QModelIndex &parent) const

Devuelve true si hay más datos disponibles para parent; en caso contrario devuelve false.

La implementación por defecto siempre devuelve false.

Si canFetchMore() devuelve true, se debe llamar a la función fetchMore() . Este es el comportamiento de QAbstractItemView, por ejemplo.

Véase también fetchMore().

[protected] void QAbstractItemModel::changePersistentIndex(const QModelIndex &from, const QModelIndex &to)

Cambia el QPersistentModelIndex que es igual al índice del modelo from dado al índice del modelo to dado.

Si no se encuentra ningún índice de modelo persistente igual al índice de modelo from dado, no se cambia nada.

Véase también persistentIndexList() y changePersistentIndexList().

[protected] void QAbstractItemModel::changePersistentIndexList(const QModelIndexList &from, const QModelIndexList &to)

Cambia los {QPersistentModelIndex}es que son iguales a los índices de la lista de índices del modelo from dada a la lista de índices del modelo to dada.

Si no se encuentran índices de modelos persistentes iguales a los índices de la lista de índices de modelos from dada, no se cambia nada.

Véase también persistentIndexList() y changePersistentIndex().

bool QAbstractItemModel::checkIndex(const QModelIndex &index, QAbstractItemModel::CheckIndexOptions options = CheckIndexOption::NoOption) const

Esta función comprueba si index es un índice de modelo legal para este modelo. Un índice de modelo legal es un índice de modelo inválido, o un índice de modelo válido para el que se cumple todo lo siguiente:

• el modelo del índice es this;
• la fila del índice es mayor o igual que cero;
• la fila del índice es menor que el número de filas del índice padre;
• la columna "índice" es mayor o igual que cero
• la columna del índice es menor que el número de columnas del índice padre.

El argumento options puede cambiar algunas de estas comprobaciones. Si options contiene IndexIsValid, entonces index debe ser un índice válido; esto es útil cuando se reimplementan funciones como data() o setData(), que esperan índices válidos.

Si options contiene DoNotUseParent, se omiten las comprobaciones que llamarían a parent(); esto permite llamar a esta función desde una reimplementación de parent() (de lo contrario, se produciría una recursión interminable y un fallo).

Si options no contiene DoNotUseParent, y contiene ParentIsInvalid, se realiza una comprobación adicional: se comprueba que el índice padre no sea válido. Esto es útil cuando se implementan modelos planos como listas o tablas, donde ningún índice del modelo debe tener un índice padre válido.

Esta función devuelve true si todas las comprobaciones se han realizado correctamente, y false en caso contrario. Esto permite utilizar la función en Q_ASSERT y otros mecanismos de depuración similares. Si falla alguna comprobación, se imprimirá un mensaje de advertencia en la categoría de registro qt.core.qabstractitemmodel.checkindex, que contendrá alguna información que puede ser útil para depurar el fallo.

Véase también QModelIndex.

[virtual, since 6.0] bool QAbstractItemModel::clearItemData(const QModelIndex &index)

Elimina los datos almacenados en todos los roles para el index dado . Devuelve true si se ha realizado correctamente; en caso contrario, devuelve false. Se emitirá la señal dataChanged() si los datos se han eliminado correctamente. La implementación de la clase base devuelve false

Esta función se introdujo en Qt 6.0.

Véase también data(), itemData(), setData(), y setItemData().

[pure virtual invokable] int QAbstractItemModel::columnCount(const QModelIndex &parent = QModelIndex()) const

Devuelve el número de columnas de los hijos de parent.

En la mayoría de las subclases, el número de columnas es independiente de parent.

Por ejemplo:

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

Véase también rowCount().

[private signal] void QAbstractItemModel::columnsAboutToBeInserted(const QModelIndex &parent, int first, int last)

Esta señal se emite justo antes de que se inserten columnas en el modelo. Los nuevos elementos se colocarán entre first y last inclusive, debajo del elemento parent dado.

Véase también insertColumns() y beginInsertColumns().

[private signal] void QAbstractItemModel::columnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)

Esta señal se emite justo antes de que las columnas se muevan dentro del modelo. Los elementos que se moverán son los comprendidos entre sourceStart y sourceEnd inclusive, bajo el elemento sourceParent dado. Se moverán a destinationParent a partir de la columna destinationColumn.

Nota: Los componentes conectados a esta señal la utilizan para adaptarse a los cambios en las dimensiones del modelo. Sólo puede ser emitida por la implementación de QAbstractItemModel, y no puede ser emitida explícitamente en código de subclase.

Véase también beginMoveRows().

[private signal] void QAbstractItemModel::columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last)

Esta señal se emite justo antes de eliminar columnas del modelo. Los elementos a eliminar son los comprendidos entre first y last, ambos inclusive, bajo el elemento parent dado.

Véase también removeColumns() y beginRemoveColumns().

[private signal] void QAbstractItemModel::columnsInserted(const QModelIndex &parent, int first, int last)

Esta señal se emite después de que se hayan insertado columnas en el modelo. Los nuevos elementos son los comprendidos entre first y last inclusive, bajo el elemento parent dado.

Véase también insertColumns() y beginInsertColumns().

[private signal] void QAbstractItemModel::columnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)

Esta señal se emite después de que las columnas se hayan movido dentro del modelo. Los elementos entre sourceStart y sourceEnd inclusive, bajo el elemento sourceParent dado se han movido a destinationParent comenzando en la columna destinationColumn.

Nota: Los componentes conectados a esta señal la utilizan para adaptarse a los cambios en las dimensiones del modelo. Sólo puede ser emitida por la implementación de QAbstractItemModel, y no puede ser emitida explícitamente en código de subclase.

Véase también beginMoveRows().

[private signal] void QAbstractItemModel::columnsRemoved(const QModelIndex &parent, int first, int last)

Esta señal se emite después de eliminar columnas del modelo. Los elementos eliminados son los comprendidos entre first y last, ambos inclusive, bajo el elemento parent dado.

Véase también removeColumns() y beginRemoveColumns().

[protected] QModelIndex QAbstractItemModel::createIndex(int row, int column, const void *ptr = nullptr) const

Crea un índice de modelo para los datos row y column con el puntero interno ptr.

Cuando se utiliza un QSortFilterProxyModel, sus índices tienen su propio puntero interno. No es aconsejable acceder a este puntero interno fuera del modelo. Utilice en su lugar la función data().

Esta función proporciona una interfaz coherente que las subclases del modelo deben utilizar para crear índices del modelo.

[protected] QModelIndex QAbstractItemModel::createIndex(int row, int column, quintptr id) const

Crea un índice de modelo para los datos row y column con el identificador interno id.

Esta función proporciona una interfaz coherente que las subclases del modelo deben utilizar para crear índices del modelo.

Véase también QModelIndex::internalId().

[pure virtual invokable] QVariant QAbstractItemModel::data(const QModelIndex &index, int role = Qt::DisplayRole) const

Devuelve los datos almacenados en el role dado para el elemento al que hace referencia el index.

Véase también Qt::ItemDataRole, setData(), y headerData().

[signal] void QAbstractItemModel::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList<int> &roles = QList<int>())

Esta señal se emite cada vez que cambian los datos de un elemento existente.

Si los elementos son del mismo padre, los afectados son los comprendidos entre topLeft y bottomRight, ambos inclusive. Si los elementos no tienen el mismo padre, el comportamiento es indefinido.

Al reimplementar la función setData(), esta señal debe emitirse explícitamente.

El argumento opcional roles puede utilizarse para especificar qué roles de datos se han modificado realmente. Un vector vacío en el argumento roles significa que todos los roles deben considerarse modificados. El orden de los elementos en el argumento roles no tiene ninguna relevancia.

Véase también headerDataChanged(), setData() y layoutChanged().

[virtual] bool QAbstractItemModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)

Maneja el data suministrado por una operación de arrastrar y soltar que terminó con el action dado.

Devuelve true si los datos y la acción fueron manejados por el modelo; en caso contrario devuelve false.

Los campos row, column y parent indican la ubicación de un elemento en el modelo donde finalizó la operación. Es responsabilidad del modelo completar la acción en la ubicación correcta.

Por ejemplo, una acción de soltar un elemento en QTreeView puede dar lugar a que se inserten nuevos elementos como hijos del elemento especificado por row, column, y parent, o como hermanos del elemento.

Cuando row y column son -1 significa que los datos eliminados deben considerarse como eliminados directamente en parent. Normalmente, esto significará añadir los datos como elementos hijos de parent. Si row y column son mayores o iguales que cero, significa que la baja se produjo justo antes de row y column en parent.

Se llama al miembro mimeTypes() para obtener la lista de tipos MIME aceptables. Esta implementación por defecto asume la implementación por defecto de mimeTypes(), que devuelve un único tipo MIME por defecto. Si reimplementa mimeTypes() en su modelo personalizado para devolver varios tipos MIME, deberá reimplementar esta función para poder utilizarlos.

Consulte también supportedDropActions(), canDropMimeData() y Uso de la función de arrastrar y soltar con las vistas de elementos.

[protected] void QAbstractItemModel::endInsertColumns()

Finaliza una operación de inserción de columnas.

Al reimplementar insertColumns() en una subclase, debe llamar a esta función después de insertar datos en el almacén de datos subyacente del modelo.

Véase también beginInsertColumns().

[protected] void QAbstractItemModel::endInsertRows()

Finaliza una operación de inserción de filas.

Al reimplementar insertRows() en una subclase, debe llamar a esta función después de insertar datos en el almacén de datos subyacente del modelo.

Véase también beginInsertRows().

[protected] void QAbstractItemModel::endMoveColumns()

Finaliza una operación de movimiento de columna.

Al implementar una subclase, debes llamar a esta función después de mover datos dentro del almacén de datos subyacente del modelo.

Véase también beginMoveColumns().

[protected] void QAbstractItemModel::endMoveRows()

Finaliza una operación de movimiento de filas.

Al implementar una subclase, debes llamar a esta función después de mover datos dentro del almacén de datos subyacente del modelo.

Véase también beginMoveRows().

[protected] void QAbstractItemModel::endRemoveColumns()

Finaliza una operación de eliminación de columnas.

Al reimplementar removeColumns() en una subclase, debes llamar a esta función después de eliminar datos del almacén de datos subyacente del modelo.

Véase también beginRemoveColumns().

[protected] void QAbstractItemModel::endRemoveRows()

Finaliza una operación de eliminación de filas.

Al reimplementar removeRows() en una subclase, debe llamar a esta función después de eliminar datos del almacén de datos subyacente del modelo.

Véase también beginRemoveRows().

[protected] void QAbstractItemModel::endResetModel()

Completa una operación de restablecimiento del modelo.

Debe llamar a esta función después de restablecer cualquier estructura de datos interna en su modelo o modelo proxy.

Esta función emite la señal modelReset().

Véase también beginResetModel().

[virtual invokable] void QAbstractItemModel::fetchMore(const QModelIndex &parent)

Obtiene todos los datos disponibles para los elementos con el padre especificado por el índice parent.

Reimplemente esta opción si está rellenando su modelo de forma incremental.

La implementación por defecto no hace nada.

Véase también canFetchMore().

[virtual invokable] Qt::ItemFlags QAbstractItemModel::flags(const QModelIndex &index) const

Devuelve las banderas de elemento para el index dado .

La implementación de la clase base devuelve una combinación de banderas que habilita el elemento (ItemIsEnabled) y permite seleccionarlo (ItemIsSelectable).

Véase también Qt::ItemFlags.

[virtual invokable] bool QAbstractItemModel::hasChildren(const QModelIndex &parent = QModelIndex()) const

Devuelve true si parent tiene algún hijo; en caso contrario devuelve false.

Utilice rowCount() en el padre para averiguar el número de hijos.

Tenga en cuenta que es un comportamiento indefinido informar de que un índice concreto tieneHijos con este método si el mismo índice tiene el indicador Qt::ItemNeverHasChildren activado.

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

[invokable] bool QAbstractItemModel::hasIndex(int row, int column, const QModelIndex &parent = QModelIndex()) const

Devuelve true si el modelo devuelve un QModelIndex válido para row y column con parent, en caso contrario devuelve false.

[virtual invokable] QVariant QAbstractItemModel::headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const

Devuelve los datos de role y section en la cabecera con orientation.

En las cabeceras horizontales, el número de sección corresponde al número de columna. Del mismo modo, para las cabeceras verticales, el número de sección corresponde al número de fila.

Véase también Qt::ItemDataRole, setHeaderData(), y QHeaderView.

[signal] void QAbstractItemModel::headerDataChanged(Qt::Orientation orientation, int first, int last)

Esta señal se emite cada vez que se modifica una cabecera. El orientation indica si la cabecera horizontal o vertical ha cambiado. Es necesario actualizar las secciones de la cabecera desde first hasta last.

Al reimplementar la función setHeaderData(), esta señal debe emitirse explícitamente.

Si está cambiando el número de columnas o filas no necesita emitir esta señal, sino utilizar las funciones begin/end (consulte la sección sobre subclases en la descripción de la clase QAbstractItemModel para más detalles).

Véase también headerData(), setHeaderData(), y dataChanged().

[pure virtual invokable] QModelIndex QAbstractItemModel::index(int row, int column, const QModelIndex &parent = QModelIndex()) const

Devuelve el índice del elemento en el modelo especificado por el índice dado row, column y parent.

Cuando reimplemente esta función en una subclase, llame a createIndex() para generar índices de modelo que otros componentes puedan utilizar para referirse a elementos de su modelo.

Véase también createIndex().

[invokable] bool QAbstractItemModel::insertColumn(int column, const QModelIndex &parent = QModelIndex())

Inserta una sola columna antes del column dado en los elementos hijos del parent especificado.

Devuelve true si se inserta la columna; en caso contrario devuelve false.

Véase también insertColumns(), insertRow() y removeColumn().

[virtual invokable] bool QAbstractItemModel::insertColumns(int column, int count, const QModelIndex &parent = QModelIndex())

En los modelos que lo admiten, inserta count nuevas columnas en el modelo antes de la dada column. Los elementos de cada nueva columna serán hijos del elemento representado por el índice del modelo parent.

Si column es 0, las columnas se añaden a cualquier columna existente.

Si column es columnCount(), las columnas se añaden a cualquier columna existente.

Si parent no tiene hijos, se inserta una única fila con las columnas de count.

Devuelve true si las columnas se han insertado correctamente; en caso contrario devuelve false.

La implementación de la clase base no hace nada y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar inserciones. Alternativamente, puede proporcionar su propia API para alterar los datos.

Véase también insertRows(), removeColumns(), beginInsertColumns() y endInsertColumns().

[invokable] bool QAbstractItemModel::insertRow(int row, const QModelIndex &parent = QModelIndex())

Inserta una única fila antes del row dado en los elementos hijos del parent especificado.

Devuelve true si se inserta la fila; en caso contrario devuelve false.

Véase también insertRows(), insertColumn() y removeRow().

[virtual invokable] bool QAbstractItemModel::insertRows(int row, int count, const QModelIndex &parent = QModelIndex())

En los modelos que lo soportan, inserta count filas en el modelo antes de la dada row. Los elementos de la nueva fila serán hijos del elemento representado por el índice del modelo parent.

Si row es 0, las filas se añaden a cualquier fila existente en el modelo padre.

Si row es rowCount(), las filas se añaden a cualquier fila existente en el padre.

Si parent no tiene hijos, se inserta una única columna con las filas de count.

Devuelve true si las filas se han insertado correctamente; en caso contrario, devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar inserciones. Alternativamente, puede proporcionar su propia API para alterar los datos. En cualquier caso, necesitará llamar a beginInsertRows() y endInsertRows() para notificar a otros componentes que el modelo ha cambiado.

Véase también insertColumns(), removeRows(), beginInsertRows() y endInsertRows().

[virtual] QMap<int, QVariant> QAbstractItemModel::itemData(const QModelIndex &index) const

Devuelve un mapa con los valores de todos los roles predefinidos en el modelo para el elemento en la dirección index.

Reimplemente esta función si desea ampliar el comportamiento predeterminado de esta función para incluir roles personalizados en el mapa.

Véase también setItemData(), Qt::ItemDataRole, y data().

[signal] void QAbstractItemModel::layoutAboutToBeChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)

Esta señal se emite justo antes de que se modifique la disposición de un modelo. Los componentes conectados a esta señal la utilizan para adaptarse a los cambios en la disposición del modelo.

Las subclases deben actualizar cualquier índice persistente del modelo después de emitir layoutAboutToBeChanged().

El parámetro opcional parents se utiliza para dar una notificación más específica sobre qué partes de la disposición del modelo están cambiando. Una lista vacía indica un cambio en la disposición de todo el modelo. El orden de los elementos en la lista parents no es significativo. El parámetro opcional hint se utiliza para dar una pista sobre lo que está sucediendo mientras el modelo se relanza.

Véase también layoutChanged() y changePersistentIndex().

[signal] void QAbstractItemModel::layoutChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)

Esta señal se emite siempre que la disposición de los elementos expuestos por el modelo ha cambiado; por ejemplo, cuando el modelo ha sido ordenado. Cuando una vista recibe esta señal, debe actualizar la disposición de los elementos para reflejar este cambio.

Cuando subclase QAbstractItemModel o QAbstractProxyModel, asegúrese de que emite layoutAboutToBeChanged() antes de cambiar el orden de los elementos o alterar la estructura de los datos que expone a las vistas, y emita layoutChanged() después de cambiar la disposición.

El parámetro opcional parents se utiliza para dar una notificación más específica sobre qué partes de la disposición del modelo están cambiando. Una lista vacía indica un cambio en el diseño de todo el modelo. El orden de los elementos en la lista parents no es significativo. El parámetro opcional hint se utiliza para dar una pista sobre lo que está ocurriendo mientras se retransmite el modelo.

Las subclases deben actualizar cualquier índice persistente del modelo antes de emitir layoutChanged(). En otras palabras, cuando cambie la estructura:

• emite layoutAboutToBeChanged
• Recuerde el QModelIndex que va a cambiar
• Actualiza los datos internos
• Llama a changePersistentIndex()
• emit layoutChanged

Ver también layoutAboutToBeChanged(), dataChanged(), headerDataChanged(), modelReset(), y changePersistentIndex().

[virtual invokable] QModelIndexList QAbstractItemModel::match(const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap)) const

Devuelve una lista de índices para los elementos de la columna del índice start en los que los datos almacenados en el role dado coinciden con el value especificado. La forma en que se realiza la búsqueda viene definida por el flags dado. La lista devuelta puede estar vacía. Tenga en cuenta también que el orden de los resultados en la lista puede no corresponder al orden en el modelo, si por ejemplo se utiliza un modelo proxy. No se puede confiar en el orden de los resultados.

La búsqueda comienza a partir del índice start, y continúa hasta que el número de elementos de datos coincidentes es igual a hits, la búsqueda alcanza la última fila, o la búsqueda alcanza start de nuevo - dependiendo de si MatchWrap se especifica en flags. Si desea buscar todos los elementos coincidentes, utilice hits = -1.

Por defecto, esta función realizará una comparación envolvente basada en cadenas en todos los elementos, buscando los elementos que empiecen por el término de búsqueda especificado en value.

[virtual] QMimeData *QAbstractItemModel::mimeData(const QModelIndexList &indexes) const

Devuelve un objeto que contiene elementos de datos serializados correspondientes a la lista de indexes especificada. El formato utilizado para describir los datos codificados se obtiene de la función mimeTypes(). Esta implementación por defecto utiliza el tipo MIME por defecto devuelto por la implementación por defecto de mimeTypes(). Si reimplementa mimeTypes() en su modelo personalizado para devolver más tipos MIME, reimplemente esta función para hacer uso de ellos.

Si la lista de indexes está vacía, o no hay tipos MIME soportados, se devuelve nullptr en lugar de una lista vacía serializada.

Véase también mimeTypes() y dropMimeData().

[virtual] QStringList QAbstractItemModel::mimeTypes() const

Devuelve la lista de tipos MIME permitidos. Por defecto, los modelos y vistas incorporados utilizan un tipo MIME interno: application/x-qabstractitemmodeldatalist.

Cuando implemente el soporte de arrastrar y soltar en un modelo personalizado, si va a devolver datos en formatos distintos del tipo MIME interno predeterminado, reimplemente esta función para devolver su lista de tipos MIME.

Si reimplementa esta función en su modelo personalizado, también debe reimplementar las funciones miembro que la llaman: mimeData() y dropMimeData().

Véase también mimeData() y dropMimeData().

[private signal] void QAbstractItemModel::modelAboutToBeReset()

Esta señal se emite cuando se llama a beginResetModel(), antes de que se haya invalidado el estado interno del modelo (por ejemplo, los índices persistentes del modelo).

Véase también beginResetModel() y modelReset().

[private signal] void QAbstractItemModel::modelReset()

Esta señal se emite cuando se llama a endResetModel(), después de que se haya invalidado el estado interno del modelo (por ejemplo, los índices persistentes del modelo).

Ten en cuenta que si se restablece un modelo debe considerarse que toda la información recuperada previamente de él no es válida. Esto incluye, pero no se limita a, los mensajes rowCount() y columnCount(), flags(), los datos recuperados a través de data(), y roleNames().

Véase también endResetModel() y modelAboutToBeReset().

[invokable] bool QAbstractItemModel::moveColumn(const QModelIndex &sourceParent, int sourceColumn, const QModelIndex &destinationParent, int destinationChild)

En los modelos que lo soportan, mueve sourceColumn de sourceParent a destinationChild bajo destinationParent.

Devuelve true si las columnas se han movido con éxito; en caso contrario devuelve false.

Véase también moveColumns() y moveRow().

[virtual invokable] bool QAbstractItemModel::moveColumns(const QModelIndex &sourceParent, int sourceColumn, int count, const QModelIndex &destinationParent, int destinationChild)

En los modelos que lo soportan, mueve las columnas count empezando por la dada sourceColumn bajo el padre sourceParent a la columna destinationChild bajo el padre destinationParent.

Devuelve true si las columnas se han movido correctamente; en caso contrario devuelve false.

La implementación de la clase base no hace nada y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar el movimiento. Alternativamente, puede proporcionar su propia API para alterar los datos.

Véase también beginMoveColumns() y endMoveColumns().

[invokable] bool QAbstractItemModel::moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)

En los modelos que lo soportan, mueve sourceRow de sourceParent a destinationChild bajo destinationParent.

Devuelve true si las filas se han movido con éxito; en caso contrario devuelve false.

Véase también moveRows() y moveColumn().

[virtual invokable] bool QAbstractItemModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)

En modelos que soportan esto, mueve count filas comenzando con la dada sourceRow bajo el padre sourceParent a la fila destinationChild bajo el padre destinationParent.

Devuelve true si las filas se han movido correctamente; en caso contrario devuelve false.

La implementación de la clase base no hace nada y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar el movimiento. Alternativamente, puede proporcionar su propia API para alterar los datos.

Véase también beginMoveRows() y endMoveRows().

[virtual, since 6.0] void QAbstractItemModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const

Rellena el roleDataSpan con los datos solicitados para el index dado.

La implementación por defecto llamará simplemente a data() para cada rol en el span. Una subclase puede reimplementar esta función para proporcionar datos a las vistas de forma más eficiente:

void MyModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const
{
    for (QModelRoleData &roleData : roleDataSpan) {
        int role = roleData.role();

        // ... obtain the data for index and role ...

        roleData.setData(result);
    }
}

En el fragmento anterior, index es el mismo para toda la llamada. Esto significa que el acceso a las estructuras de datos necesarias para recuperar la información de index sólo puede hacerse una vez (sacando el código correspondiente del bucle).

Se recomienda el uso de QModelRoleData::setData(), o de forma similar QVariant::setValue(), en lugar de construir un QVariant por separado y utilizar un operador de asignación simple; esto se debe a que el primero permite reutilizar la memoria ya asignada para el objeto QVariant almacenado dentro de un QModelRoleData, mientras que el segundo siempre asigna la nueva variante y luego destruye la anterior.

Tenga en cuenta que las vistas pueden llamar a multiData() con spans que han sido utilizados en llamadas anteriores, y por lo tanto pueden contener ya algunos datos. Por lo tanto, es imperativo que si el modelo no puede devolver los datos para un rol dado, entonces debe borrar los datos en el objeto QModelRoleData correspondiente. Esto puede hacerse llamando a QModelRoleData::clearData(), o de forma similar estableciendo un valor por defecto construido QVariant, y así sucesivamente. Si no se borran los datos, la vista creerá que los datos "antiguos" deben utilizarse para el rol correspondiente.

Por último, para evitar la duplicación de código, una subclase también puede decidir reimplementar data() en términos de multiData(), suministrando un span de un solo elemento:

QVariant MyModel::data(const QModelIndex &index, int role) const
{
    QModelRoleData roleData(role);
    multiData(index, roleData);
    return roleData.data();
}

Esta función se introdujo en Qt 6.0.

Véase también QModelRoleDataSpan y data().

[pure virtual invokable] QModelIndex QAbstractItemModel::parent(const QModelIndex &index) const

Devuelve el elemento padre del modelo con la dirección index. Si el elemento no tiene padre, se devuelve un QModelIndex no válido.

Una convención común utilizada en modelos que exponen estructuras de datos en árbol es que sólo los elementos de la primera columna tienen hijos. Para ese caso, al reimplementar esta función en una subclase la columna del QModelIndex devuelto sería 0.

Cuando reimplemente esta función en una subclase, tenga cuidado de evitar llamar a funciones miembro de QModelIndex, como QModelIndex::parent(), ya que los índices que pertenezcan a su modelo simplemente llamarán a su implementación, dando lugar a una recursión infinita.

Véase también createIndex().

[protected] QModelIndexList QAbstractItemModel::persistentIndexList() const

Devuelve la lista de índices almacenados como índices persistentes en el modelo.

[invokable] bool QAbstractItemModel::removeColumn(int column, const QModelIndex &parent = QModelIndex())

Elimina el column dado de los elementos hijos del parent especificado.

Devuelve true si se elimina la columna; en caso contrario devuelve false.

Véase también removeColumns(), removeRow() y insertColumn().

[virtual invokable] bool QAbstractItemModel::removeColumns(int column, int count, const QModelIndex &parent = QModelIndex())

En los modelos que lo admiten, elimina del modelo las columnas count que empiezan por la column dada bajo el padre parent.

Devuelve true si las columnas se han eliminado correctamente; en caso contrario, devuelve false.

La implementación de la clase base no hace nada y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar la eliminación. Alternativamente, puede proporcionar su propia API para alterar los datos.

Véase también removeColumn(), removeRows(), insertColumns(), beginRemoveColumns(), y endRemoveColumns().

[invokable] bool QAbstractItemModel::removeRow(int row, const QModelIndex &parent = QModelIndex())

Elimina el row dado de los elementos hijos del parent especificado.

Devuelve true si se elimina la fila; en caso contrario devuelve false.

Esta es una función de conveniencia que llama a removeRows(). La implementación de QAbstractItemModel de removeRows() no hace nada.

Véase también removeRows(), removeColumn(), y insertRow().

[virtual invokable] bool QAbstractItemModel::removeRows(int row, int count, const QModelIndex &parent = QModelIndex())

En los modelos que lo admiten, elimina del modelo las filas de count que comienzan con row bajo el padre parent.

Devuelve true si las filas se han eliminado correctamente; en caso contrario devuelve false.

La implementación de la clase base no hace nada y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si quieres soportar la eliminación. Alternativamente, puede proporcionar su propia API para alterar los datos.

Véase también removeRow(), removeColumns(), insertColumns(), beginRemoveRows(), y endRemoveRows().

[virtual protected slot] void QAbstractItemModel::resetInternalData()

Esta ranura se llama justo después de que los datos internos de un modelo se borren mientras se reinicia.

Esta ranura se proporciona para la comodidad de las subclases de modelos proxy concretos, como las subclases de QSortFilterProxyModel que mantienen datos adicionales.

class CustomDataProxy : public QSortFilterProxyModel
{
    Q_OBJECT
public:
    CustomDataProxy(QObject *parent)
      : QSortFilterProxyModel(parent)
    {
    }

    //...

    QVariant data(const QModelIndex &index, int role) const override
    {
        if (role != Qt::BackgroundRole)
            return QSortFilterProxyModel::data(index, role);

        if (m_customData.contains(index.row()))
            return m_customData.value(index.row());
        return QSortFilterProxyModel::data(index, role);
    }

private slots:
    void resetInternalData()
    {
        m_customData.clear();
    }

private:
  QHash<int, QVariant> m_customData;
};

Véase también modelAboutToBeReset() y modelReset().

[virtual slot] void QAbstractItemModel::revert()

Indica al modelo que debe descartar la información almacenada en caché. Esta función se utiliza normalmente para la edición de filas.

Véase también submit().

[virtual] QHash<int, QByteArray> QAbstractItemModel::roleNames() const

Devuelve los nombres de rol del modelo.

Los nombres de rol por defecto establecidos por Qt son:

[pure virtual invokable] int QAbstractItemModel::rowCount(const QModelIndex &parent = QModelIndex()) const

Devuelve el número de filas bajo la dirección parent. Cuando el padre es válido significa que rowCount devuelve el número de hijos del padre.

Véase también columnCount().

[private signal] void QAbstractItemModel::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)

Esta señal se emite justo antes de que se inserten filas en el modelo. Los nuevos elementos se colocarán entre start y end inclusive, bajo el elemento parent dado.

Véase también insertRows() y beginInsertRows().

[private signal] void QAbstractItemModel::rowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)

Esta señal se emite justo antes de que se muevan las filas dentro del modelo. Los elementos que se moverán son los comprendidos entre sourceStart y sourceEnd inclusive, bajo el elemento sourceParent dado. Se moverán a destinationParent a partir de la fila destinationRow.

Nota: Los componentes conectados a esta señal la utilizan para adaptarse a los cambios en las dimensiones del modelo. Sólo puede ser emitida por la implementación de QAbstractItemModel, y no puede ser emitida explícitamente en código de subclase.

Véase también beginMoveRows().

[private signal] void QAbstractItemModel::rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)

Esta señal se emite justo antes de que se eliminen filas del modelo. Los elementos que se eliminarán son los comprendidos entre first y last, ambos inclusive, bajo el elemento parent dado.

Véase también removeRows() y beginRemoveRows().

[private signal] void QAbstractItemModel::rowsInserted(const QModelIndex &parent, int first, int last)

Esta señal se emite después de que se hayan insertado filas en el modelo. Los nuevos elementos son los comprendidos entre first y last inclusive, bajo el elemento parent dado.

Véase también insertRows() y beginInsertRows().

[private signal] void QAbstractItemModel::rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)

Esta señal se emite después de que se hayan movido filas dentro del modelo. Los elementos entre sourceStart y sourceEnd inclusive, bajo el elemento sourceParent dado se han movido a destinationParent comenzando en la fila destinationRow.

Nota: Los componentes conectados a esta señal la utilizan para adaptarse a los cambios en las dimensiones del modelo. Sólo puede ser emitida por la implementación de QAbstractItemModel, y no puede ser emitida explícitamente en código de subclase.

Véase también beginMoveRows().

[private signal] void QAbstractItemModel::rowsRemoved(const QModelIndex &parent, int first, int last)

Esta señal se emite después de eliminar filas del modelo. Los elementos eliminados son los comprendidos entre first y last, ambos inclusive, bajo el elemento parent dado.

Véase también removeRows() y beginRemoveRows().

[virtual invokable] bool QAbstractItemModel::setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)

Establece los datos de role para el elemento en index a value.

Devuelve true si tiene éxito; en caso contrario devuelve false.

La señal dataChanged() debe emitirse si los datos se han establecido correctamente.

La implementación de la clase base devuelve false. Esta función y data() deben reimplementarse para modelos editables.

Véase también Qt::ItemDataRole, data(), y itemData().

[virtual] bool QAbstractItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole)

Establece los datos para los role y section dados en la cabecera con el orientation especificado al value suministrado.

Devuelve true si se han actualizado los datos de la cabecera; en caso contrario devuelve false.

Al reimplementar esta función, la señal headerDataChanged() debe emitirse explícitamente.

Véase también Qt::ItemDataRole y headerData().

[virtual] bool QAbstractItemModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)

Establece los datos de rol para el elemento en index al valor asociado en roles, para cada Qt::ItemDataRole.

Devuelve true si se ha realizado correctamente; en caso contrario, devuelve false.

Los roles que no estén en roles no se modificarán.

Véase también setData(), data(), y itemData().

[virtual invokable] QModelIndex QAbstractItemModel::sibling(int row, int column, const QModelIndex &index) const

Devuelve el hermano en row y column para el elemento en index, o un QModelIndex inválido si no hay hermano en esa ubicación.

sibling() es sólo una función práctica que encuentra el elemento padre y lo utiliza para recuperar el índice del elemento hijo en las direcciones row y column especificadas.

Este método puede ser sobreescrito opcionalmente para una optimización específica de la implementación.

Véase también index(), QModelIndex::row() y QModelIndex::column().

[virtual invokable] void QAbstractItemModel::sort(int column, Qt::SortOrder order = Qt::AscendingOrder)

Ordena el modelo por column en la dirección order.

La implementación de la clase base no hace nada.

[virtual] QSize QAbstractItemModel::span(const QModelIndex &index) const

Devuelve el espacio entre filas y columnas del elemento representado por index.

[virtual slot] bool QAbstractItemModel::submit()

Indica al modelo que debe enviar la información almacenada en caché al almacenamiento permanente. Esta función se utiliza normalmente para la edición de filas.

Devuelve true si no hay error; en caso contrario devuelve false.

Véase también revert().

[virtual] Qt::DropActions QAbstractItemModel::supportedDragActions() const

Devuelve las acciones soportadas por los datos de este modelo.

La implementación predeterminada devuelve supportedDropActions(). Reimplemente esta función si desea soportar acciones adicionales.

supportedDragActions() es utilizado por QAbstractItemView::startDrag() como valor por defecto cuando se produce un arrastre.

Véase también Qt::DropActions y Uso de arrastrar y soltar con vistas de elementos.

[virtual] Qt::DropActions QAbstractItemModel::supportedDropActions() const

Devuelve las acciones de drop soportadas por este modelo.

La implementación por defecto devuelve Qt::CopyAction. Reimplemente esta función si desea soportar acciones adicionales. También debe reimplementar la función dropMimeData() para manejar las operaciones adicionales.

Véase también dropMimeData(), Qt::DropActions, y Uso de la función de arrastrar y soltar con vistas de elementos.