https://doc.qt.io/qt-5/qtwidgets-itemviews-stardelegate-example.html

一、介绍

star委托示例展示了如何创建一个可以自己绘制并支持编辑的委托。

当在QListView、QTableView或QTreeView中显示数据时，单个项由委托绘制。此外，当用户开始编辑项(例如，双击项)时，委托提供一个编辑器小部件，在进行编辑时，该小部件被放置在项的顶部。

委托是QAbstractItemDelegate的子类。Qt提供了QStyledItemDelegate，它继承了QAbstractItemDelegate并处理最常见的数据类型(特别是int和QString)。如果我们需要支持自定义数据类型，或者想要自定义现有数据类型的呈现或编辑，我们可以子类化QAbstractItemDelegate或QStyledItemDelegate。如果你需要Qt的模型/视图体系结构(包括委托)的高级介绍，请参阅委托类以获得更多关于委托和模型/视图编程的信息。

在本例中，我们将看到如何实现自定义委托来呈现和编辑“星级评级”数据类型，它可以存储诸如“5颗星中的1颗”这样的值。

这个例子由以下类组成：

  • StarRating：是自定义数据类型。它存储以星表示的评级，如“5星中的2星”或“6星中的5星”。
  • starDelegate：继承了QStyledItemDelegate并提供了对StarRating的支持(除了QStyledItemDelegate已经处理的数据类型之外)。
  • StarEditor继承了QWidget，StarDelegate使用它来让用户使用鼠标编辑星级评级。

为了显示StarDelegate的实际操作，我们将用一些数据填充一个QTableWidget，并在其上安装delegate。

二、StarDelegate类

2.1定义

以下是StarDelegate类的定义：

  1. class StarDelegate : public QStyledItemDelegate {
  2.     Q_OBJECT
  3. public:
  4.     // 使用父类的构造函数
  5.     using QStyledItemDelegate::QStyledItemDelegate;
  7.     void paint(QPainter* painter, const QStyleOptionViewItem& option,
  8.         const QModelIndex& index) const override;
  10.     QSize sizeHint(const QStyleOptionViewItem& option,
  11.         const QModelIndex& index) const override;
  13.     QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option,
  14.         const QModelIndex& index) const override;
  16.     void setEditorData(QWidget* editor, const QModelIndex& index) const override;
  18.     void setModelData(QWidget* editor, QAbstractItemModel* model,
  19.         const QModelIndex& index) const override;
  21. private slots:
  22.     void commitAndCloseEditor();
  23. };

所有公共函数都是从QStyledItemDelegate中重新实现的虚函数，以提供自定义呈现和编辑。

2.2 实现

paint() 函数从QStyledItemDelegate中重新实现，并在视图需要重绘一个项目时调用

  1. void StarDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
  2.     const QModelIndex& index) const
  3. {
  4.     if (index.data().canConvert<StarRating>()) {
  5.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  7.         if (option.state & QStyle::State_Selected)
  8.             painter->fillRect(option.rect, option.palette.highlight());
  10.         starRating.paint(painter, option.rect, option.palette,
  11.             StarRating::EditMode::ReadOnly);
  12.     } else {
  13.         QStyledItemDelegate::paint(painter, option, index);
  14.     }
  15. }

该函数对每个项调用一次，由模型中的QModelIndex对象表示。如果存储在项目中的数据是StarRating，我们将自己绘制它；否则，我们让QStyledItemDelegate为我们绘制它。这确保了StarDelegate可以处理最常见的数据类型。

如果该项目是StarRating，那么如果该项目被选中，我们将绘制背景，并使用StarRating::paint()绘制该项目，
稍后我们将回顾这一点。

由于Q_DECLARE_METATYPE()宏出现在starrate .h中，StartRatings可以存储在QVariant中。稍后详细介绍。

当用户开始编辑条目时，createEditor()函数被调用：

  1. QWidget* StarDelegate::createEditor(QWidget* parent,
  2.     const QStyleOptionViewItem& option,
  3.     const QModelIndex& index) const
  4. {
  5.     if (index.data().canConvert<StarRating>()) {
  6.         StarEditor* editor = new StarEditor(parent);
  7.         connect(editor, &StarEditor::editingFinished,
  8.             this, &StarDelegate::commitAndCloseEditor);
  9.         return editor;
  10.     }
  11.     return QStyledItemDelegate::createEditor(parent, option, index);
  12. }

如果条目是StarRating，我们创建一个StarEditor，并将它的editingFinished()信号连接到commitAndCloseEditor()槽，这样我们就可以在编辑器关闭时更新模型。

下面是commitAndCloseEditor()的实现：

  1. void StarDelegate::commitAndCloseEditor()
  2. {
  3.     StarEditor* editor = qobject_cast<StarEditor*>(sender());
  4.     emit commitData(editor);
  5.     emit closeEditor(editor);
  6. }

当用户完成编辑时，我们发出commitData()和closeEditor()(都在QAbstractItemDelegate中声明)，告诉模型有编辑过的数据，并通知视图不再需要编辑器。

setEditorData()函数在创建编辑器时调用，用来自模型的数据初始化编辑器:

  1. void StarDelegate::setEditorData(QWidget* editor,
  2.     const QModelIndex& index) const
  3. {
  4.     if (index.data().canConvert<StarRating>()) {
  5.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  6.         StarEditor* starEditor = qobject_cast<StarEditor*>(editor);
  7.         starEditor->setStarRating(starRating);
  8.     } else {
  9.         QStyledItemDelegate::setEditorData(editor, index);
  10.     }
  11. }

我们只需在编辑器上调用setStarRating()。

当编辑完成时，调用setModelData()函数将数据从编辑器提交给模型：

  1. void StarDelegate::setModelData(QWidget* editor, QAbstractItemModel* model,
  2.     const QModelIndex& index) const
  3. {
  4.     if (index.data().canConvert<StarRating>()) {
  5.         StarEditor* starEditor = qobject_cast<StarEditor*>(editor);
  6.         model->setData(index, QVariant::fromValue(starEditor->starRating()));
  7.     } else {
  8.         QStyledItemDelegate::setModelData(editor, model, index);
  9.     }
  10. }

sizeHint()函数的作用是：返回一个元素的首选大小：

  1. QSize StarDelegate::sizeHint(const QStyleOptionViewItem& option,
  2.     const QModelIndex& index) const
  3. {
  4.     if (index.data().canConvert<StarRating>()) {
  5.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  6.         return starRating.sizeHint();
  7.     }
  8.     return QStyledItemDelegate::sizeHint(option, index);
  9. }

三、StarEditor类

3.1 定义

在实现StarDelegate时使用了StarEditor类。下面是类的定义：

  1. class StarEditor : public QWidget {
  2.     Q_OBJECT
  3. public:
  4.     StarEditor(QWidget* parent = nullptr);
  6.     QSize sizeHint() const override;
  7.     void setStarRating(const StarRating& starRating)
  8.     {
  9.         myStarRating = starRating;
  10.     }
  11.     StarRating starRating() { return myStarRating; }
  13. signals:
  14.     void editingFinished();
  16. protected:
  17.     void paintEvent(QPaintEvent* event) override;
  18.     void mouseMoveEvent(QMouseEvent* event) override;
  19.     void mouseReleaseEvent(QMouseEvent* event) override;
  21. private:
  22.     int starAtPosition(int x) const;
  24.     StarRating myStarRating;
  25. };

这个类允许用户通过将鼠标移到编辑器上来编辑StarRating。当用户单击编辑器时，它会发出editingFinished()信号。

受保护的函数从QWidget重新实现，以处理鼠标和绘图事件。私有函数starAtPosition()是一个辅助函数，它返回鼠标指针下的*号。

3.2 实现

让我们从构造函数开始：

  1. StarEditor::StarEditor(QWidget* parent)
  2.     : QWidget(parent)
  3. {
  4.     setMouseTracking(true);
  5.     setAutoFillBackground(true);
  6. }

我们在小部件上启用鼠标跟踪，这样即使用户没有按下任何鼠标按钮，我们也可以跟踪光标。我们还打开了QWidget的自动填充背景特性，以获得不透明的背景。(如果没有调用，视图的背景将通过编辑器发光。)

它的paintEvent()函数从QWidget重新实现：

  1. void StarEditor::paintEvent(QPaintEvent*)
  2. {
  3.     QPainter painter(this);
  4.     myStarRating.paint(&painter, rect(), palette(),
  5.         StarRating::EditMode::Editable);
  6. }

我们简单地调用StarRating::paint()来绘制星星，就像我们在实现StarDelegate时所做的那样。

  1. void StarEditor::mouseMoveEvent(QMouseEvent* event)
  2. {
  3.     const int star = starAtPosition(event->x());
  5.     if (star != myStarRating.starCount() && star != -1) {
  6.         myStarRating.setStarCount(star);
  7.         update();
  8.     }
  9.     QWidget::mouseMoveEvent(event);
  10. }

在鼠标事件处理程序中，我们对私有数据成员myStarRating调用setStarCount()来反映当前光标的位置，并调用QWidget::update()来强制重绘。

  1. void StarEditor::mouseReleaseEvent(QMouseEvent* event)
  2. {
  3.     emit editingFinished();
  4.     QWidget::mouseReleaseEvent(event);
  5. }

当用户释放鼠标按钮时，我们只发出editingFinished()信号。

  1. int StarEditor::starAtPosition(int x) const
  2. {
  3.     const int star = (x / (myStarRating.sizeHint().width() / myStarRating.maxStarCount())) + 1;
  4.     if (star <= 0 || star > myStarRating.maxStarCount())
  5.         return -1;
  7.     return star;
  8. }

starAtPosition()函数使用基本的线性代数来找出光标下的星星。

sizeHint()：首选的大小刚好足够绘制最大数目的星星。

  1. QSize StarEditor::sizeHint() const
  2. {
  3.     return myStarRating.sizeHint();
  4. }

四、StarRating类

4.1 定义

  1. class StarRating {
  2. public:
  3.     enum class EditMode { Editable,
  4.         ReadOnly };
  6.     explicit StarRating(int starCount = 1, int maxStarCount = 5);
  8.     void paint(QPainter* painter, const QRect& rect,
  9.         const QPalette& palette, EditMode mode) const;
  10.     QSize sizeHint() const;
  11.     int starCount() const { return myStarCount; }
  12.     int maxStarCount() const { return myMaxStarCount; }
  13.     void setStarCount(int starCount) { myStarCount = starCount; }
  14.     void setMaxStarCount(int maxStarCount) { myMaxStarCount = maxStarCount; }
  16. private:
  17.     QPolygonF starPolygon;
  18.     QPolygonF diamondPolygon;
  19.     int myStarCount;
  20.     int myMaxStarCount;
  21. };
  23. Q_DECLARE_METATYPE(StarRating)

StarRating类用一些星星表示一个评级。除了保存数据之外，它还能够在QPaintDevice上绘制星星，在本例中，QPaintDevice是一个视图或编辑器。myStarCount成员变量存储当前评级，而myMaxStarCount存储可能的最高评级(通常为5)。

Q_DECLARE_METATYPE()宏使QVariant知道StarRating类型，使得在QVariant中存储StarRating值成为可能。

4.2 实现

构造函数初始化myStarCount和myMaxStarCount，并设置用于绘制星星和菱形的多边形:

  1. StarRating::StarRating(int starCount, int maxStarCount)
  2.     : myStarCount(starCount)
  3.     , myMaxStarCount(maxStarCount)
  4. {
  5.     starPolygon << QPointF(1.0, 0.5);
  6.     for (int i = 1; i < 5; ++i)
  7.         starPolygon << QPointF(0.5 + 0.5 * std::cos(0.8 * i * 3.14),
  8.             0.5 + 0.5 * std::sin(0.8 * i * 3.14));
  10.     diamondPolygon << QPointF(0.4, 0.5) << QPointF(0.5, 0.4)
  11.                    << QPointF(0.6, 0.5) << QPointF(0.5, 0.6)
  12.                    << QPointF(0.4, 0.5);
  13. }

paint()函数用于绘制绘制设备上StarRating对象中的星星：

  1. void StarRating::paint(QPainter* painter, const QRect& rect,
  2.     const QPalette& palette, EditMode mode) const
  3. {
  4.     painter->save();
  6.     painter->setRenderHint(QPainter::Antialiasing, true);
  7.     painter->setPen(Qt::NoPen);
  8.     painter->setBrush(mode == EditMode::Editable ? palette.highlight() : palette.windowText());
  10.     const int yOffset = (rect.height() - PaintingScaleFactor) / 2;
  11.     painter->translate(rect.x(), rect.y() + yOffset);
  12.     painter->scale(PaintingScaleFactor, PaintingScaleFactor);
  14.     for (int i = 0; i < myMaxStarCount; ++i) {
  15.         if (i < myStarCount) {
  16.             painter->drawPolygon(starPolygon, Qt::WindingFill);
  17.         } else if (mode == EditMode::Editable) {
  18.             painter->drawPolygon(diamondPolygon, Qt::WindingFill);
  19.         }
  20.         painter->translate(1.0, 0.0);
  21.     }
  23.     painter->restore();
  24. }

五、main函数

下面是程序的main()函数:

  1. int main(int argc, char* argv[])
  2. {
  3.     QApplication app(argc, argv);
  5.     QTableWidget tableWidget(4, 4);
  6.     tableWidget.setItemDelegate(new StarDelegate);
  7.     tableWidget.setEditTriggers(QAbstractItemView::DoubleClicked
  8.         | QAbstractItemView::SelectedClicked);
  9.     tableWidget.setSelectionBehavior(QAbstractItemView::SelectRows);
  10.     tableWidget.setHorizontalHeaderLabels({ "Title", "Genre", "Artist", "Rating" });
  12.     populateTableWidget(&tableWidget);
  14.     tableWidget.resizeColumnsToContents();
  15.     tableWidget.resize(500, 300);
  16.     tableWidget.show();
  18.     return app.exec();
  19. }

main()函数创建一个QTableWidget并在其上设置一个StarDelegate。DoubleClicked和SelectedClicked被设置为编辑触发器，这样当星型评级项目被选中时，编辑器就会随着一次单击而打开。

populateTableWidget()函数用数据填充QTableWidget：

  1. void populateTableWidget(QTableWidget* tableWidget)
  2. {
  3.     static constexpr struct {
  4.         const char* title;
  5.         const char* genre;
  6.         const char* artist;
  7.         int rating;
  8.     } staticData[] = {
  9.         { "Mass in B-Minor", "Baroque", "J.S. Bach", 5 },
  10.         //! [1]
  11.         { "Three More Foxes", "Jazz", "Maynard Ferguson", 4 },
  12.         { "Sex Bomb", "Pop", "Tom Jones", 3 },
  13.         { "Barbie Girl", "Pop", "Aqua", 5 },
  14.         { nullptr, nullptr, nullptr, 0 }
  15.     };
  17.     for (int row = 0; staticData[row].title != nullptr; ++row) {
  18.         QTableWidgetItem* item0 = new QTableWidgetItem(staticData[row].title);
  19.         QTableWidgetItem* item1 = new QTableWidgetItem(staticData[row].genre);
  20.         QTableWidgetItem* item2 = new QTableWidgetItem(staticData[row].artist);
  21.         QTableWidgetItem* item3 = new QTableWidgetItem;
  22.         // 调用QVariant::fromValue将StarRating转换为QVariant
  23.         item3->setData(0, QVariant::fromValue(StarRating(staticData[row].rating)));
  25.         tableWidget->setItem(row, 0, item0);
  26.         tableWidget->setItem(row, 1, item1);
  27.         tableWidget->setItem(row, 2, item2);
  28.         tableWidget->setItem(row, 3, item3);
  29.     }
  30. }

注意：调用QVariant::fromValue将StarRating转换为QVariant。

六、示例代码

stardelegate.h

  1. #ifndef STARDELEGATE_H
  2. #define STARDELEGATE_H
  4. #include <QStyledItemDelegate>
  6. class StarDelegate : public QStyledItemDelegate {
  7.     Q_OBJECT
  8. public:
  9.     using QStyledItemDelegate::QStyledItemDelegate;
  11.     void paint(QPainter* painter, const QStyleOptionViewItem& option,
  12.         const QModelIndex& index) const override;
  13.     QSize sizeHint(const QStyleOptionViewItem& option,
  14.         const QModelIndex& index) const override;
  15.     QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option,
  16.         const QModelIndex& index) const override;
  17.     void setEditorData(QWidget* editor, const QModelIndex& index) const override;
  18.     void setModelData(QWidget* editor, QAbstractItemModel* model,
  19.         const QModelIndex& index) const override;
  21. private slots:
  22.     void commitAndCloseEditor();
  23. };
  24. #endif

stardelegate.cpp

  1. #include "stardelegate.h"
  2. #include "stareditor.h"
  3. #include "starrating.h"
  4. #include <QtWidgets>
  6. // paint()函数从QStyledItemDelegate中重新实现，并在视图需要重绘一个项目时调用
  7. void StarDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
  8.     const QModelIndex& index) const
  9. {
  10.     // 如果项目中的数据是StarRating,将自己绘制它;
  11.     // 否则让QStyledItemDelegate去绘制它, 这样可以让StarDelegate处理常见的数据类型
  12.     if (index.data().canConvert<StarRating>()) {
  13.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  14.         // 如果该项目被选中, 我们将绘制背景, 并使用StarRating::paint()绘制该项目
  15.         if (option.state & QStyle::State_Selected) {
  16.             painter->fillRect(option.rect, option.palette.highlight());
  17.         }
  18.         starRating.paint(painter, option.rect, option.palette,
  19.             StarRating::EditMode::ReadOnly);
  20.     } else {
  21.         QStyledItemDelegate::paint(painter, option, index);
  22.     }
  23. }
  25. // 当用户开始编辑条目时，createEditor()函数被调用
  26. QWidget* StarDelegate::createEditor(QWidget* parent,
  27.     const QStyleOptionViewItem& option,
  28.     const QModelIndex& index) const
  29. {
  30.     // 如果条目是StarRating,我们创建一个StarEditor,并绑定信号槽,以确保在编辑器关闭时更新模型
  31.     if (index.data().canConvert<StarRating>()) {
  32.         StarEditor* editor = new StarEditor(parent);
  33.         connect(editor, &StarEditor::editingFinished,
  34.             this, &StarDelegate::commitAndCloseEditor);
  35.         return editor;
  36.     }
  37.     return QStyledItemDelegate::createEditor(parent, option, index);
  38. }
  40. // 当用户完成编辑时，我们发出commitData()和closeEditor(),告诉模型有编辑过的数据,并通知视图不再需要编辑器
  41. void StarDelegate::commitAndCloseEditor()
  42. {
  43.     StarEditor* editor = qobject_cast<StarEditor*>(sender());
  44.     // 以下两个信号在QAbstractItemDelegate中声明
  45.     emit commitData(editor);
  46.     emit closeEditor(editor);
  47. }
  49. // setEditorData()函数在创建编辑器时调用，用来自模型的数据初始化编辑器:
  50. void StarDelegate::setEditorData(QWidget* editor,
  51.     const QModelIndex& index) const
  52. {
  53.     if (index.data().canConvert<StarRating>()) {
  54.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  55.         StarEditor* starEditor = qobject_cast<StarEditor*>(editor);
  56.         starEditor->setStarRating(starRating);
  57.     } else {
  58.         QStyledItemDelegate::setEditorData(editor, index);
  59.     }
  60. }
  61. // 我们只需在编辑器上调用setStarRating()。
  62. // 当编辑完成时，调用setModelData()函数将数据从编辑器提交给模型:
  63. void StarDelegate::setModelData(QWidget* editor, QAbstractItemModel* model,
  64.     const QModelIndex& index) const
  65. {
  66.     if (index.data().canConvert<StarRating>()) {
  67.         StarEditor* starEditor = qobject_cast<StarEditor*>(editor);
  68.         model->setData(index, QVariant::fromValue(starEditor->starRating()));
  69.     } else {
  70.         QStyledItemDelegate::setModelData(editor, model, index);
  71.     }
  72. }
  74. // sizeHint()函数: 返回一个元素的首选大小
  75. QSize StarDelegate::sizeHint(const QStyleOptionViewItem& option,
  76.     const QModelIndex& index) const
  77. {
  78.     if (index.data().canConvert<StarRating>()) {
  79.         StarRating starRating = qvariant_cast<StarRating>(index.data());
  80.         return starRating.sizeHint();
  81.     }
  82.     return QStyledItemDelegate::sizeHint(option, index);
  83. }

stareditor.h

  1. #ifndef STAREDITOR_H
  2. #define STAREDITOR_H
  4. #include <QWidget>
  6. #include "starrating.h"
  8. // 在实现StarDelegate时使用了StarEditor类
  10. class StarEditor : public QWidget {
  11.     Q_OBJECT
  12. public:
  13.     StarEditor(QWidget* parent = nullptr);
  15.     QSize sizeHint() const override;
  17.     void setStarRating(const StarRating& starRating)
  18.     {
  19.         myStarRating = starRating;
  20.     }
  22.     StarRating starRating() { return myStarRating; }
  24. signals:
  25.     void editingFinished();
  27. protected:
  28.     void paintEvent(QPaintEvent* event) override;
  29.     void mouseMoveEvent(QMouseEvent* event) override;
  30.     void mouseReleaseEvent(QMouseEvent* event) override;
  32. private:
  33.     int starAtPosition(int x) const;
  35.     StarRating myStarRating;
  36. };
  38. #endif

stareditor.cpp

  1. #include "stareditor.h"
  2. #include "starrating.h"
  4. #include <QtWidgets>
  6. StarEditor::StarEditor(QWidget* parent)
  7.     : QWidget(parent)
  8. {
  9.     // 启用鼠标跟踪
  10.     setMouseTracking(true);
  11.     // QWidget的自动填充背景特性
  12.     setAutoFillBackground(true);
  13. }
  15. // paint()用来绘制星星, 就像我们在实现StarDelegate时所做的那样
  16. void StarEditor::paintEvent(QPaintEvent*)
  17. {
  18.     QPainter painter(this);
  19.     myStarRating.paint(&painter, rect(), palette(),
  20.         StarRating::EditMode::Editable);
  21. }
  23. // 通过调用StarRating类的setStarCount()来反映当前光标的位置, 并调用QWidget::update()来强制重绘
  24. void StarEditor::mouseMoveEvent(QMouseEvent* event)
  25. {
  26.     const int star = starAtPosition(event->x());
  28.     if (star != myStarRating.starCount() && star != -1) {
  29.         myStarRating.setStarCount(star);
  30.         update();
  31.     }
  32.     QWidget::mouseMoveEvent(event);
  33. }
  35. // 当用户释放鼠标按钮时, 发出editingFinished()信号
  36. void StarEditor::mouseReleaseEvent(QMouseEvent* event)
  37. {
  38.     emit editingFinished();
  39.     QWidget::mouseReleaseEvent(event);
  40. }
  42. // starAtPosition()函数使用基本的线性代数来找出光标下的星星
  43. int StarEditor::starAtPosition(int x) const
  44. {
  45.     const int star = (x / (myStarRating.sizeHint().width() / myStarRating.maxStarCount())) + 1;
  46.     if (star <= 0 || star > myStarRating.maxStarCount())
  47.         return -1;
  49.     return star;
  50. }
  52. // 首选的大小刚好足够绘制最大数目的星星
  53. QSize StarEditor::sizeHint() const
  54. {
  55.     return myStarRating.sizeHint();
  56. }

starrating.h

  1. #ifndef STARRATING_H
  2. #define STARRATING_H
  4. #include <QPainter>
  5. #include <QPolygonF>
  6. #include <QSize>
  8. // StarRating类用一些星星表示一个评级, 保存数据与绘制星星
  9. class StarRating {
  10. public:
  11.     enum class EditMode { Editable,
  12.         ReadOnly };
  14.     explicit StarRating(int starCount = 1, int maxStarCount = 5);
  16.     void paint(QPainter* painter, const QRect& rect,
  17.         const QPalette& palette, EditMode mode) const;
  19.     QSize sizeHint() const;
  21.     int starCount() const { return myStarCount; }
  22.     int maxStarCount() const { return myMaxStarCount; }
  23.     void setStarCount(int starCount) { myStarCount = starCount; }
  24.     void setMaxStarCount(int maxStarCount) { myMaxStarCount = maxStarCount; }
  26. private:
  27.     QPolygonF starPolygon;
  28.     QPolygonF diamondPolygon;
  29.     // 存储当前评级
  30.     int myStarCount;
  31.     // 存储可能的最高评级(通常为5)
  32.     int myMaxStarCount;
  33. };
  35. // Q_DECLARE_METATYPE()宏使QVariant知道StarRating类型，使得在QVariant中存储StarRating值成为可能。
  36. Q_DECLARE_METATYPE(StarRating)
  38. #endif

starrating.cpp

  1. #include "starrating.h"
  3. #include <QtWidgets>
  4. #include <cmath>
  6. constexpr int PaintingScaleFactor = 20;
  8. // 构造函数初始化myStarCount和myMaxStarCount，并设置用于绘制星星和菱形的多边形:
  9. StarRating::StarRating(int starCount, int maxStarCount)
  10.     : myStarCount(starCount)
  11.     , myMaxStarCount(maxStarCount)
  12. {
  13.     starPolygon << QPointF(1.0, 0.5);
  14.     for (int i = 1; i < 5; ++i)
  15.         starPolygon << QPointF(0.5 + 0.5 * std::cos(0.8 * i * 3.14),
  16.             0.5 + 0.5 * std::sin(0.8 * i * 3.14));
  18.     diamondPolygon << QPointF(0.4, 0.5) << QPointF(0.5, 0.4)
  19.                    << QPointF(0.6, 0.5) << QPointF(0.5, 0.6)
  20.                    << QPointF(0.4, 0.5);
  21. }
  23. // 首选的大小刚好足够绘制最大数目的星星
  24. QSize StarRating::sizeHint() const
  25. {
  26.     return PaintingScaleFactor * QSize(myMaxStarCount, 1);
  27. }
  29. // paint()函数用于绘制绘制设备上StarRating对象中的星星
  30. void StarRating::paint(QPainter* painter, const QRect& rect,
  31.     const QPalette& palette, EditMode mode) const
  32. {
  33.     painter->save();
  35.     painter->setRenderHint(QPainter::Antialiasing, true);
  36.     painter->setPen(Qt::NoPen);
  37.     painter->setBrush(mode == EditMode::Editable ? palette.highlight() : palette.windowText());
  39.     const int yOffset = (rect.height() - PaintingScaleFactor) / 2;
  40.     painter->translate(rect.x(), rect.y() + yOffset);
  41.     painter->scale(PaintingScaleFactor, PaintingScaleFactor);
  43.     for (int i = 0; i < myMaxStarCount; ++i) {
  44.         if (i < myStarCount) {
  45.             painter->drawPolygon(starPolygon, Qt::WindingFill);
  46.         } else if (mode == EditMode::Editable) {
  47.             painter->drawPolygon(diamondPolygon, Qt::WindingFill);
  48.         }
  49.         painter->translate(1.0, 0.0);
  50.     }
  52.     painter->restore();
  53. }

main.cpp

  1. // star委托示例展示了如何创建一个可以自己绘制并支持编辑的委托。
  3. #include "stardelegate.h"
  4. #include "stareditor.h"
  5. #include "starrating.h"
  6. #include <QApplication>
  7. #include <QTableWidget>
  9. // 用数据填充QTableWidget
  10. void populateTableWidget(QTableWidget* tableWidget)
  11. {
  12.     static constexpr struct {
  13.         const char* title;
  14.         const char* genre;
  15.         const char* artist;
  16.         int rating;
  17.     } staticData[] = {
  18.         { "Mass in B-Minor", "Baroque", "J.S. Bach", 5 },
  19.         //! [1]
  20.         { "Three More Foxes", "Jazz", "Maynard Ferguson", 4 },
  21.         { "Sex Bomb", "Pop", "Tom Jones", 3 },
  22.         { "Barbie Girl", "Pop", "Aqua", 5 },
  23.         { nullptr, nullptr, nullptr, 0 }
  24.     };
  26.     for (int row = 0; staticData[row].title != nullptr; ++row) {
  27.         QTableWidgetItem* item0 = new QTableWidgetItem(staticData[row].title);
  28.         QTableWidgetItem* item1 = new QTableWidgetItem(staticData[row].genre);
  29.         QTableWidgetItem* item2 = new QTableWidgetItem(staticData[row].artist);
  30.         QTableWidgetItem* item3 = new QTableWidgetItem;
  31.         // 调用QVariant::fromValue将StarRating转换为QVariant
  32.         item3->setData(0, QVariant::fromValue(StarRating(staticData[row].rating)));
  34.         tableWidget->setItem(row, 0, item0);
  35.         tableWidget->setItem(row, 1, item1);
  36.         tableWidget->setItem(row, 2, item2);
  37.         tableWidget->setItem(row, 3, item3);
  38.     }
  39. }
  41. int main(int argc, char* argv[])
  42. {
  43.     QApplication app(argc, argv);
  45.     QTableWidget tableWidget(4, 4);
  46.     tableWidget.setItemDelegate(new StarDelegate);
  47.     tableWidget.setEditTriggers(QAbstractItemView::DoubleClicked
  48.         | QAbstractItemView::SelectedClicked);
  49.     tableWidget.setSelectionBehavior(QAbstractItemView::SelectRows);
  50.     tableWidget.setHorizontalHeaderLabels({ "Title", "Genre", "Artist", "Rating" });
  52.     populateTableWidget(&tableWidget);
  54.     tableWidget.resizeColumnsToContents();
  55.     tableWidget.resize(500, 300);
  56.     tableWidget.show();
  58.     return app.exec();
  59. }

七、示例结果

image.png