Qt 自定义Checkbox和QColorDialog 颜色调试框委托

最新推荐文章于 2024-05-27 10:20:48 发布
最新推荐文章于 2024-05-27 10:20:48 发布
阅读量1k 收藏 1
点赞数
分类专栏： QT 文章标签： Qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010505080/article/details/119254027
版权
该代码实现了一个基于Qt的表格视图代理`TableDelegate`，允许用户在表格中直接编辑颜色和可见性。代理创建了颜色对话框和复选框编辑器，并处理相应的编辑事件。`TableModel`类提供了数据模型，包含通道名称、颜色和可见性信息。此外，`Widget`类展示了如何将模型和代理应用于表格视图。
摘要由CSDN通过智能技术生成 
#ifndef TABLEDELEGATE_H
#define TABLEDELEGATE_H

#include <QStyledItemDelegate>

class TableDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    explicit TableDelegate(QObject *parent = nullptr);
    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const;
    void setEditorData(QWidget *editor, const QModelIndex &index) const;
    void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const;

    void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
    void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const;
    bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index);
};

#endif // TABLEDELEGATE_H

#include "tabledelegate.h"

#include <QPainter>
#include <QColorDialog>
#include "tablemodel.h"
#include <QDebug>
#include <QCheckBox>
#include <QApplication>
#include <QMouseEvent>

TableDelegate::TableDelegate(QObject *parent) : QStyledItemDelegate(parent)
{

}

QWidget *TableDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                                     const QModelIndex &index) const
{
    if (index.column() == TableModel::Color)
    {
        QColorDialog *editor = new QColorDialog(parent);
        return editor;
    }
//    else if (index.column() == TableModel::Visible)
//    {
//        QCheckBox *editor = new QCheckBox(parent);
//        return editor;
//    }

    return QStyledItemDelegate::createEditor(parent, option, index);
}

void TableDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
    if (index.column() == TableModel::Color)
    {
         QColorDialog *dlg =  qobject_cast<QColorDialog *>(editor);
        if (dlg)
        {
            const QVariant color = index.model()->data(index);
            dlg->setCurrentColor(color.value<QColor>());
        }
    }
//    else if (index.column() == TableModel::Visible)
//    {
//        QCheckBox *checkbox  =  qobject_cast<QCheckBox *>(editor);
//        if(checkbox)
//        {
//            const bool visible = index.model()->data(index).toBool();
//            checkbox->setChecked(visible);
//        }
//    }
    else
    {
        QStyledItemDelegate::setEditorData(editor, index);
    }
}

void TableDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
    if (index.column() == TableModel::Color)
    {
        QColorDialog *dlg =  qobject_cast<QColorDialog *>(editor);
       if (dlg)
       {
           model->setData(index,dlg->currentColor());
       }
    }
//    else if (index.column() == TableModel::Visible)
//    {
//        QCheckBox *checkbox  =  qobject_cast<QCheckBox *>(editor);
//        if(checkbox)
//        {
//            model->setData(index,checkbox->checkState());
//        }
//    }
    else
    {
        QStyledItemDelegate::setModelData(editor, model, index);
    }
}

void TableDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    QStyleOptionViewItem viewOption(option);
       initStyleOption(&viewOption, index);
       if (option.state.testFlag(QStyle::State_HasFocus))
           viewOption.state = viewOption.state ^ QStyle::State_HasFocus;


    if (index.column() == TableModel::Color)
    {
        painter->save();
        const QVariant value = index.model()->data(index);
        QColor color = value.value<QColor>();
        QRect rect(option.rect);
        painter->fillRect(rect, color);
//        QPen pen;
//        pen.setColor(color);
//        pen.setWidth(3);
//        pen.setStyle(Qt::SolidLine);
//        painter->setPen(pen);
//        painter->drawLine(QPoint(rect.x(), rect.y() + rect.height()/2), QPoint(rect.x() + rect.width(),rect.y()+ rect.height()/2));
        painter->restore();
    }
    else if (index.column() == TableModel::Visible)
      {
          bool data = index.model()->data(index, Qt::EditRole).toBool();

          QStyleOptionButton checkBoxStyle;
          checkBoxStyle.state = data ? QStyle::State_On : QStyle::State_Off;
          checkBoxStyle.state |= QStyle::State_Enabled;
          checkBoxStyle.iconSize = QSize(20, 20);
          checkBoxStyle.rect = option.rect;

          QCheckBox checkBox;
          checkBoxStyle.iconSize = QSize(20, 20);
          checkBoxStyle.rect = option.rect;
          QApplication::style()->drawPrimitive(QStyle::PE_IndicatorCheckBox, &checkBoxStyle, painter, &checkBox);
    }
    else
    {
        QStyledItemDelegate::paint(painter, option, index);
    }
}



bool TableDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)
{
    QRect decorationRect = option.rect;

    QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
    if (event->type() == QEvent::MouseButtonPress && decorationRect.contains(mouseEvent->pos()))
    {
        if (index.column() == TableModel::Visible)
        {
            bool data = model->data(index, Qt::EditRole).toBool();
            model->setData(index, !data, Qt::EditRole);
            return true;
        }
    }

    return QStyledItemDelegate::editorEvent(event, model, option, index);
}

void TableDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
                                         const QModelIndex &index) const
{
    Q_UNUSED(index)
    editor->setGeometry(option.rect);
}

model 

#include "tablemodel.h"
#include <QDebug>
#include <QColor>

#define CHANNEL_NUM 1024

const std::vector<QColor> g_vetPenColor =
{
    QColor(0, 0, 0),     QColor(202,235,216),    QColor(128,118,105),
    QColor(255,235,205), QColor(255,245,238),    QColor(255,0,0),
    QColor(227,23,13),   QColor(255,127,80),     QColor(255,192,203),
    QColor(116,0,0),     QColor(255,255,0),      QColor(227,207,87),
    QColor(255,125,64),  QColor(255,227,132),    QColor(85,102,0),
    QColor(0,255,0),     QColor(128,42,42),      QColor(0,255,255),
    QColor(199,97,20),   QColor(127,255,0),      QColor(210,180,140),
    QColor(8,46,84),     QColor(188,143,143),    QColor(34,139,34),
    QColor(107,142,35),  QColor(199,97,20),      QColor(0,0,255),
    QColor(160,32,240),  QColor(218,112,214),    QColor(25,25,112),
    QColor(138,43,226),  QColor(153,51,250)
};


TableModel::TableModel(QObject *parent) : QAbstractTableModel(parent)
{
   m_vetIsVisible.resize(CHANNEL_NUM);
   m_vetCurvesColor.resize(CHANNEL_NUM);
   m_vetChannelNme.resize(CHANNEL_NUM);

   for(int ch = 0; ch < CHANNEL_NUM; ++ch)
   {
       m_vetIsVisible[ch] = true;
       m_vetCurvesColor[ch] = g_vetPenColor[ch%32];
       m_vetChannelNme[ch] =QString("CH %1").arg(ch+1);
   }
}

Qt::ItemFlags TableModel::flags(const QModelIndex &index) const
{
    if (index.column() == Channel)
    {
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
    }
    else if(index.column() == Color)
    {
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
    }
    else if(index.column() == Visible)
    {
        return Qt::NoItemFlags;
    }


    return QAbstractTableModel::flags(index);
}

int TableModel::rowCount(const QModelIndex &parent) const
{
    return parent.isValid() ? 0 : m_vetChannelNme.size();
}

int TableModel::columnCount(const QModelIndex &parent) const
{
    return parent.isValid() ? 0 : Count;
}

QVariant TableModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid() || index.row() < 0 || index.row() >= m_vetChannelNme.size())
    {
        return QVariant();
    }

    switch (role)
    {
    case Qt::DisplayRole:
    case Qt::EditRole:
        if (index.column() == Channel)
        {
            return  m_vetChannelNme[index.row()];
        }
        else if (index.column() == Visible)
        {
            return m_vetIsVisible[index.row()];
        }
        else if (index.column() == Color)
        {
            return m_vetCurvesColor[index.row()];
        }
        break;
    }

    return QVariant();
}

QVariant TableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        switch (section)
        {
        case Channel:
            return "Channel";
        case Visible:
            return "Visible";
        case Color:
            return "Color";
        }
    }

    return QAbstractTableModel::headerData(section, orientation, role);
}

bool TableModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid() || index.row() < 0 || index.row() >= m_vetChannelNme.size())
    {
        return false;
    }

    switch (role)
    {
    case Qt::DisplayRole:
    case Qt::EditRole:
        if (index.column() == Channel)
        {
            m_vetChannelNme[index.row()] = value.toString();
        }
        else if (index.column() == Visible)
        {
            m_vetIsVisible[index.row()] = value.toBool();
        }
        else if (index.column() == Color)
        {
            m_vetCurvesColor[index.row()] = value.value<QColor>();
        }
        emit dataChanged(index, index);
        return true;
    }

    return false;
}


#ifndef TABLEMODEL_H
#define TABLEMODEL_H

#include <QAbstractTableModel>

class TableModel : public QAbstractTableModel
{
    Q_OBJECT
public:
    enum Columns { Channel = 0, Visible, Color, Count = Color + 1 };

    explicit TableModel(QObject *parent = nullptr);

    Qt::ItemFlags flags(const QModelIndex &index) const;
    int rowCount(const QModelIndex &parent = QModelIndex()) const;
    int columnCount(const QModelIndex &parent = QModelIndex()) const;

    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::DisplayRole);

private:
    std::vector<bool> m_vetIsVisible;
    std::vector<QColor> m_vetCurvesColor;
    std::vector<QString> m_vetChannelNme;

};

#endif // TABLEMODEL_H

widget

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "tablemodel.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private:
    Ui::Widget *ui;

private:
    TableModel *tableModel;
};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"

#include "tabledelegate.h"
#include <QDebug>


Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    tableModel = new TableModel();  // Model
    ui->tableView->setModel(tableModel);    // View
    ui->tableView->setItemDelegate(new TableDelegate);  // Delegate

//    QString checkQss =   "QCheckBox::indicator { width: 20px;height: 20px;}"
//                         "QCheckBox::indicator::unchecked {image: url(:/img/res/checkun.png);}"
//                         "QCheckBox::indicator::checked {image: url(:/img/res/check.png);}";

    ui->tableView->horizontalHeader()->setStretchLastSection(true);

}

Widget::~Widget()
{
    delete ui;
}

mian

#include "widget.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();
    return a.exec();
}

使用MVD模式，目的是自定义颜色选择框

源码下载

https://download.csdn.net/download/u010505080/20658452

寒沙细细入江流
关注
专栏目录
【QT开发】颜色选择对话框QColorDialog类详解及实战应用
科技改变人类，技术成就未来
07-06 1349
QColorDialog是Qt提供的一个功能强大且灵活的颜色选择对话框类，通过本篇文章的学习，你应该对QColorDialog有了全面的理解，能够在自己的项目中正确使用它。QColorDialog在用户界面中帮助你更好地管理颜色选择，实现交互式和响应式的应用程序，有助于创建用户友好和高效的图形编辑器、文本编辑器、界面主题设置等应用场景。
Qt自定义ColorDialog(支持RGB和HSV)
不会飞的纸飞机的博客
02-08 5567
文章目录1. HSV和RGB2. H分量圆盘绘制3. SV画布绘制 当我们做软件开发的时候，经常需要编辑颜色，有时需要同时编辑RGB和HSV的颜色。 这是一个自定义的颜色对话框，如下图所示 具有如下功能： 支持RGB和HSV颜色值得修改和预览 支持添加自定义颜色（点击按钮添加或鼠标拖拽添加） 修改颜色效果预览： 添加自定义颜色效果预览： 颜色控件效果预览： 下面是主要用到得技术点说...
Qt自定义的ColorDialog--仿QColorDialog
slowlytalk
05-27 1397
这样设置之后，按照预想应该是正常的，没想到的是，运行起来之后，直接堆栈溢出了。因为设置之后，其他的也改变了value，改变了就会发信号，发了信号我们就又设置了，设置了就又发信号，所以就一直在这样的循环中重复了起来。刚开始时，确实有种无处下手的感觉，后来突然想想，当你不会的时候，如果手边刚好有现成的差不多的东西，不仿去抄一抄，所以，我就看了下。设置颜色值的时候需要进行一次转换，因为这个HSV空间的最大值是359和255，所以要根据界面的大小转换成在HSV空间对应的数值。的背景色为对应的渐变色。
Qt自定义颜色对话框QColorDialog
2301_80974269的博客
04-05 438
（直接在头文件中实现函数，这样是为了方便移植和浏览）Q_OBJECTpublic:protected:// 在这里完成编辑的逻辑} else {Q_OBJECTpublic:// 遍历图像的每个像素x++) {y++) {// 遍历图像的每个像素x++) {y++) {//由h更改导致sv区域全部重绘//备份修改前的图片//备份修改前的图片private:int width;int height;
Qt自定义控件之颜色对话框QColorDialog/Qt Color Widgets
$firecat利白的代码足迹$
04-30 7396
1、官方自带 Qt官方自带的QColorDialog类提供了一个指定颜色的对话框部件。#include <QColorDialog> 2、自定义 但是好多开源项目都使用了自定义控件Qt Color Widgets。 https://gitlab.com/mattia.basaglia/Qt-Color-Widgets https://github.c.........
QT中级（2）QTableView自定义委托（二）实现QProgressBar委托
02-05
我们在之前写的[《QT(7)-初识委托》](https://blog.csdn.net/qq_40666149/article/details/128674837)文章末尾提到，***“使用一个类继承QStyledItemDelegate实现常用的控件委托，在使用时可以直接调用接口，灵活...
用WPF自定义CheckBox的样式(框框和钩钩)
10-28
在默认情况下，CheckBox有一个矩形框和一个勾选标记，但我们可以根据需求自定义其样式，以实现独特的视觉效果。本篇文章将深入探讨如何在WPF中自定义CheckBox的样式，特别是改变它的框框和勾钩。 首先，我们需要...
Android开发之自定义CheckBox
09-01
本文将详细介绍如何自定义一个CheckBox，包括处理`wrap_content`问题和实现动画效果。 首先，从描述中我们可以知道，我们要创建一个自定义的CheckBox，它可能具有特殊的视觉效果或交互方式。通常，CheckBox是通过...
qtableview 自定义委托 checkbox，进度条、时间等控件
05-04
这个自定义委托的概念在标题和描述中被提及，意味着我们将探讨如何在QTableView中添加复选框、进度条和时间等控件。 自定义委托是Qt提供的一种机制，允许开发人员为表格视图中的每一项数据创建个性化的显示和编辑...
Qt之QColorDialog
Shijia Yin
03-31 4921
简述 QColorDialog提供了一个对话框用于选择颜色。 静态函数getColor()可以用于展示出对话框允许用户指定一个颜色。通过指定额外的选项参数ShowAlphaChannel，可以让用户在选择颜色的同时选择透明度。 通过点击"Pick Screen Color"，用户可以拾取程序窗口内的颜色。 使用 效果 源码 构造函数 colorDialog = new QColorD...
Qt中的QColorDialog
木子皿--啥都不会的菜鸟
03-03 888
文章目录1 Qt中的QColorDialog 1 Qt中的QColorDialog 颜色对话框： Qt中提供了预定义的颜色对话框QColorDialog类。 QColorDialog类用于提供指定颜色的对话框部件。 颜色对话框的使用方式： Qt中的颜色表示： Qt中的Qcolor类用来在程序中表示颜色的概念。 QColor类同时支持多种颜色表示方式： RGB：以红、绿、蓝为基准的三色模...
Qt 颜色对话框 QColorDialog
超级大洋葱的博客
12-10 1144
#include <QColorDialog> // 颜色对话框 void MyWidget::on_pushButton_clicked() { // QColor color = QColorDialog::getColor(Qt::red, this, tr("颜色对话框"), // QColorDialog::ShowAlphaChannel); QColorDialog di
QT修改QCheckBox控件选项框的颜色
最新发布
qq_46117468的博客
05-27 879
请注意，这种方法可能会影响到QCheckBox的所有状态下的边框颜色，如果你想要针对不同的状态设置不同的边框颜色，你可能需要为每种状态定义不同的伪元素，例如QCheckBox::indicator:checked、QCheckBox::indicator:disabled等。QCheckBox::indicator是一个伪元素，表示QCheckBox的选中标记（也就是勾选框）。border属性用于设置边框的样式，1px solid #0000FF表示边框宽度为1像素，样式为实线，颜色为蓝色。
PyQt5_QColorDialog_颜色选择对话框
瓜地考拉
02-10 1599
PyQt5 的颜色选择对话框，主要包括 构造函数，打开对话框，颜色选择，选项设置，静态方法。 # # QColorDialog # 颜色选择对话框 # from PyQt5.Qt import * class MyWindow(QWidget): def __init__(self): super().__init__() s...
QT的QColorDialog类的使用
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-04 880
详细说明 QColorDialog类提供了一个用于指定颜色的对话框小部件。 颜色对话框的功能是允许用户选择颜色。例如，您可以在绘图程序中使用它来允许用户设置笔刷颜色。 静态函数提供模态颜色对话框。 静态getColor（）函数显示对话框，并允许用户指定颜色。此函数还可以用于让用户选择具有一定透明度的颜色：将ShowAlphaChannel选项作为附加参数传递。 用户可以存储customCount（）不同的自定义颜色。自定义颜色由所有颜色对话框共享，并在程序执行期间被记住。使用setCustomColor（）
QtCreator 对话框（一）QColorDialog,QFileDialog,QFontDialog,QInputDialog
psujtfc的专栏
07-15 1761
1.颜色对话框
设置qt的qcheckbox内部选择框颜色
weixin_39235202的博客
05-16 2572
”);
QT 颜色选择器 QColorDialog 使用
zcc的博客
06-01 3936
需求：点击修改按钮 弹出 颜色选择框，确定后 给 label 设置背景色 打印： 代码：
Android自定义CheckBox实现与动画优化教程
首先，自定义Checkbox的步骤通常涉及创建一个继承自`View`的新类，而不是直接使用系统提供的`CheckBox`，因为这样可以更好地控制布局和样式。尽管`CompoundButton`类实现了`Checkable`接口，提供了复选状态的管理，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值