En esta página

QAbstractItemModel Class

La clase QAbstractItemModel proporciona la interfaz abstracta para las clases de modelo de elemento. Más información...

Encabezado: #include <QAbstractItemModel>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Heredado de: QObject
Heredado por:
10 tipos

QAbstractItemModelReplica, QAbstractListModel, QAbstractProxyModel, QAbstractTableModel, QConcatenateTablesProxyModel, QFileSystemModel, QHelpContentModel, QPdfBookmarkModel, QRangeModel, y QStandardItemModel

Tipos públicos

enum class CheckIndexOption { NoOption, IndexIsValid, DoNotUseParent, ParentIsInvalid }
flags CheckIndexOptions
enum LayoutChangeHint { NoLayoutChangeHint, VerticalSortHint, HorizontalSortHint }

Funciones públicas

QAbstractItemModel(QObject *parent = nullptr)
virtual ~QAbstractItemModel()
virtual QModelIndex buddy(const QModelIndex &index) const
virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const
virtual bool canFetchMore(const QModelIndex &parent) const
bool checkIndex(const QModelIndex &index, QAbstractItemModel::CheckIndexOptions options = CheckIndexOption::NoOption) const
(since 6.0) virtual bool clearItemData(const QModelIndex &index)
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const = 0
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const = 0
virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
virtual void fetchMore(const QModelIndex &parent)
virtual Qt::ItemFlags flags(const QModelIndex &index) const
virtual bool hasChildren(const QModelIndex &parent = QModelIndex()) const
bool hasIndex(int row, int column, const QModelIndex &parent = QModelIndex()) const
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const
virtual QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const = 0
bool insertColumn(int column, const QModelIndex &parent = QModelIndex())
virtual bool insertColumns(int column, int count, const QModelIndex &parent = QModelIndex())
bool insertRow(int row, const QModelIndex &parent = QModelIndex())
virtual bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex())
virtual QMap<int, QVariant> itemData(const QModelIndex &index) const
virtual QModelIndexList match(const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap)) const
virtual QMimeData *mimeData(const QModelIndexList &indexes) const
virtual QStringList mimeTypes() const
bool moveColumn(const QModelIndex &sourceParent, int sourceColumn, const QModelIndex &destinationParent, int destinationChild)
virtual bool moveColumns(const QModelIndex &sourceParent, int sourceColumn, int count, const QModelIndex &destinationParent, int destinationChild)
bool moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)
virtual bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
(since 6.0) virtual void multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const
virtual QModelIndex parent(const QModelIndex &index) const = 0
bool removeColumn(int column, const QModelIndex &parent = QModelIndex())
virtual bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex())
bool removeRow(int row, const QModelIndex &parent = QModelIndex())
virtual bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex())
virtual QHash<int, QByteArray> roleNames() const
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const = 0
virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)
virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole)
virtual bool setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)
virtual QModelIndex sibling(int row, int column, const QModelIndex &index) const
virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder)
virtual QSize span(const QModelIndex &index) const
virtual Qt::DropActions supportedDragActions() const
virtual Qt::DropActions supportedDropActions() const

Ranuras públicas

virtual void revert()
virtual bool submit()

Señales

void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last)
void columnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)
void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
void columnsInserted(const QModelIndex &parent, int first, int last)
void columnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)
void columnsRemoved(const QModelIndex &parent, int first, int last)
void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList<int> &roles = QList<int>())
void headerDataChanged(Qt::Orientation orientation, int first, int last)
void layoutAboutToBeChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)
void layoutChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)
void modelAboutToBeReset()
void modelReset()
void rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
void rowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)
void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
void rowsInserted(const QModelIndex &parent, int first, int last)
void rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)
void rowsRemoved(const QModelIndex &parent, int first, int last)

Funciones protegidas

void beginInsertColumns(const QModelIndex &parent, int first, int last)
void beginInsertRows(const QModelIndex &parent, int first, int last)
bool beginMoveColumns(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)
bool beginMoveRows(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)
void beginRemoveColumns(const QModelIndex &parent, int first, int last)
void beginRemoveRows(const QModelIndex &parent, int first, int last)
void beginResetModel()
void changePersistentIndex(const QModelIndex &from, const QModelIndex &to)
void changePersistentIndexList(const QModelIndexList &from, const QModelIndexList &to)
QModelIndex createIndex(int row, int column, const void *ptr = nullptr) const
QModelIndex createIndex(int row, int column, quintptr id) const
void endInsertColumns()
void endInsertRows()
void endMoveColumns()
void endMoveRows()
void endRemoveColumns()
void endRemoveRows()
void endResetModel()
QModelIndexList persistentIndexList() const

Ranuras protegidas

virtual void resetInternalData()

Miembros estáticos protegidos

(since 6.12) Qt::weak_ordering compareData(const QVariant &left, const QVariant &right)
(since 6.12) Qt::weak_ordering compareData(const QVariant &left, const QVariant &right, const QCollator &collator)

Descripción detallada

La clase `QAbstractItemModel` define la interfaz estándar que deben utilizar los modelos de elementos para poder interoperar con otros componentes de la arquitectura modelo/vista. No está pensada para ser instanciada directamente. En su lugar, debes crear una subclase a partir de ella para crear nuevos modelos.

La clase QAbstractItemModel es una de las clases de modelo/vista y forma parte del marco de trabajo de modelo/vista de Qt. Se puede utilizar como modelo de datos subyacente para los elementos de vista de elementos en QML o para las clases de vista de elementos del módulo Qt Widgets.

Si necesitas un modelo para utilizarlo con una vista de elementos, como el elemento «List View» de QML o los widgets de C++ « QListView » o « QTableView », deberías plantearte crear una subclase de « QAbstractListModel » o « QAbstractTableModel » en lugar de esta clase.

El modelo de datos subyacente se expone a las vistas y a los delegados como una jerarquía de tablas. Si no se hace uso de la jerarquía, el modelo es una simple tabla de filas y columnas. Cada elemento tiene un índice único especificado por un QModelIndex.

Diagrama que muestra una cuadrícula de 3x3 con filas y columnas numeradas, en el que aparece resaltada la celda de la fila 1 y la columna 2.

Cada elemento de datos al que se puede acceder a través de un modelo tiene un índice de modelo asociado. Puede obtener este índice de modelo utilizando la función index(). Cada índice puede tener un índice sibling(); los elementos secundarios tienen un índice parent().

Cada elemento tiene asociados varios elementos de datos, que pueden recuperarse especificando un rol (véase Qt::ItemDataRole) en la función data() del modelo. Los datos de todos los roles disponibles pueden obtenerse al mismo tiempo mediante la función itemData().

Los datos de cada función se establecen mediante un Qt::ItemDataRole concreto. Los datos de las funciones individuales se establecen por separado con setData(), o bien se pueden establecer para todas las funciones con setItemData().

Los elementos se pueden consultar con flags() (véase Qt::ItemFlag) para comprobar si se pueden seleccionar, arrastrar o manipular de otras formas.

Si un elemento tiene objetos secundarios, hasChildren() devuelve true para el índice correspondiente.

El modelo dispone de un ` rowCount()` y un ` columnCount()` para cada nivel de la jerarquía. Las filas y columnas se pueden insertar y eliminar mediante ` insertRows()`, ` insertColumns()`, ` removeRows()` y ` removeColumns()`.

El modelo emite señales para indicar cambios. Por ejemplo, se emite dataChanged() cada vez que se modifican los datos puestos a disposición por el modelo. Los cambios en los encabezados proporcionados por el modelo provocan que se emita headerDataChanged(). Si cambia la estructura de los datos subyacentes, el modelo puede emitir layoutChanged() para indicar a cualquier vista asociada que debe volver a mostrar los elementos que se muestran, teniendo en cuenta la nueva estructura.

Los elementos disponibles a través del modelo pueden buscarse en función de datos concretos utilizando la función match().

Para ordenar el modelo, puedes utilizar sort().

Subclasificación

Nota: En la Referencia sobre subclasificación de modelos se ofrecenalgunas directrices generales para la subclasificación de modelos.

Al crear una subclase de `QAbstractItemModel`, como mínimo debes implementar ` index()`, ` parent()`, ` rowCount()`, ` columnCount()` y ` data()`. Estas funciones se utilizan en todos los modelos de solo lectura y constituyen la base de los modelos editables.

También puedes reimplementar ` hasChildren()` para proporcionar un comportamiento especial en los modelos en los que la implementación de ` rowCount()` resulte costosa. Esto permite a los modelos restringir la cantidad de datos solicitados por las vistas y puede utilizarse como una forma de implementar la carga diferida de los datos del modelo.

Para habilitar la edición en tu modelo, también debes implementar setData() y reimplementar flags() para garantizar que se devuelva ItemIsEditable. También puedes reimplementar headerData() y setHeaderData() para controlar la forma en que se presentan los encabezados de tu modelo.

Las señales « dataChanged()» y « headerDataChanged()» deben emitirse explícitamente al reimplementar las funciones « setData()» y « setHeaderData()», respectivamente.

Los modelos personalizados deben crear índices de modelo para que los utilicen otros componentes. Para ello, llama a ` createIndex()` con los números de fila y columna adecuados para el elemento, y un identificador para el mismo, ya sea como puntero o como valor entero. La combinación de estos valores debe ser única para cada elemento. Los modelos personalizados suelen utilizar estos identificadores únicos en otras funciones reimplementadas para recuperar datos de los elementos y acceder a información sobre los elementos padres e hijos de cada uno. Consulte el ejemplo de modelo de árbol simple para obtener más información sobre los identificadores únicos.

No es necesario que se admitan todos los roles definidos en Qt::ItemDataRole. Dependiendo del tipo de datos que contenga un modelo, puede que solo resulte útil implementar la función data() para devolver información válida para algunos de los roles más comunes. La mayoría de los modelos proporcionan al menos una representación textual de los datos de los elementos para el rol Qt::DisplayRole, y los modelos que funcionan correctamente también deberían proporcionar información válida para los roles Qt::ToolTipRole y Qt::WhatsThisRole. La compatibilidad con estos roles permite utilizar los modelos con vistas estándar de Qt. Sin embargo, para algunos modelos que gestionan datos muy especializados, puede ser conveniente proporcionar datos únicamente para los roles definidos por el usuario.

Los modelos que proporcionan interfaces a estructuras de datos redimensionables pueden ofrecer implementaciones de ` insertRows()`, ` removeRows()`, ` insertColumns()` y ` removeColumns()`. Al implementar estas funciones, es importante notificar a las vistas conectadas los cambios en las dimensiones del modelo, tanto antes como después de que se produzcan:

Las señales privadas que emiten estas funciones permiten a los componentes asociados tomar medidas antes de que los datos dejen de estar disponibles. La encapsulación de las operaciones de inserción y eliminación mediante estas funciones de inicio y fin también permite que el modelo gestione correctamente ` persistent model indexes `. Si desea que las selecciones se gestionen adecuadamente, debe asegurarse de llamar a estas funciones. Si inserta o elimina un elemento con elementos secundarios, no es necesario que llame a estas funciones para los elementos secundarios. En otras palabras, el elemento principal se encargará de sus elementos secundarios.

Para crear modelos que se rellenen de forma incremental, puede reimplementar ` fetchMore()` y ` canFetchMore()`. Si la reimplementación de ` fetchMore()` añade filas al modelo, deben llamarse ` beginInsertRows()` y ` endInsertRows()`.

Seguridad entre subprocesos

Al ser una subclase de QObject, QAbstractItemModel no es « thread-safe ». Cualquier API relacionada con el modelo QAbstractItemModel solo debe invocarse desde el hilo en el que reside el objeto modelo. Si QAbstractItemModel está conectado a una vista, opera en el hilo de la interfaz gráfica de usuario, ya que la vista reside allí e interactúa con el modelo desde ese hilo. Aunque se puede utilizar un hilo de fondo para rellenar o modificar el contenido del modelo, hay que hacerlo con cuidado, ya que no puede llamar directamente a ninguna API relacionada con el modelo. En su lugar, debes poner en cola las actualizaciones y aplicarlas en el hilo principal. Esto se puede hacer mediante conexiones en cola.

Véase también Clases de modelo, Referencia de subclasificación de modelos, QModelIndex, QAbstractItemView, QRangeModel, Uso de arrastrar y soltar con vistas de elementos, Ejemplo de modelo de árbol simple, Ejemplo de modelo de árbol editable y Ejemplo de «Fetch More».

Documentación sobre los tipos de miembros

enum class QAbstractItemModel::CheckIndexOption
flags QAbstractItemModel::CheckIndexOptions

Esta enumeración se puede utilizar para controlar las comprobaciones que realiza la función ` QAbstractItemModel::checkIndex()`.

ConstanteValorDescripción
QAbstractItemModel::CheckIndexOption::NoOption0x0000No se ha especificado ninguna opción de comprobación.
QAbstractItemModel::CheckIndexOption::IndexIsValid0x0001Se comprueba que el índice del modelo pasado a ` QAbstractItemModel::checkIndex()` sea un índice de modelo válido.
QAbstractItemModel::CheckIndexOption::DoNotUseParent0x0002No se realiza ninguna comprobación relacionada con el uso del índice padre del índice pasado a ` QAbstractItemModel::checkIndex()`.
QAbstractItemModel::CheckIndexOption::ParentIsInvalid0x0004Se comprueba que el padre del índice de modelo pasado a QAbstractItemModel::checkIndex() sea un índice de modelo no válido. Si se especifican tanto esta opción como DoNotUseParent, esta opción se ignora.

El tipo `CheckIndexOptions` es un `typedef` para ` QFlags<CheckIndexOption>`. Almacena una combinación OR de valores de `CheckIndexOption`.

enum QAbstractItemModel::LayoutChangeHint

Esta enumeración describe la forma en que el modelo cambia de diseño.

ConstanteValorDescripción
QAbstractItemModel::NoLayoutChangeHint0No hay ninguna sugerencia disponible.
QAbstractItemModel::VerticalSortHint1Se están ordenando las filas.
QAbstractItemModel::HorizontalSortHint2Se están ordenando las columnas.

Tenga en cuenta que VerticalSortHint y HorizontalSortHint indican que los elementos se están moviendo dentro del mismo elemento padre, no a un elemento padre diferente en el modelo, y que no se están filtrando ni excluyendo ni incluyendo.

Documentación de las funciones de miembro

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

Crea un modelo de elemento abstracto con el ` parent` indicado.

[virtual noexcept] QAbstractItemModel::~QAbstractItemModel()

Elimina el modelo de elemento abstracto.

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

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

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 de ` parent ` corresponde al elemento 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.

Insertar las columnas 4, 5 y 6 en una filaEspecifique los números de la primera y la última columna del intervalo de columnas que desea insertar en un elemento de un modelo.

Por ejemplo, tal y 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);

De este modo, se insertan las tres nuevas columnas como columnas 4, 5 y 6.

Añadir las columnas 6, 7 y 8 a una filaPara añadir columnas, insértalas después de la última columna.

Por ejemplo, tal y como se muestra en el diagrama, añadimos tres columnas a una colección de seis columnas existentes (que termina en la columna 5), por lo que first es 6 y last es 8:

beginInsertColumns(parent, 6, 8);

De este modo, se añaden las dos nuevas columnas como columnas 6, 7 y 8.

Nota: Esta función emite la señal columnsAboutToBeInserted(), que las vistas (o proxies) conectadas deben gestionar antes de que se inserten los datos. De lo contrario, las vistas podrían quedar en un estado no válido.

Véase también ` endInsertColumns()`.

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

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

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 de ` parent ` corresponde al elemento 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.

Insertar las filas 2, 3 y 4 en una listaEspecifica los números de la primera y la última fila del intervalo de filas que deseas insertar en un elemento de un modelo.

Por ejemplo, tal y 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);

De este modo, se insertan las tres nuevas filas como filas 2, 3 y 4.

Añadir las filas 4 y 5 a una listaPara añadir filas, insértalas después de la última fila.

Por ejemplo, tal y como se muestra en el diagrama, añadimos dos filas a una colección de 4 filas existentes (que termina en la fila 3), por lo que first es 4 y last es 5:

beginInsertRows(parent, 4, 5);

De este modo, se añaden las dos nuevas filas como filas 4 y 5.

Nota: Esta función emite la señal rowsAboutToBeInserted(), que las vistas (o proxies) conectadas deben gestionar antes de que se inserten los datos. De lo contrario, las vistas podrían quedar en un estado no válido.

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 desplazamiento de columnas.

Al reimplementar una subclase, este método simplifica el desplazamiento de entidades en el modelo. Este método se encarga de desplazar los índices persistentes del modelo, algo que, de otro modo, tendrías que hacer tú mismo. El uso de `beginMoveColumns` y ` endMoveColumns ` es una alternativa a emitir directamente ` layoutAboutToBeChanged ` y ` layoutChanged ` junto con ` changePersistentIndex`.

El índice sourceParent corresponde al padre desde el que se mueven las columnas; sourceFirst y sourceLast son los números de la primera y la última columna de las que se van a mover. El índice destinationParent corresponde al padre al que se mueven dichas columnas. El destinationChild es la columna a la que se moverán las columnas. Es decir, el índice de la columna sourceFirst en sourceParent pasará a ser la columna destinationChild en destinationParent, seguido de todas las demás columnas hasta sourceLast.

Sin embargo, al desplazar columnas hacia abajo dentro del mismo elemento 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 pasen a ser las columnas 1 y 2, destinationChild debería ser 3. En este caso, el nuevo índice de la columna de origen i (que se encuentra entre sourceFirst y sourceLast) es igual a (destinationChild-sourceLast-1+i).

Ten en cuenta que, si sourceParent y destinationParent son iguales, debes asegurarte de que destinationChild no se encuentre dentro del intervalo comprendido entre sourceFirst y sourceLast + 1. También debes asegurarte de no intentar mover una columna a uno de sus propios descendientes o antecesores. Este método devuelve false si se cumple cualquiera de estas condiciones, en cuyo caso debes abortar la operación de movimiento.

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 desplazamiento de filas.

Al reimplementar una subclase, este método simplifica el desplazamiento de entidades en el modelo. Este método se encarga de desplazar los índices persistentes del modelo, algo que, de otro modo, tendrías que hacer tú mismo. El uso de `beginMoveRows` y ` endMoveRows ` es una alternativa a emitir directamente ` layoutAboutToBeChanged ` y ` layoutChanged ` junto con ` changePersistentIndex`.

El índice sourceParent corresponde al padre desde el que se mueven las filas; sourceFirst y sourceLast son los números de la primera y la última fila de las filas que se van a mover. El índice destinationParent corresponde al padre al que se mueven esas filas. destinationChild es la fila a la que se moverán las filas. Es decir, el índice de la fila sourceFirst en sourceParent pasará a ser la fila destinationChild en destinationParent, seguido de todas las demás filas hasta sourceLast.

Sin embargo, al desplazar filas hacia abajo dentro del mismo elemento 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 pasen a ser las filas 1 y 2, destinationChild debería ser 3. En este caso, el nuevo índice de la fila de origen i (que se encuentra entre sourceFirst y sourceLast) es igual a (destinationChild-sourceLast-1+i).

Ten en cuenta que, si sourceParent y destinationParent son iguales, debes asegurarte de que destinationChild no se encuentre dentro del rango comprendido entre sourceFirst y sourceLast + 1. También debes asegurarte de no intentar mover una fila a uno de sus propios hijos o antecesores. Este método devuelve false si se cumple cualquiera de estas condiciones, en cuyo caso debes abortar la operación de movimiento.

Mover filas de un elemento principal a otroEspecifica los números de la primera y la última fila del intervalo de filas del elemento padre de origen que deseas mover en el modelo. Especifica también la fila del elemento padre de destino a la que se va a mover dicho intervalo.

Por ejemplo, tal y como se muestra en el diagrama, movemos tres filas de la fila 2 a la 4 en el elemento de origen, por lo que sourceFirst es 2 y sourceLast es 4. Movemos esos elementos por encima de la fila 2 en el elemento de destino, por lo que destinationChild es 2.

beginMoveRows(sourceParent, 2, 4, destinationParent, 2);

De este modo, las tres filas 2, 3 y 4 de la fuente pasan a ser las filas 2, 3 y 4 del destino. Los demás elementos hermanos afectados se desplazan en consecuencia.

Añadir filas a otro elemento principalPara añadir filas a otro padre, muévelas después de la última fila.

Por ejemplo, tal y como se muestra en el diagrama, movemos tres filas a una colección de seis filas existentes (que termina en la fila 5), por lo que destinationChild es 6:

beginMoveRows(sourceParent, 2, 4, destinationParent, 6);

De este modo, las filas de destino se trasladan al final del elemento principal de destino como filas 6, 7 y 8.

Desplazar una fila hacia arriba dentro del mismo elemento padrePara mover filas dentro del mismo elemento principal, especifica la fila a la que quieres moverlas.

Por ejemplo, tal y como se muestra en el diagrama, movemos un elemento de la fila 2 a la fila 0, de modo que sourceFirst y sourceLast son 2 y destinationChild es 0.

beginMoveRows(parent, 2, 2, parent, 0);

Ten en cuenta que otras filas pueden desplazarse en consecuencia. Ten en cuenta también que, al mover elementos dentro del mismo elemento padre, no debes intentar movimientos inválidos o que no produzcan ningún efecto. En el ejemplo anterior, el elemento 2 se encuentra en la fila 2 antes del desplazamiento, por lo que no puede desplazarse a la fila 2 (donde ya se encuentra) ni a la fila 3 (operación sin efecto, ya que la fila 3 significa «por encima de la fila 3», donde ya se encuentra).

Desplazar una fila hacia abajo dentro del mismo elemento principalPara mover filas dentro del mismo elemento principal, especifica la fila a la que quieres moverlas.

Por ejemplo, tal y 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 una columna.

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 elemento padre del que se eliminan las nuevas columnas; ` first ` y ` last ` son los números de la primera y la última columna que se van a eliminar.

Eliminar las columnas 4, 5 y 6 de una filaEspecifique los números de la primera y la última columna del intervalo de columnas que desea eliminar de un elemento de un modelo.

Por ejemplo, tal y como se muestra en el diagrama, eliminamos las tres columnas comprendidas entre la columna 4 y la columna 6, por lo que first es 4 y last es 6:

beginRemoveColumns(parent, 4, 6);

Nota: Esta función emite la señal columnsAboutToBeRemoved(), que las vistas (o proxies) conectadas deben gestionar antes de que se eliminen los datos. De lo contrario, las vistas podrían quedar en un estado no válido.

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 de ` parent ` corresponde al elemento padre del que se eliminan las nuevas filas; ` first ` y ` last ` son los números de las filas que se van a eliminar.

Eliminar las filas 2 y 3 de una listaEspecifique los números de la primera y la última fila del intervalo de filas que desea eliminar de un elemento de un modelo.

Por ejemplo, tal y como se muestra en el diagrama, eliminamos las dos filas comprendidas entre la fila 2 y la fila 3, por lo que first es 2 y last es 3:

beginRemoveRows(parent, 2, 3);

Nota: Esta función emite la señal « rowsAboutToBeRemoved()», que las vistas (o proxies) conectadas deben gestionar antes de que se eliminen los datos. De lo contrario, las vistas podrían quedar en un estado no válido.

Véase también endRemoveRows().

[protected] void QAbstractItemModel::beginResetModel()

Inicia una operación de restablecimiento del modelo.

Una operación de restablecimiento restablece el modelo a su estado actual en todas las vistas asociadas.

Nota: Las vistas asociadas a este modelo también se restablecerán.

Cuando se restablece un modelo, los datos anteriores proporcionados por el modelo dejan de ser válidos y deben consultarse de nuevo. Esto también implica que el elemento actual y cualquier elemento seleccionado dejarán de ser válidos.

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

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

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

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

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

Devuelve un índice de modelo para el «buddy» del elemento representado por index. Cuando el usuario desea editar un elemento, la vista llamará a esta función para comprobar si, en su lugar, se debería editar otro elemento del modelo. A continuación, la vista creará un delegado utilizando el índice de modelo devuelto por el elemento «buddy».

La implementación por defecto de esta función hace que cada elemento sea su propio «buddy».

[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 eliminación de ` data`. Esta implementación por defecto solo comprueba si ` data ` tiene al menos un formato en la lista de ` mimeTypes()` y si ` action ` se encuentra entre los ` supportedDropActions()` del modelo.

Reimplementa esta función en tu modelo personalizado si deseas comprobar si el data puede soltarse en row, column, parent con action. Si no necesitas esa comprobación, no es necesario reimplementar esta función.

Véase también ` dropMimeData()` y «Uso de 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.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también fetchMore().

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

Cambia el QPersistentModelIndex que coincide con el índice de modelo from especificado por el índice de modelo to especificado.

Si no se encuentra ningún índice de modelo persistente que coincida con el índice de modelo from especificado, no se realiza ningún cambio.

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

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

Cambia los {QPersistentModelIndex} que coincidan con los índices de la lista de índices del modelo from por los de la lista de índices del modelo to.

Si no se encuentran índices de modelo persistentes que coincidan con los índices de la lista de índices de modelo especificada en from, no se realiza ningún cambio.

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 válido para este modelo. Un índice de modelo válido puede ser un índice de modelo no válido o un índice de modelo válido que cumpla todas las condiciones siguientes:

  • 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 padre del índice;
  • la columna del í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 modificar algunas de estas comprobaciones. Si ` options ` contiene ` IndexIsValid`, entonces ` index ` debe ser un índice válido; esto resulta útil al reimplementar 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 infinita y un fallo del sistema).

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 resulta útil al implementar modelos planos, como listas o tablas, en los que ningún índice del modelo debería tener un índice padre válido.

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

Nota: Esta función es una herramienta de depuración para implementar tus propios modelos de elemento. Al desarrollar modelos complejos, así como al construir jerarquías de modelos complicadas (por ejemplo, utilizando modelos proxy), resulta útil llamar a esta función para detectar errores relacionados con índices de modelo no válidos (tal y como se definen anteriormente) que se hayan pasado accidentalmente a alguna API de QAbstractItemModel.

Advertencia: Ten en cuenta que pasar índices no válidos a los modelos de elementos constituye un comportamiento indefinido, por lo que las aplicaciones deben abstenerse de hacerlo y no confiar en ninguna programación «defensiva» que los modelos de elementos pudieran emplear para gestionar dichos índices de forma adecuada.

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 especificado. Devuelve true si se realiza correctamente; en caso contrario, devuelve false. Se debe 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 elementos secundarios de la clase « parent » indicada.

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

Por ejemplo:

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

Nota: Al implementar un modelo basado en tablas, columnCount() debería devolver 0 cuando el elemento padre sea válido.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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, ambos incluidos, debajo del elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 se desplacen las columnas dentro del modelo. Los elementos que se van a desplazar son aquellos comprendidos entre sourceStart y sourceEnd, ambos inclusive, bajo el elemento sourceParent especificado. Se trasladará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. Solo puede ser emitida por la implementación de QAbstractItemModel y no puede emitirse explícitamente en el código de una subclase.

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 que se eliminen columnas del modelo. Los elementos que se van a eliminar son aquellos comprendidos entre first y last, ambos inclusive, bajo el elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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

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

Esta señal se emite una vez que se han insertado columnas en el modelo. Los nuevos elementos son los que se encuentran entre first y last, ambos inclusive, bajo el elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 se hayan movido columnas dentro del modelo. Los elementos comprendidos entre sourceStart y sourceEnd, ambos inclusive, bajo el elemento sourceParent indicado, se han movido 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. Solo puede ser emitida por la implementación de QAbstractItemModel y no puede emitirse explícitamente en el código de una subclase.

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 que se hayan eliminado columnas del modelo. Los elementos eliminados son aquellos comprendidos entre first y last, ambos inclusive, bajo el elemento parent indicado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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

[static protected, since 6.12] Qt::weak_ordering QAbstractItemModel::compareData(const QVariant &left, const QVariant &right)

[static protected, since 6.12] Qt::weak_ordering QAbstractItemModel::compareData(const QVariant &left, const QVariant &right, const QCollator &collator)

Compara el objeto ` left ` ( QVariant ) con el objeto ` right ` ( QVariant) y devuelve el orden como un objeto ` weak ordering`.

Si el ` QVariant ` se compara como una cadena, se utiliza el objeto opcional ` collator ` para la comparación ` locale-aware ` y ` case-sensitive `. Si no se proporciona ningún collator, las cadenas se comparan exclusivamente en función de los valores numéricos Unicode de los caracteres. Esto es rápido, pero a menudo no es lo que el usuario espera de una interfaz de usuario.

Esta función es adecuada para implementaciones de ` QAbstractItemModel::sort()` (ordenación), ya que proporciona una ordenación débil incluso para valores variantes que no se pueden comparar, es decir, en los casos en los que ` QVariant::compare ` devolvería ` unordered`. Esto hace que su uso sea seguro en ` std::sort ` y ` std::stable_sort`, que requieren datos que se puedan ordenar.

void Model::sort(int column, Qt::SortOrder sortOrder)
{
    // Model operates on a QList<QVariant> data
    std::sort(data.begin(), data.end(), [=](const QVariant &lhs, const Variant &rhs){
        const auto ordering = compareData(lhs, rhs);
        return sortOrder == Qt::AscendingOrder ? sortOrder < 0 : sortOrder > 0;
    });
}

Si el ` left ` ` QVariant ` contiene una cadena, las variantes se comparan como en ` as strings`, utilizando el ` collator` opcional.

De lo contrario, la implementación compara left y right utilizando QVariant::compare(), que solo puede proporcionar un orden parcial. Si la comparación produce un resultado unordered y el meta type de left y right no son iguales, la función intenta convert las variantes a un tipo común y se vuelve a intentar la comparación.

Si esto sigue dando un resultado de « unordered », se comparan las representaciones como cadenas de ambas variantes. Esto podría comparar dos cadenas vacías, que son {Qt::weak_ordering::}{equivalentes}.

Invalid variants siempre se comparan como mayores que las variantes que contienen un valor válido.

Estas funciones se introdujeron en Qt 6.12.

Véase también «comparación a tres bandas», « sort()», « QVariant::compare » y « QSortFilterProxyModel ».

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

Crea un índice de modelo para los elementos « row » y « column » indicados, con el puntero interno « ptr ».

Cuando se utiliza un ` QSortFilterProxyModel`, sus índices tienen su propio puntero interno. No es recomendable acceder a este puntero interno desde fuera del modelo. En su lugar, utilice 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 elementos 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 de 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 ` indicado para el elemento al que hace referencia el ` index`.

Nota: Si no hay ningún valor que devolver, devuelve un ` QVariant` no válido (construido por defecto).

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 pertenecen al mismo padre, los afectados son aquellos comprendidos entre topLeft y bottomRight, ambos inclusive. Si los elementos no pertenecen al mismo padre, el comportamiento es indefinido.

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

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)

Gestiona el objeto ` data ` proporcionado por una operación de arrastrar y soltar que ha finalizado con el objeto ` action` indicado.

Devuelve ` true ` si el modelo ha gestionado los datos y la acción; en caso contrario, devuelve ` false`.

Los valores especificados 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 sobre un elemento en un QTreeView puede dar lugar a que se inserten nuevos elementos, ya sea 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 soltados deben considerarse como si se hubieran soltado directamente sobre parent. Normalmente, esto implicará añadir los datos como elementos hijos de parent. Si row y column son mayores o iguales a cero, significa que la acción de soltar se produjo justo antes de los elementos especificados row y column en el parent especificado.

Se invoca el miembro mimeTypes() para obtener la lista de tipos MIME aceptables. Esta implementación predeterminada asume la implementación predeterminada de mimeTypes(), que devuelve un único tipo MIME predeterminado. Si reimplementas mimeTypes() en tu modelo personalizado para devolver varios tipos MIME, debes reimplementar esta función para poder utilizarlos.

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

[protected] void QAbstractItemModel::endInsertColumns()

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

Al reimplementar insertColumns() en una subclase, debes llamar a esta función después de insertar los 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 una fila.

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

Véase también beginInsertRows().

[protected] void QAbstractItemModel::endMoveColumns()

Finaliza una operación de desplazamiento de columna.

Al implementar una subclase, debes llamar a esta función tras 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 desplazamiento de filas.

Al implementar una subclase, debes llamar a esta función tras desplazar 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 una columna.

Al reimplementar ` removeColumns()` en una subclase, debes llamar a esta función después de eliminar los 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 una fila.

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

Véase también ` beginRemoveRows()`.

[protected] void QAbstractItemModel::endResetModel()

Realiza una operación de restablecimiento del modelo.

Debes llamar a esta función tras restablecer cualquier estructura de datos interna de tu 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)

Recupera los datos disponibles de los elementos cuyo padre se especifica mediante el índice « parent ».

Reimplementa esto si estás rellenando tu modelo de forma incremental.

La implementación por defecto no realiza ninguna acción.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también canFetchMore().

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

Devuelve los indicadores del elemento para el index dado.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase ` Q_INVOKABLE`.

Véase también Qt::ItemFlags.

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

Devuelve ` true ` si ` parent ` tiene hijos; en caso contrario, devuelve ` false`.

Utiliza rowCount() en el elemento padre para averiguar el número de elementos hijos.

Ten en cuenta que se considera un comportamiento indefinido que este método indique que un índice concreto tiene hijos (hasChildren) si dicho índice tiene activada la bandera Qt::ItemNeverHasChildren.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase ` Q_INVOKABLE`.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

Devuelve los datos correspondientes a los valores « role » y « section » indicados en el encabezado, con el valor « orientation » especificado.

En el caso de los encabezados horizontales, el número de sección se corresponde con el número de columna. Del mismo modo, en el caso de los encabezados verticales, el número de sección se corresponde con el número de fila.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 un encabezado. La señal « orientation » indica si se ha modificado el encabezado horizontal o el vertical. Es necesario actualizar las secciones del encabezado que van desde « first » hasta « last ».

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

Si se modifica el número de columnas o filas, no es necesario emitir esta señal, sino que se deben utilizar las funciones begin/end (consulte la sección sobre subclasificación en la descripción de la clase QAbstractItemModel para obtener 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 del modelo especificado por los índices row, column y parent proporcionados.

Al reimplementar esta función en una subclase, llama a createIndex() para generar índices de modelo que otros componentes puedan utilizar para hacer referencia a elementos de tu modelo.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también createIndex().

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

Inserta una sola columna antes del elemento « column » indicado en los elementos secundarios del « parent » especificado.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 admiten esta función, inserta count nuevas columnas en el modelo antes de la columna especificada 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 al principio de las columnas ya existentes.

Si column es columnCount(), las columnas se añaden al final de las columnas existentes.

Si ` parent ` no tiene elementos secundarios, se inserta una única fila con ` count ` columnas.

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

La implementación de la clase base no realiza ninguna acción y devuelve ` false`.

Si implementas tu propio modelo, puedes reimplementar esta función si deseas admitir inserciones. Como alternativa, puedes proporcionar tu propia API para modificar los datos.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

Inserta una sola fila antes del elemento « row » indicado entre los elementos secundarios de la lista « parent » especificada.

Nota: Esta función llama al método virtual insertRows.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

Nota: La implementación de esta función enla clase base no realiza ninguna acción y devuelve ` false`.

En los modelos que lo admiten, inserta count filas en el modelo antes de la row indicada. 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 al principio de cualquier fila existente en el elemento padre.

Si row es rowCount(), las filas se añaden al final de las filas existentes en el elemento padre.

Si parent no tiene hijos, se inserta una sola columna con count filas.

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 deseas admitir inserciones. Como alternativa, puedes proporcionar tu propia API para modificar los datos. En cualquier caso, deberás llamar a ` beginInsertRows()` y a ` endInsertRows()` para notificar a otros componentes que el modelo ha cambiado.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 situado en la ruta index.

Reimplementa esta función si deseas ampliar su comportamiento predeterminado 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 tras emitir layoutAboutToBeChanged().

El parámetro opcional ` parents ` se utiliza para proporcionar una notificación más específica sobre qué partes del diseño 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 de la lista ` parents ` no es relevante. El parámetro opcional ` hint ` se utiliza para dar una pista sobre lo que está ocurriendo mientras se está rediseñando el modelo.

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 cada vez que cambia la disposición de los elementos mostrados por el modelo; por ejemplo, cuando se ha ordenado el modelo. Cuando una vista recibe esta señal, debe actualizar la disposición de los elementos para reflejar este cambio.

Al crear subclases de ` QAbstractItemModel ` o ` QAbstractProxyModel`, asegúrate de emitir ` layoutAboutToBeChanged()` antes de cambiar el orden de los elementos o modificar la estructura de los datos que expones a las vistas, y de emitir `layoutChanged()` después de cambiar la disposición.

El parámetro opcional parents se utiliza para proporcionar 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 relevante. El parámetro opcional hint se utiliza para dar una pista sobre lo que está ocurriendo mientras el modelo está reorganizando su disposición.

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

Véase 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 correspondientes a los elementos de la columna del índice start en los que los datos almacenados bajo el role dado coinciden con el value especificado. La forma en que se realiza la búsqueda viene definida por el flags proporcionado. 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 del modelo, si, por ejemplo, se utiliza un modelo proxy. No se puede confiar en el orden de los resultados.

La búsqueda comienza en el índice start y continúa hasta que el número de elementos de datos coincidentes sea igual a hits, la búsqueda llegue a la última fila o vuelva a alcanzar start, dependiendo de si se ha especificado MatchWrap en flags. Si desea buscar todos los elementos coincidentes, utilice hits = -1.

Por defecto, esta función realizará una comparación de cadenas con repetición de caracteres en todos los elementos, buscando aquellos que comiencen con el término de búsqueda especificado en value.

Nota: La implementación predeterminada de esta función solo busca en las columnas. Reimplementa esta función para incluir un comportamiento de búsqueda diferente.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

[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 predeterminada utiliza el tipo MIME predeterminado devuelto por la implementación predeterminada de ` mimeTypes()`. Si reimplementas ` mimeTypes()` en tu modelo personalizado para devolver más tipos MIME, reimplementa esta función para utilizarlos.

Si la lista de indexes está vacía, o no hay tipos MIME compatibles, 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 integrados utilizan un tipo MIME interno: application/x-qabstractitemmodeldatalist.

Al implementar la compatibilidad con la función de arrastrar y soltar en un modelo personalizado, si vas a devolver datos en formatos distintos al tipo MIME interno predeterminado, reimplementa esta función para devolver tu propia lista de tipos MIME.

Si reimplementas esta función en tu modelo personalizado, también debes reimplementar las funciones miembro que la invocan: mimeData() y dropMimeData().

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

[private signal] void QAbstractItemModel::modelAboutToBeReset()

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 obtenida previamente del mismo ha dejado de ser válida. Esto incluye, entre otros, las funciones rowCount() y columnCount(), flags(), los datos obtenidos mediante data() y roleNames().

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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

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

En los modelos que lo admiten, traslada sourceColumn de sourceParent a destinationChild en destinationParent.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 admiten esta función, mueve las columnas count que empiezan por el sourceColumn especificado, situadas bajo el sourceParent principal, a la columna destinationChild situada bajo el destinationParent principal.

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

La implementación de la clase base no realiza ninguna acción y devuelve « false ».

Si implementas tu propio modelo, puedes reimplementar esta función si deseas permitir el desplazamiento. Como alternativa, puedes proporcionar tu propia API para modificar los datos.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 admiten, mueve sourceRow de sourceParent a destinationChild en destinationParent.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 los modelos que admiten esta función, traslada count filas, empezando por la sourceRow indicada, que se encuentra bajo el elemento principal sourceParent, a la fila destinationChild, situada bajo el elemento principal destinationParent.

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

La implementación de la clase base no realiza ninguna acción y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si deseas permitir el traslado. Como alternativa, puedes proporcionar tu propia API para modificar los datos.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

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

La implementación por defecto llamará simplemente a ` data()` para cada rol del 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 de código 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 ` solo tiene que realizarse una vez (sacando el código relevante 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 lo primero permite reutilizar la memoria ya asignada para el objeto QVariant almacenado dentro de un QModelRoleData, mientras que lo segundo siempre asigna una nueva instancia y destruye la anterior.

Tenga en cuenta que las vistas pueden llamar a `multiData()` con intervalos que se hayan utilizado en llamadas anteriores y que, por lo tanto, ya puedan contener algunos datos. Por ello, es imprescindible que, si el modelo no puede devolver los datos para un rol determinado, borre los datos del objeto ` QModelRoleData ` correspondiente. Esto puede hacerse llamando a ` QModelRoleData::clearData()` o, de forma similar, estableciendo un ` QVariant` construido por defecto, 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 optar por reimplementar ` data()` en términos de `multiData()`, proporcionando un intervalo de un solo elemento:

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

Nota: Los modelos no pueden modificar los roles del span ni reorganizar los elementos del span. Hacerlo da lugar a un comportamiento indefinido.

Nota: Noestá permitido pasar un índice de modelo no válido a esta función.

Esta función se introdujo en Qt 6.0.

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

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

Devuelve el elemento padre del elemento del modelo con el « index » indicado. Si el elemento no tiene padre, se devuelve un « QModelIndex » no válido.

Una convención habitual en los modelos que exponen estructuras de datos en árbol es que solo los elementos de la primera columna tengan hijos. En ese caso, al reimplementar esta función en una subclase, la columna del objeto ` QModelIndex ` devuelto sería 0.

Al reimplementar esta función en una subclase, hay que tener cuidado de evitar llamar a funciones miembro de ` QModelIndex `, como ` QModelIndex::parent()`, ya que los índices que pertenecen a tu modelo simplemente llamarán a tu implementación, lo que provocaría una recursión infinita.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 elemento « column » indicado de los elementos secundarios de la « parent » especificada.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 admiten esta función, elimina del modelo las columnas count que empiecen por el column indicado, bajo el parent principal.

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

La implementación de la clase base no realiza ninguna acción y devuelve false.

Si implementas tu propio modelo, puedes reimplementar esta función si deseas permitir la eliminación. Como alternativa, puedes proporcionar tu propia API para modificar los datos.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

Elimina el elemento « row » indicado de los elementos secundarios del « parent » especificado.

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

Se trata de una función de conveniencia que llama a ` removeRows()`. La implementación de ` QAbstractItemModel ` de ` removeRows()` no realiza ninguna acción.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 admiten esta función, elimina del modelo las filas count que comiencen por el row especificado, bajo el parent principal.

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 deseas permitir la eliminación. Como alternativa, puedes proporcionar tu propia API para modificar los datos.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

Esta ranura se invoca justo después de que se borren los datos internos de un modelo durante su reinicio.

Este slot se proporciona para facilitar el trabajo a 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;
};

Nota: Debido a un error, este slot no está presente en Qt 5.0.

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 suele utilizar para la edición de filas.

Véase también submit().

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

Devuelve los nombres de los roles del modelo.

Los nombres de roles predeterminados establecidos por Qt son:

Rol de QtNombre del rol en QML
Qt::DisplayRoledisplay
Qt::DecorationRoledecoration
Qt::EditRoleedit
Qt::ToolTipRoletoolTip
Qt::StatusTipRoleestado
Qt::WhatsThisRole¿qué es esto?

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

Devuelve el número de filas que hay bajo el « parent » especificado. Cuando el «parent» es válido, «rowCount» devuelve el número de «children» de dicho «parent».

Nota: Al implementar un modelo basado en tablas, rowCount() debe devolver 0 cuando el elemento padre es válido.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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, ambos inclusive, debajo del elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 desplacen las filas dentro del modelo. Los elementos que se van a desplazar son los que se encuentran entre sourceStart y sourceEnd, ambos inclusive, bajo el elemento sourceParent. Se trasladará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. Solo puede ser emitida por la implementación de QAbstractItemModel y no puede emitirse explícitamente en el código de una subclase.

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 que se encuentran entre first y last, ambos inclusive, bajo el elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 que se encuentran entre first y last, ambos inclusive, bajo el elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 comprendidos entre sourceStart y sourceEnd, ambos inclusive, bajo el elemento sourceParent, se han movido 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. Solo puede ser emitida por la implementación de QAbstractItemModel y no puede emitirse explícitamente en el código de una subclase.

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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 que se hayan eliminado filas del modelo. Los elementos eliminados son aquellos comprendidos entre first y last, ambos inclusive, bajo el elemento parent especificado.

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

Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.

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

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

Establece el dato « role » del elemento situado en « index » en « value ».

Devuelve ` true ` si se realiza correctamente; en caso contrario, devuelve ` false`.

Se debe emitir la señal « dataChanged()» si los datos se han establecido correctamente.

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

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase ` Q_INVOKABLE`.

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 de los campos « role » y « section » del encabezado, con el valor especificado en « orientation », en el campo « value » proporcionado.

Devuelve true si se han actualizado los datos del encabezado; en caso contrario, devuelve false.

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

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

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

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

Devuelve true si la operación se realiza correctamente; en caso contrario, devuelve false.

Los roles que no figuren 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 elemento hermano situado en row y column correspondiente al elemento situado en index, o un QModelIndex no válido si no hay ningún elemento hermano en esa ubicación.

sibling() es simplemente una función de conveniencia que busca el elemento padre y la utiliza para recuperar el índice del elemento hijo en las ubicaciones especificadas row y column.

Este método puede sobrescribirse opcionalmente para realizar optimizaciones específicas de la implementación.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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 según el campo « column » en la tabla indicada order.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

Devuelve el rango de filas y columnas del elemento representado por ` index`.

Nota: Actualmente , «span» no se utiliza.

[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 ningún error; en caso contrario, devuelve ` false`.

Véase también revert().

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

Devuelve las acciones compatibles con los datos de este modelo.

La implementación por defecto devuelve ` supportedDropActions()`. Reimplementa esta función si deseas admitir acciones adicionales.

QAbstractItemView::startDrag() utiliza supportedDragActions() como valores por defecto cuando se produce un arrastre.

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

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

Devuelve las acciones de arrastre y soltar compatibles con este modelo.

La implementación predeterminada devuelve ` Qt::CopyAction`. Reimplementa esta función si deseas admitir acciones adicionales. También debes reimplementar la función ` dropMimeData()` para gestionar las operaciones adicionales.

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

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