QRangeModel::ItemAccess Struct
template <typename T> struct QRangeModel::ItemAccessLa plantilla ItemAccess ofrece un punto de personalización para controlar cómo accede « QRangeModel » a los datos de roles de los elementos individuales. Más información...
Esta estructura se introdujo en Qt 6.11.
Miembros públicos estáticos
(since 6.12) bool | canDropMimeData(const QMimeData *data) |
(since 6.12) bool | canDropMimeData(const QMimeData *data, int action, int row, int column, const QModelIndex &parent) |
(since 6.12) auto | dropMimeData(const QMimeData *data, auto inserter) |
(since 6.12) auto | dropMimeData(const QMimeData *data, int action, int row, int column, const QModelIndex &parent, auto inserter) |
(since 6.12) Qt::ItemFlags | flags(const T &item) |
(since 6.12) QMimeData * | mimeData(const QModelIndex &range) |
(since 6.12) QMimeData * | mimeData(const auto &range) |
(since 6.12) QStringList | mimeTypes() |
| QVariant | readRole(const T &item, int role) |
| bool | writeRole(T &item, const QVariant &value, int role) |
Descripción detallada
ItemAccess<T> es una plantilla de estructura en la que T especifica el tipo de elemento. Especializa esta plantilla para el tipo utilizado en tu estructura de datos e implementa las funciones de miembro de clase pertinentes.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static Qt::ItemFlags flags(const ColorEntry &entry)
{
return entry.flags();
}
static QVariant readRole(const ColorEntry &entry, int role)
{
switch (role) {
// ...
}
return {};
}
static bool writeRole(ColorEntry &entry, const QVariant &value, int role)
{
bool ok = false;
switch (role) {
// ...
}
return ok;
}
...
};Una especialización de este tipo tendrá prioridad sobre cualquier comportamiento predefinido y sobre una especialización correspondiente de ` RowOptions`.
Nota: No especialices esta plantilla para tipos de los que no seas propietario.
Documentación de las funciones miembro
[static, since 6.12] bool ItemAccess::canDropMimeData(const QMimeData *data)
[static, since 6.12] bool ItemAccess::canDropMimeData(const QMimeData *data, int action, int row, int column, const QModelIndex &parent)
Implementa uno de estos miembros de clase para indicar si data puede soltarse en el modelo. Si se implementa la versión simplificada, QRangeModel comprobará que action sea uno de los supported drop actions. En la versión completa, la implementación puede devolver resultados diferentes en función de la posición de la acción de soltar, tal y como se especifica en row, column y parent.
Este miembro es opcional y no es necesario para la personalización de la función «arrastrar y soltar». El comportamiento por defecto comprueba si data contiene uno de los tipos MIME compatibles.
Nota: Esta especialización solo se tendrá en cuenta cuando todos los elementos del modelo estén respaldados por elementos de tipo T. Para modelos heterogéneos en los que diferentes columnas proporcionan diferentes tipos de datos, especialice en su lugar RowOptions.
Estas funciones se introdujeron en Qt 6.12.
Véase también QAbstractItemModel::canDropMimeData().
[static, since 6.12] template <typename inserter:auto> auto ItemAccess::dropMimeData(const QMimeData *data, auto inserter)
[static, since 6.12] template <typename inserter:auto> auto ItemAccess::dropMimeData(const QMimeData *data, int action, int row, int column, const QModelIndex &parent, auto inserter)
Implementa uno de estos miembros de clase para decodificar las entradas pertinentes de data en una secuencia de elementos de tipo T, e incorpora estas filas al modelo asignando cada una de ellas a la inserter proporcionada. Devuelve si la operación se ha realizado correctamente.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static bool dropMimeData(const QMimeData *mimeData, auto inserter)
{
QByteArray data = mimeData->data(mimeTypes().first());
if (data.isEmpty())
return false;
QTextStream stream(&data, QIODevice::ReadOnly);
while (!stream.atEnd()) {
QString colorName;
stream >> colorName;
inserter = ColorEntry(colorName);
}
return true;
}
};Opcionalmente, los elementos descodificados pueden asociarse a un valor de fila y columna relativo a la ubicación de inserción. Si los datos MIME incluyen información posicional, esto permite mantener la «forma» de los elementos.
for (const auto &decodedItem: decodedItems) {
inserter = {
decodedItem,
{
relativeRow,
relativeColumn
}
};
}Implementa la versión con los parámetros action, row, column y parent para tener un control total sobre la operación.
Devuelve uno de los valores de ` DropOperation ` para proporcionar una indicación a ` QRangeModel ` sobre cómo deben aplicarse al modelo las filas eliminadas. Como alternativa, basta con devolver ` true ` (equivalente a ` DropOperation::Automatic`) o ` false ` (equivalente a ` DropOperation::DontDrop`).
Nota: Esta especialización solo se tendrá en cuenta cuando todos los elementos del modelo estén respaldados por elementos de tipo T. Para modelos heterogéneos en los que las distintas columnas proporcionan diferentes tipos de datos, especializa RowOptions en su lugar.
Estas funciones se introdujeron en Qt 6.12.
Véase también QAbstractItemModel::dropMimeData().
[static, since 6.12] Qt::ItemFlags ItemAccess::flags(const T &item)
Implementa este miembro de clase para que devuelva el objeto ` flags ` para ` item`.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static Qt::ItemFlags flags(const ColorEntry &entry)
{
return entry.flags();
}
};Esta función se introdujo en Qt 6.12.
Véase también QAbstractItemModel::flags().
[static, since 6.12] QMimeData *ItemAccess::mimeData(const QModelIndex &range)
[static, since 6.12] template <typename range:auto> QMimeData *ItemAccess::mimeData(const auto &range)
Implementa uno de estos miembros de clase para devolver el ` mime data ` correspondiente a los elementos del ` range` facilitado.
Si se proporciona la versión genérica, el iterador sobre ` range ` es bidireccional y hace referencia a un par con un elemento de tipo ` T ` y el correspondiente ` QModelIndex`.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static QMimeData *mimeData(const auto &range)
{
QByteArray data;
QTextStream stream(&data, QIODevice::WriteOnly);
for (const auto &[item, index] : range)
stream << item.colorName() << Qt::endl;
QMimeData *result = new QMimeData;
result->setData(mimeTypes().first(), data);
// Qt handles encoding into the default mime type
return result;
}
};Las entradas de range están ordenadas en orden lógico, desde la fila más superior hasta la última, y desde la columna más a la izquierda hasta la última.
Nota: Esta especialización solo se tendrá en cuenta cuando todos los elementos del modelo estén respaldados por elementos de tipo T. Para modelos heterogéneos en los que diferentes columnas proporcionan diferentes tipos de datos, especializa RowOptions en su lugar.
Estas funciones se introdujeron en Qt 6.12.
Véase también QAbstractItemModel::mimeData().
[static, since 6.12] QStringList ItemAccess::mimeTypes()
Implementa este miembro de clase para devolver la lista de objetos ` mime types ` que un modelo que contenga elementos de tipo ` T ` pueda utilizar para representar los datos del modelo durante las operaciones de arrastrar y soltar.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static QStringList mimeTypes()
{
return {
u"text/plain"_s,
u"application/x-qabstractitemmodeldatalist"_s
};
}
};Si la lista incluye el tipo « default mime type » que Qt utiliza para los datos de arrastrar y soltar, « QRangeModel » se encargará automáticamente de la codificación y descodificación de los datos para ese tipo MIME.
Nota: Esta especialización solo se tendrá en cuenta cuando todos los elementos del modelo estén respaldados por elementos de tipo T. Para modelos heterogéneos en los que diferentes columnas proporcionan distintos tipos de datos, especialice RowOptions en su lugar.
Esta función se introdujo en Qt 6.12.
Véase también QAbstractItemModel::mimeTypes().
[static] QVariant ItemAccess::readRole(const T &item, int role)
Implementa este miembro de clase para devolver los datos de item correspondientes al role solicitado.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static QVariant readRole(const ColorEntry &entry, int role)
{
switch (role) {
// ...
}
return {};
}
};Los tipos para los que ItemAccess está especializado con una implementación de readRole se interpretan implícitamente como multi-role items.
Véase también QAbstractItemModel::data().
[static] bool ItemAccess::writeRole(T &item, const QVariant &value, int role)
Implementa este miembro de clase para establecer los datos de ` item ` correspondientes al ` role ` solicitado en el valor ` value` facilitado, y devuelve si el cambio se ha realizado correctamente.
template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
static bool writeRole(ColorEntry &entry, const QVariant &value, int role)
{
bool ok = false;
switch (role) {
// ...
}
return ok;
}
};Véase también QAbstractItemModel::setData().
© 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.