Sur cette page

QRangeModel::ItemAccess Struct

template <typename T> struct QRangeModel::ItemAccess

Le modèle ItemAccess offre un point de personnalisation permettant de contrôler la manière dont l'QRangeModel e accède aux données de rôle des éléments individuels. En savoir plus...

Cette structure a été introduite dans Qt 6.11.

Membres publics statiques

(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)

Description détaillée

ItemAccess<T> est un modèle de structure dans lequel T spécifie le type d'élément. Spécialisez ce modèle pour le type utilisé dans votre structure de données, puis implémentez les fonctions membres de classe 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;
    }
    ...
};

Une spécialisation de ce type prévaudra sur tout comportement prédéfini, ainsi que sur une spécialisation correspondante de ` RowOptions`.

Remarque : ne spécialisezpas ce modèle pour des types dont vous n’êtes pas propriétaire.

Documentation des fonctions membres

[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)

Implémentez l’un de ces membres de classe pour indiquer si data peut être déposé dans le modèle. Si la version simplifiée est implémentée, alors QRangeModel vérifiera que action fait partie des supported drop actions. Dans la version complète, l’implémentation peut renvoyer différents résultats en fonction de la position du dépôt, telle que spécifiée par row, column et parent.

Ce membre est facultatif et n’est pas requis pour la personnalisation du glisser-déposer. Le comportement par défaut indique si data contient l’un des types MIME pris en charge.

Remarque : cette spécialisation ne sera prise en compte que lorsque tous les éléments du modèle sont représentés par des objets de type T. Pour les modèles hétérogènes où différentes colonnes fournissent différents types de données, spécialisez plutôt RowOptions.

Ces fonctions ont été introduites dans Qt 6.12.

Voir également 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)

Implémentez l'un de ces membres de classe pour décoder les entrées pertinentes de ` data ` en une séquence d'éléments de type ` T`, puis insérez ces lignes dans le modèle en les attribuant respectivement à ` inserter`. Indiquez si l'opération a abouti.

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;
    }
};

Facultativement, les éléments décodés peuvent être associés à une valeur de ligne et de colonne relative à l'emplacement d'insertion. Si les données MIME incluent des informations de position, cela permet de conserver la « forme » des éléments.

for (const auto &decodedItem: decodedItems) {
    inserter = {
        decodedItem,
        {
            relativeRow,
            relativeColumn
        }
    };
}

Implémentez la version avec les paramètres action, row, column et parent pour un contrôle total de l’opération.

Renvoyez l’une des valeurs de ` DropOperation ` pour fournir une indication à ` QRangeModel ` sur la manière dont les lignes supprimées doivent être appliquées au modèle. Vous pouvez également renvoyer simplement ` true ` (équivalent de ` DropOperation::Automatic`) ou ` false ` (équivalent de ` DropOperation::DontDrop`).

Remarque : cette spécialisation ne sera prise en compte que si tous les éléments du modèle sont représentés par des éléments de type T. Pour les modèles hétérogènes où différentes colonnes fournissent différents types de données, spécialisez plutôt RowOptions.

Ces fonctions ont été introduites dans Qt 6.12.

Voir également QAbstractItemModel::dropMimeData().

[static, since 6.12] Qt::ItemFlags ItemAccess::flags(const T &item)

Implémentez ce membre de classe pour renvoyer l'flags pour item.

template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
    static Qt::ItemFlags flags(const ColorEntry &entry)
    {
        return entry.flags();
    }
};

Cette fonction a été introduite dans Qt 6.12.

Voir également 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)

Implémentez l’un de ces membres de classe pour renvoyer l’ mime data des éléments contenus dans l’ range fourni.

Si la version générique est fournie, l’itérateur sur ` range ` est bidirectionnel et déréférence vers une paire contenant un élément de type ` T ` et la ` QModelIndex` correspondante.

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;
    }
};

Les entrées de ` range ` sont triées dans l’ordre logique, de la ligne la plus haute à la dernière ligne, et de la colonne la plus à gauche à la dernière colonne.

Remarque : cette spécialisation ne sera prise en compte que si tous les éléments du modèle sont représentés par des éléments de type T. Pour les modèles hétérogènes où différentes colonnes fournissent différents types de données, spécialisez plutôt RowOptions.

Ces fonctions ont été introduites dans Qt 6.12.

Voir également QAbstractItemModel::mimeData().

[static, since 6.12] QStringList ItemAccess::mimeTypes()

Implémentez ce membre de classe pour renvoyer la liste des objets ` mime types ` qu’un modèle contenant des éléments de type ` T ` peut utiliser pour représenter les données du modèle lors d’opérations de glisser-déposer.

template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
    static QStringList mimeTypes()
    {
        return {
            u"text/plain"_s,
            u"application/x-qabstractitemmodeldatalist"_s
        };
    }
};

Si la liste inclut le type MIME « default mime type » utilisé par Qt pour les données de glisser-déposer, alors QRangeModel se chargera automatiquement de l'encodage et du décodage des données pour ce type MIME.

Remarque : cette spécialisation ne sera prise en compte que si tous les éléments du modèle sont représentés par des éléments de type ` T`. Pour les modèles hétérogènes où différentes colonnes fournissent différents types de données, spécialisez plutôt ` RowOptions `.

Cette fonction a été introduite dans Qt 6.12.

Voir également QAbstractItemModel::mimeTypes().

[static] QVariant ItemAccess::readRole(const T &item, int role)

Implémentez ce membre de classe pour renvoyer les données contenues dans item pour l'role demandé.

template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
    static QVariant readRole(const ColorEntry &entry, int role)
    {
        switch (role) {
            // ...
        }
        return {};
    }
};

Les types pour lesquels ` ItemAccess ` est spécialisé avec une implémentation de ` readRole ` sont implicitement interprétés comme des ` multi-role items`.

Voir également QAbstractItemModel::data().

[static] bool ItemAccess::writeRole(T &item, const QVariant &value, int role)

Implémentez ce membre de classe pour définir les données de ` item ` de l'role ` demandé sur la valeur fournie ` value`, et indiquez si la modification a abouti.

template <>
struct QRangeModel::ItemAccess<ColorEntry>
{
    static bool writeRole(ColorEntry &entry, const QVariant &value, int role)
    {
        bool ok = false;
        switch (role) {
            // ...
        }
        return ok;
    }
};

Voir également 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.