Sur cette page

QItemDelegate Class

La classe QItemDelegate permet d'afficher et de modifier les éléments de données d'un modèle. Plus d'informations...

En-tête : #include <QItemDelegate>
CMake : find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake : QT += widgets
Héritages : QAbstractItemDelegate

Propriétés

Fonctions publiques

QItemDelegate(QObject *parent = nullptr)
virtual ~QItemDelegate()
bool hasClipping() const
QItemEditorFactory *itemEditorFactory() const
void setClipping(bool clip)
void setItemEditorFactory(QItemEditorFactory *factory)

Fonctions publiques réimplémentées

virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
virtual void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
virtual void setEditorData(QWidget *editor, const QModelIndex &index) const override
virtual void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override
virtual QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override
virtual void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override

Fonctions protégées

void drawBackground(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
virtual void drawCheck(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, Qt::CheckState state) const
virtual void drawDecoration(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, const QPixmap &pixmap) const
virtual void drawDisplay(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, const QString &text) const
virtual void drawFocus(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect) const

Fonctions protégées réimplémentées

virtual bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override
virtual bool eventFilter(QObject *object, QEvent *event) override

Description détaillée

QItemDelegate peut être utilisé pour fournir des fonctionnalités d'affichage personnalisées et des widgets d'édition pour les vues d'éléments basées sur les sous-classes QAbstractItemView. L'utilisation d'un délégué à cette fin permet de personnaliser et de développer les mécanismes d'affichage et d'édition indépendamment du modèle et de la vue.

La classe QItemDelegate est l'une des classes Modèle/Vue et fait partie du cadre modèle/vue de Qt. Notez que QStyledItemDelegate a pris en charge le dessin des vues d'éléments de Qt. Nous recommandons l'utilisation de QStyledItemDelegate lors de la création de nouveaux délégués.

Lors de l'affichage d'éléments d'un modèle personnalisé dans une vue standard, il suffit souvent de s'assurer que le modèle renvoie les données appropriées pour chacune des roles qui déterminent l'apparence des éléments dans les vues. Le délégué par défaut utilisé par les vues standard de Qt utilise ces informations de rôle pour afficher les éléments dans la plupart des formes courantes attendues par les utilisateurs. Cependant, il est parfois nécessaire d'avoir encore plus de contrôle sur l'apparence des éléments que le délégué par défaut ne peut en fournir.

Cette classe fournit des implémentations par défaut des fonctions permettant de peindre les données des éléments dans une vue et de modifier les données des modèles d'éléments. Les implémentations par défaut des fonctions virtuelles paint() et sizeHint(), définies dans QAbstractItemDelegate, sont fournies pour garantir que le délégué implémente le comportement de base correct attendu par les vues. Vous pouvez réimplémenter ces fonctions dans les sous-classes pour personnaliser l'apparence des éléments.

Lors de l'édition de données dans une vue d'élément, QItemDelegate fournit un widget d'éditeur, qui est un widget placé au-dessus de la vue pendant l'édition. Les éditeurs sont créés à l'aide de QItemEditorFactory; une instance statique par défaut fournie par QItemEditorFactory est installée sur tous les délégués d'éléments. Vous pouvez définir une usine personnalisée à l'aide de setItemEditorFactory() ou définir une nouvelle usine par défaut à l'aide de QItemEditorFactory::setDefaultFactory(). Ce sont les données stockées dans le modèle d'élément avec Qt::EditRole qui sont modifiées.

Seules les fonctions d'édition standard pour les délégués basés sur des widgets sont réimplémentées ici :

  • createEditor() renvoie le widget utilisé pour modifier les données du modèle et peut être réimplémenté pour personnaliser le comportement d'édition.
  • setEditorData() fournit au widget les données à manipuler.
  • updateEditorGeometry() s'assure que l'éditeur est affiché correctement par rapport à la vue de l'élément.
  • setModelData() renvoie les données mises à jour au modèle.

Le signal closeEditor() indique que l'utilisateur a terminé l'édition des données et que le widget de l'éditeur peut être détruit.

Rôles et types de données standard

Le délégué par défaut utilisé par les vues standard fournies avec Qt XML associe chaque rôle standard (défini par Qt::ItemDataRole) à certains types de données. Les modèles qui renvoient des données de ces types peuvent influencer l'apparence du délégué comme décrit dans le tableau suivant.

RôleTypes acceptés
Qt::BackgroundRoleQBrush
Qt::CheckStateRoleQt::CheckState
Qt::DecorationRoleQIconLes types acceptés sont les suivants : QPixmap et QColor
Qt::DisplayRoleQString et les types avec une représentation sous forme de chaîne de caractères
Qt::EditRoleVoir QItemEditorFactory pour plus de détails
Qt::FontRoleQFont
Qt::SizeHintRoleQSize
Qt::TextAlignmentRoleQt::Alignment
Qt::ForegroundRoleQBrush

Si le délégué par défaut ne permet pas le niveau de personnalisation dont vous avez besoin, que ce soit à des fins d'affichage ou d'édition de données, il est possible de sous-classer QItemDelegate pour mettre en œuvre le comportement souhaité.

Sous-classement

Lorsque l'on sous-classe QItemDelegate pour créer un délégué qui affiche les éléments à l'aide d'un moteur de rendu personnalisé, il est important de s'assurer que le délégué peut rendre les éléments de manière appropriée pour tous les états requis, tels que sélectionné, désactivé, coché. La documentation relative à la fonction paint() contient des conseils sur la manière d'y parvenir.

Vous pouvez fournir des éditeurs personnalisés en utilisant une fonction QItemEditorFactory. Le code suivant montre comment un éditeur personnalisé peut être mis à la disposition des délégués avec la fabrique d'éditeurs d'éléments par défaut.

QItemEditorFactory *editorFactory = new QItemEditorFactory;
QItemEditorCreatorBase *creator = new QStandardItemEditorCreator<MyFancyDateTimeEdit>();
editorFactory->registerEditor(QMetaType::QDateTime, creator);

QItemEditorFactory::setDefaultFactory(editorFactory);

Une fois la fabrique par défaut définie, tous les délégués d'éléments standard l'utiliseront (ainsi que les délégués qui ont été créés avant la définition de la fabrique par défaut).

De cette manière, vous pouvez éviter de sous-classer QItemDelegate, et toutes les valeurs du type spécifié (par exemple QMetaType::QDateTime) seront modifiées à l'aide de l'éditeur fourni (comme MyFancyDateTimeEdit dans l'exemple ci-dessus).

Une autre solution consiste à réimplémenter createEditor(), setEditorData(), setModelData() et updateEditorGeometry(). Ce processus est décrit dans la documentation de présentation de la programmation modèle/vue.

QStyledItemDelegate vs. QItemDelegate

Depuis Qt 4.4, il existe deux classes de délégués : QItemDelegate et QStyledItemDelegate. Cependant, le délégué par défaut est QStyledItemDelegate. Ces deux classes sont des alternatives indépendantes pour peindre et fournir des éditeurs pour les éléments dans les vues. La différence entre elles est que QStyledItemDelegate utilise le style courant pour peindre ses éléments. Nous recommandons donc d'utiliser QStyledItemDelegate comme classe de base lors de l'implémentation de délégués personnalisés ou lorsque vous travaillez avec des feuilles de style Qt. Le code requis pour l'une ou l'autre classe devrait être le même, à moins que le délégué personnalisé n'ait besoin d'utiliser le style pour dessiner.

Voir également Delegate Classes, QStyledItemDelegate, et QAbstractItemDelegate.

Documentation sur les propriétés

clipping : bool

si le délégué doit découper les événements de peinture

Cette propriété définit le clip de peinture en fonction de la taille de l'élément. La valeur par défaut est "on". Elle est utile dans les cas où les images sont plus grandes que la taille de l'élément.

Fonctions d'accès :

bool hasClipping() const
void setClipping(bool clip)

Documentation des fonctions membres

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

Construit un délégué de l'élément avec l'adresse parent.

[virtual noexcept] QItemDelegate::~QItemDelegate()

Détruit le délégué de l'élément.

[override virtual] QWidget *QItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const.

Renvoie le widget utilisé pour modifier l'élément spécifié par index. Le widget parent et le style option sont utilisés pour contrôler l'apparence du widget de l'éditeur.

Voir aussi QAbstractItemDelegate::createEditor().

[protected] void QItemDelegate::drawBackground(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const

Rend l'arrière-plan de l'élément pour la valeur donnée index, en utilisant la valeur donnée painter et le style option.

[virtual protected] void QItemDelegate::drawCheck(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, Qt::CheckState state) const

Crée un indicateur de contrôle dans le rectangle spécifié par rect, en utilisant les données painter et le style option, en utilisant les données state.

[virtual protected] void QItemDelegate::drawDecoration(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, const QPixmap &pixmap) const

Rend la décoration pixmap à l'intérieur du rectangle spécifié par rect en utilisant le style painter et le style option.

[virtual protected] void QItemDelegate::drawDisplay(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect, const QString &text) const

Rend la vue de l'élément text à l'intérieur du rectangle spécifié par rect en utilisant le style painter et le style option.

[virtual protected] void QItemDelegate::drawFocus(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect) const

Rend la région à l'intérieur du rectangle spécifié par rect, en indiquant qu'elle est au centre de l'attention, à l'aide de painter et du style option.

[override virtual protected] bool QItemDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)

Réimplémente : QAbstractItemDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index).

[override virtual protected] bool QItemDelegate::eventFilter(QObject *object, QEvent *event)

Réimplémente : QObject::eventFilter(QObject *watched, QEvent *event).

Voir les détails dans QAbstractItemDelegate::handleEditorEvent().

QItemEditorFactory *QItemDelegate::itemEditorFactory() const

Renvoie la fabrique d'éditeurs utilisée par le délégué de l'élément. Si aucune fabrique d'éditeurs n'est définie, la fonction renvoie null.

Voir aussi setItemEditorFactory().

[override virtual] void QItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const.

Effectue le rendu du délégué à l'aide de painter et du style option pour l'élément spécifié par index.

Lorsque vous réimplémentez cette fonction dans une sous-classe, vous devez mettre à jour la zone détenue par la variable rect de l'option, en utilisant la variable state de l'option pour déterminer l'état de l'élément à afficher, et ajuster la façon dont il est peint en conséquence.

Par exemple, un élément sélectionné peut être affiché différemment des éléments non sélectionnés, comme le montre le code suivant :

if (option.state & QStyle::State_Selected)
    painter->fillRect(option.rect, option.palette.highlight());

Après avoir peint, vous devez vous assurer que le peintre est ramené à l'état dans lequel il a été fourni lorsque cette fonction a été appelée. Par exemple, il peut être utile d'appeler QPainter::save() avant de peindre et QPainter::restore() après.

Voir également QStyle::State.

[override virtual] void QItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const.

Définit les données à afficher et à modifier par le widget editor à partir de l'élément de modèle de données spécifié par le modèle index.

L'implémentation par défaut stocke les données dans la propriété utilisateur du widget editor.

Voir aussi QMetaProperty::isUser().

void QItemDelegate::setItemEditorFactory(QItemEditorFactory *factory)

Définit l'usine d'édition à utiliser par le délégué de l'élément à l'adresse factory spécifiée. Si aucune usine d'édition n'est définie, le délégué de l'élément utilisera l'usine d'édition par défaut.

Voir également itemEditorFactory().

[override virtual] void QItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const.

Récupère les données du widget editor et les stocke dans le widget model spécifié à l'élément index.

L'implémentation par défaut obtient la valeur à stocker dans le modèle de données à partir de la propriété utilisateur du widget editor.

Voir aussi QMetaProperty::isUser().

[override virtual] QSize QItemDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const.

Renvoie la taille nécessaire au délégué pour afficher l'élément spécifié par index, en tenant compte des informations de style fournies par option.

Lors de la réimplémentation de cette fonction, il convient de noter que dans le cas d'éléments textuels, QItemDelegate ajoute une marge (c'est-à-dire 2 * QStyle::PM_FocusFrameHMargin) à la longueur du texte.

[override virtual] void QItemDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const

Réimplémente : QAbstractItemDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const.

Met à jour le site editor pour l'élément spécifié par index en fonction du style option indiqué.

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