Qt编写自定义控件电池

最新推荐文章于 2024-06-29 10:40:03 发布
最新推荐文章于 2024-06-29 10:40:03 发布
阅读量713 收藏 10
点赞数
文章标签： qt 绘制 电池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang112031/article/details/103549691
版权

核心代码来自   feiyangqingyun 大神链接：https://blog.csdn.net/feiyangqingyun/article/details/98586038

这边主要加上大神感觉特别简单没有贴出来的代码，并修改成四格类型的电池，同时参考书籍《Qt 5.9 C++开发指南》

致敬大神们

 

#ifndef QMYBATTERY_H
#define QMYBATTERY_H

#include <QWidget>
#include <QColor>
#include <QTimer>
#include <QFont>

class QmyBattery : public QWidget
{
    Q_OBJECT

    Q_PROPERTY(double minValue READ getMinValue WRITE setMinValue)
    Q_PROPERTY(double maxValue READ getMaxValue WRITE setMaxValue)
    Q_PROPERTY(double value READ getValue WRITE setValue)
    Q_PROPERTY(double alarmValue READ getAlarmValue WRITE setAlarmValue)

    Q_PROPERTY(double step READ getStep WRITE setStep)
    Q_PROPERTY(int borderRadius READ getBorderRadius WRITE setBorderRadius)
    Q_PROPERTY(int bgRadius READ getBgRadius WRITE setBgRadius)
    Q_PROPERTY(int headRadius READ getHeadRadius WRITE setHeadRadius)

    Q_PROPERTY(QColor borderColorStart READ getBorderColorStart WRITE setBorderColorStart)
    Q_PROPERTY(QColor borderColorEnd READ getBorderColorEnd WRITE setBorderColorEnd)

    Q_PROPERTY(QColor alarmColorStart READ getAlarmColorStart WRITE setAlarmColorStart)
    Q_PROPERTY(QColor alarmColorEnd READ getAlarmColorEnd WRITE setAlarmColorEnd)

    Q_PROPERTY(QColor normalColorStart READ getNormalColorStart WRITE setNormalColorStart)
    Q_PROPERTY(QColor normalColorEnd READ getNormalColorEnd WRITE setNormalColorEnd)

    Q_PROPERTY(QFont textFont READ gettextFont WRITE settextFont)
    Q_PROPERTY(QColor textColor READ gettextColor WRITE settextColor)
public:
    explicit QmyBattery(QWidget *parent = nullptr);
protected:
    void paintEvent(QPaintEvent *);
    void drawBorder(QPainter *painter);
    void drawBg(QPainter *painter);
    void drawHead(QPainter *painter);
    void drawtext(QPainter *painter);
    void drawCharge(QPainter *painter);
    void drawInit();
private slots:
    void updateValue();
private:
    double minValue;                //最小值
    double maxValue;                //最大值
    double value;                   //目标电量
    double alarmValue;              //电池电量警戒值

    double step;                    //每次移动的步长
    int borderRadius;               //边框圆角角度
    int bgRadius;                   //背景进度圆角角度
    int headRadius;                 //头部圆角角度

    QColor borderColorStart;        //边框渐变开始颜色
    QColor borderColorEnd;          //边框渐变结束颜色

    QColor alarmColorStart;         //电池低电量时的渐变开始颜色
    QColor alarmColorEnd;           //电池低电量时的渐变结束颜色

    QColor normalColorStart;        //电池正常电量时的渐变开始颜色
    QColor normalColorEnd;          //电池正常电量时的渐变结束颜色

    bool isForward;                 //是否往前移
    double currentValue;            //当前电量
    QRectF batteryRect;             //电池主体区域
    QTimer *timer;                  //绘制定时器

    bool Charging;
    QFont textFont;
    QColor textColor;
public:
    double getMinValue()            const;
    double getMaxValue()            const;
    double getValue()               const;
    double getAlarmValue()          const;

    double getStep()                const;
    int getBorderRadius()           const;
    int getBgRadius()               const;
    int getHeadRadius()             const;

    QColor getBorderColorStart()    const;
    QColor getBorderColorEnd()      const;

    QColor getAlarmColorStart()     const;
    QColor getAlarmColorEnd()       const;

    QColor getNormalColorStart()    const;
    QColor getNormalColorEnd()      const;

    QSize sizeHint()                const;
    QSize minimumSizeHint()         const;

    QFont gettextFont()const;
    QColor gettextColor()const;
signals:
    void valueChanged(double value);
public slots:
    //设置范围值
    void setRange(double minValue, double maxValue);
    void setRange(int minValue, int maxValue);

    //设置最大最小值
    void setMinValue(double minValue);
    void setMaxValue(double maxValue);

    //设置电池电量值
    void setValue(double value);
    void setValue(int value);

    //设置电池电量警戒值
    void setAlarmValue(double alarmValue);
    void setAlarmValue(int alarmValue);

    //设置步长
    void setStep(double step);
    void setStep(int step);

    //设置边框圆角角度
    void setBorderRadius(int borderRadius);
    //设置背景圆角角度
    void setBgRadius(int bgRadius);
    //设置头部圆角角度
    void setHeadRadius(int headRadius);

    //设置边框渐变颜色
    void setBorderColorStart(const QColor &borderColorStart);
    void setBorderColorEnd(const QColor &borderColorEnd);

    //设置电池电量报警时的渐变颜色
    void setAlarmColorStart(const QColor &alarmColorStart);
    void setAlarmColorEnd(const QColor &alarmColorEnd);

    //设置电池电量正常时的渐变颜色
    void setNormalColorStart(const QColor &normalColorStart);
    void setNormalColorEnd(const QColor &normalColorEnd);

    void setCharging(bool value);
    // 设置百分比字体
   void settextFont(const QFont &textFont);
   void settextColor(const QColor &textColor);
};

#endif // QMYBATTERY_H

#include "qmybattery.h"
#include <QPainter>
#include <QDebug>
QmyBattery::QmyBattery(QWidget *parent) : QWidget(parent)
{
    drawInit();
}
void QmyBattery::drawInit()
{
    minValue = 0.0;
    maxValue = 100.0;
    value = 0.0;                   //目标电量
    alarmValue = 30.0;              //电池电量警戒值

    step = 0.5;                    //每次移动的步长
    borderRadius = 8;               //边框圆角角度
    bgRadius = 5;                   //背景进度圆角角度
    headRadius = 3;                 //头部圆角角度

    borderColorStart =QColor(100,100,100,255);  //边框渐变开始颜色
    borderColorEnd = QColor(80,80,80,255);    //边框渐变结束颜色

    alarmColorStart = QColor(250,118,113,255);  //电池低电量时的渐变开始颜色
    alarmColorEnd = QColor(204,38,38,255);    //电池低电量时的渐变结束颜色

    normalColorStart = QColor(50,205,51,255);  //电池正常电量时的渐变开始颜色
    normalColorEnd = QColor(60,179,133,255);   //电池正常电量时的渐变结束颜色

    isForward = 0;                 //是否往前移
    currentValue = 0.0;            //当前电量
    Charging = false;
    isForward = true;
}
void QmyBattery::drawtext(QPainter *painter)
{
    painter->save();

    QFontMetrics  textSize(this->font());
    int ipow= qRound(currentValue/(maxValue - minValue)*100);
    if(ipow > 100)
    {
        ipow = 100;
    }
    else if(ipow < 0)
    {
        ipow = 0;
    }
    QString powStr =QString::number(ipow) + '%';
    //qDebug()<<"powStr:"<<powStr << currentValue << maxValue - minValue<<currentValue/(maxValue - minValue)*100;
    QRect textRect=textSize.boundingRect(powStr);//得到字符串的rect

    painter->setFont(textFont);
    painter->setPen(textColor);
    //qDebug()<<textRect.width()<< textRect.height();
    //qDebug()<<batteryRect.width()<< batteryRect.height();
    painter->drawText(batteryRect.width()/2 - textRect.width()/2,
               batteryRect.height()/2 + textRect.height(),
               powStr);
    painter->restore();
}
void QmyBattery::drawCharge(QPainter *painter)
{
    if(Charging == false)
        return;

    painter->save();
    //定义6个点
    static const QPointF points[6] = {
        QPointF(batteryRect.width() -batteryRect.width()/20, batteryRect.height()/10*2),
        QPointF(batteryRect.width()-batteryRect.width()/20*3, batteryRect.height()/10*5),
        QPointF(batteryRect.width()-batteryRect.width()/10, batteryRect.height()/10*5),
        QPointF(batteryRect.width()-batteryRect.width()/10, batteryRect.height()/10*8),
        QPointF(batteryRect.width()-batteryRect.width()/40, batteryRect.height()/10*4),
        QPointF(batteryRect.width()-batteryRect.width()/20, batteryRect.height()/10*4),
    };
    painter->drawPolygon(points, 6);
    painter->restore();
}
void QmyBattery::paintEvent(QPaintEvent *)
{
    //绘制准备工作,启用反锯齿
    QPainter painter(this);
    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);

    //绘制边框
    drawBorder(&painter);
    //绘制背景
    drawBg(&painter);
    //绘制头部
    drawHead(&painter);

    drawtext(&painter);

    //drawCharge(&painter);
}

void QmyBattery::drawBorder(QPainter *painter)
{
    painter->save();

    double headWidth = width() / 10;
    double batteryWidth = width() - headWidth;

    //绘制电池边框
    QPointF topLeft(5, 5);
    QPointF bottomRight(batteryWidth, height() - 5);
    batteryRect = QRectF(topLeft, bottomRight);

    painter->setPen(QPen(borderColorStart, 5));
    painter->setBrush(Qt::NoBrush);
    painter->drawRoundedRect(batteryRect, borderRadius, borderRadius);

    painter->restore();
}

//void QmyBattery::drawBg(QPainter *painter)
//{
//    painter->save();

//    QLinearGradient batteryGradient(QPointF(0, 0), QPointF(0, height()));
//    if (currentValue <= alarmValue) {
//        batteryGradient.setColorAt(0.0, alarmColorStart);
//        batteryGradient.setColorAt(1.0, alarmColorEnd);
//    } else {
//        batteryGradient.setColorAt(0.0, normalColorStart);
//        batteryGradient.setColorAt(1.0, normalColorEnd);
//    }

//    int margin = qMin(width(), height()) / 20;
//    double unit = (batteryRect.width() - (margin * 2)) / 100;
//    double width = currentValue * unit;
//    QPointF topLeft(batteryRect.topLeft().x() + margin, batteryRect.topLeft().y() + margin);
//    QPointF bottomRight(width + margin + 5, batteryRect.bottomRight().y() - margin);
//    QRectF rect(topLeft, bottomRight);

//    painter->setPen(Qt::NoPen);
//    painter->setBrush(batteryGradient);
//    painter->drawRoundedRect(rect, bgRadius, bgRadius);

//    painter->restore();
//}
void QmyBattery::drawBg(QPainter *painter)
{
    painter->save();

    QLinearGradient batteryGradient(QPointF(0, 0), QPointF(0, height()));
    int margin = qMin(width(), height()) / 20;
    double unit = (batteryRect.width() - (margin * 2)) / 100;
    double width25 = 23 * unit;

    if (currentValue > 75)
    {
        batteryGradient.setColorAt(0.0, normalColorStart);
        batteryGradient.setColorAt(1.0, normalColorEnd);

        QPointF topLeft(batteryRect.topLeft().x() + margin + 3*width25 + 3*margin, batteryRect.topLeft().y() + margin);
        QPointF bottomRight(4 * (width25 + margin), batteryRect.bottomRight().y() - margin);
        QRectF rect(topLeft, bottomRight);

        painter->setPen(Qt::NoPen);
        painter->setBrush(batteryGradient);
        painter->drawRoundedRect(rect, bgRadius, bgRadius);

    }
    if (currentValue > 50)
    {
        batteryGradient.setColorAt(0.0, normalColorStart);
        batteryGradient.setColorAt(1.0, normalColorEnd);

        QPointF topLeft(batteryRect.topLeft().x() + margin + 2*width25 + 2*margin, batteryRect.topLeft().y() + margin);
        QPointF bottomRight(3*(width25 + margin), batteryRect.bottomRight().y() - margin);
        QRectF rect(topLeft, bottomRight);

        painter->setPen(Qt::NoPen);
        painter->setBrush(batteryGradient);
        painter->drawRoundedRect(rect, bgRadius, bgRadius);
    }
    if (currentValue > 25)
    {
        batteryGradient.setColorAt(0.0, normalColorStart);
        batteryGradient.setColorAt(1.0, normalColorEnd);

        QPointF topLeft(batteryRect.topLeft().x() + margin + width25 + margin , batteryRect.topLeft().y() + margin);
        QPointF bottomRight(2*(width25 + margin), batteryRect.bottomRight().y() - margin);
        QRectF rect(topLeft, bottomRight);

        painter->setPen(Qt::NoPen);
        painter->setBrush(batteryGradient);
        painter->drawRoundedRect(rect, bgRadius, bgRadius);
    }
    if (currentValue >= 0)
    {
        if(currentValue > 25)
        {
            batteryGradient.setColorAt(0.0, normalColorStart);
            batteryGradient.setColorAt(1.0, normalColorEnd);
        }
        else {
            batteryGradient.setColorAt(0.0, alarmColorStart);
            batteryGradient.setColorAt(1.0, alarmColorEnd);
        }


        QPointF topLeft(batteryRect.topLeft().x() + margin+1, batteryRect.topLeft().y() + margin);
        QPointF bottomRight(width25 + margin, batteryRect.bottomRight().y() - margin);
        QRectF rect(topLeft, bottomRight);

        painter->setPen(Qt::NoPen);
        painter->setBrush(batteryGradient);
        painter->drawRoundedRect(rect, bgRadius, bgRadius);
    }


    painter->restore();
}
void QmyBattery::drawHead(QPainter *painter)
{
    painter->save();

    QPointF headRectTopLeft(batteryRect.topRight().x(), height() / 3);
    QPointF headRectBottomRight(width(), height() - height() / 3);
    QRectF headRect(headRectTopLeft, headRectBottomRight);

    QLinearGradient headRectGradient(headRect.topLeft(), headRect.bottomLeft());
    headRectGradient.setColorAt(0.0, borderColorStart);
    headRectGradient.setColorAt(1.0, borderColorEnd);

    painter->setPen(Qt::NoPen);
    painter->setBrush(headRectGradient);
    painter->drawRoundedRect(headRect, headRadius, headRadius);

    painter->restore();
}
double QmyBattery::getMinValue()const
{
    return minValue;
}
double QmyBattery::getMaxValue()const
{
    return maxValue;
}
double QmyBattery::getValue()const
{
    return currentValue;
}
double QmyBattery::getAlarmValue()const
{
    return alarmValue;
}
double QmyBattery::getStep()const
{
    return step;
}
int QmyBattery::getBorderRadius()const
{
    return borderRadius;
}
int QmyBattery::getBgRadius()const
{
    return bgRadius;
}
int QmyBattery::getHeadRadius()const
{
    return headRadius;
}
QColor QmyBattery::getBorderColorStart()const
{
    return borderColorStart;
}
QColor QmyBattery::getBorderColorEnd()const
{
    return borderColorEnd;
}
QColor QmyBattery::getAlarmColorStart()const
{
    return alarmColorStart;
}
QColor QmyBattery::getAlarmColorEnd()const
{
    return alarmColorEnd;
}
QColor QmyBattery::getNormalColorStart()const
{
    return normalColorStart;
}
QColor QmyBattery::getNormalColorEnd()const
{
    return normalColorEnd;
}
QSize QmyBattery::sizeHint()const
{
    int H=this->height();
    int W=this->width();
    QSize   size(W,H);
    return size;
}
QSize QmyBattery::minimumSizeHint()const
{
    int H=this->height();
    int W=this->width();
    QSize   size(W,H);
    return size;
}
//设置范围值
void QmyBattery::setRange(double minValue, double maxValue)
{
    this->minValue = minValue;
    this->maxValue = maxValue;
}
void QmyBattery::setRange(int minValue, int maxValue)
{
    this->minValue = minValue;
    this->maxValue = maxValue;
}

//设置最大最小值
void QmyBattery::setMinValue(double minValue)
{
    this->minValue = minValue;
}
void QmyBattery::setMaxValue(double maxValue)
{
    this->maxValue = maxValue;
}

//设置电池电量值
void QmyBattery::setValue(double value)
{
    this->value = value;
    if(isForward == false)
    {
        currentValue = value;
        update();
    }
    else
    {
        update();
        QTimer::singleShot(10, this, SLOT(updateValue()));
    }
}
void QmyBattery::setValue(int value)
{
    this->value = value;
    if(isForward == false)
    {
        currentValue = value;
        update();
    }
    else
    {
        update();
        QTimer::singleShot(10, this, SLOT(updateValue()));
    }
}

//设置电池电量警戒值
void QmyBattery::setAlarmValue(double alarmValue)
{
    this->alarmValue = alarmValue;
}
void QmyBattery::setAlarmValue(int alarmValue)
{
    this->alarmValue = alarmValue;
}

//设置步长
void QmyBattery::setStep(double step)
{
    this->step = step;
}
void QmyBattery::setStep(int step)
{
    this->step = step;
}

//设置边框圆角角度
void QmyBattery::setBorderRadius(int borderRadius)
{
    this->borderRadius = borderRadius;
    update();
}
//设置背景圆角角度
void QmyBattery::setBgRadius(int bgRadius)
{
    this->bgRadius = bgRadius;
    update();
}
//设置头部圆角角度
void QmyBattery::setHeadRadius(int headRadius)
{
    this->headRadius = headRadius;
    update();
}

//设置边框渐变颜色
void QmyBattery::setBorderColorStart(const QColor &borderColorStart)
{
    this->borderColorStart = borderColorStart;
    update();
}
void QmyBattery::setBorderColorEnd(const QColor &borderColorEnd)
{
    this->borderColorEnd = borderColorEnd;
    update();
}

//设置电池电量报警时的渐变颜色
void QmyBattery::setAlarmColorStart(const QColor &alarmColorStart)
{
    this->alarmColorStart = alarmColorStart;
    update();
}
void QmyBattery::setAlarmColorEnd(const QColor &alarmColorEnd)
{
    this->alarmColorEnd = alarmColorEnd;
    update();
}

//设置电池电量正常时的渐变颜色
void QmyBattery::setNormalColorStart(const QColor &normalColorStart)
{
    this->normalColorStart = normalColorStart;
    update();
}
void QmyBattery::setNormalColorEnd(const QColor &normalColorEnd)
{
    this->normalColorEnd = normalColorEnd;
    update();
}
void QmyBattery::setCharging(bool value)
{
    this->Charging = value;
    update();
}
QFont QmyBattery::gettextFont()const
{
    return this->textFont;
}
void QmyBattery::settextFont(const QFont &textFont)
{
    this->textFont = textFont;
    update();
}
QColor QmyBattery::gettextColor()const
{
    return textColor;
}
void QmyBattery::settextColor(const QColor &textColor)
{
    this->textColor = textColor;
    update();
}
void QmyBattery::updateValue()
{
    if(value >= currentValue + step)
    {
        currentValue += step;
        update();
        QTimer::singleShot(10, this, SLOT(updateValue()));
    }
    else if(value <= currentValue - step)
    {
         currentValue -= step;
         update();
         QTimer::singleShot(10, this, SLOT(updateValue()));
    }
}

代码下载地址：https://download.csdn.net/download/wang112031/12033697

Qt/C++编写自定义控件43-自绘电池
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
08-06 2142
一、前言 到了9102年了，现在智能手机不要太流行，满大街都是，甚至连爷爷奶奶级别的人都会用智能手机，本次要写的控件就是智能手机中的电池电量表示控件，采用纯painter绘制，其实也可以采用贴图，我估计大部分手机上的都是采用贴图的形式，贴图有个好处就是程序员不用操心，drawimage即可，速度非常快。 至于本控件没有任何技术难点，就是自动计算当前设置的电量，根据宽度的比例划分100个等分，每个等...
QT自定义电池控件
萧海的博客
01-16 469
效果： #ifndef BATTERYWIDGET_H #define BATTERYWIDGET_H #include <QWidget> #include<QPainter> class BatteryWidget : public QWidget { Q_OBJECT public: explicit BatteryWidget(QWidget *parent = nullptr); int powerValue() const; void
Qt Widget 之电池控件(QPainter)
火山上的企鹅
09-12 3328
文章目录二、关键信息1. 驱动输入2. 绘制过程三、完整代码 GitHub 地址:     QWidgetPro ，选择子工程 Battery QT 其它文章请点击这里:     QT QUICK QML 学习笔记 # 一、效果 本文采用 QPainter 来绘制电池控件，顺便很适合用来初学 **QT Widget** 主要参考了飞扬青云大神的 Qt开源作品25-电池电量控件 ，相比之下， 此文更加适合新手学习
深入了解Qt 控件：Display Widgets部件(1) 以及 QT自定义控件(电池）
最新发布
宁静致远的博客
06-29 410
做一个电池控件，需要一个拖动条和一个进度条。不多说，直接上代码.h文件Q_OBJECTpublic:~Widget();private:.cpp文件//将拖动条设置为横向//设置拖动条范围//设置样式//拖动条每次值改变都会执行if(m_batteryBar->value()
Qt自定义电池控件
weixin_43820764的博客
04-30 525
Qt用久了，总觉得自带的UI不够用，正好在网上找到了个自定义控件很厉害的大佬，留个痕迹。 https://www.cnblogs.com/feiyangqingyun/category/1296367.html
Qt自定义控件之Battery电池控件
m0_62599305的博客
04-04 653
在Qt应用程序开发中，自定义控件是一种常见的需求，开发者经常需要根据特定的需求创建定制化的控件来增强用户界面的交互性和美观性。Battery电池控件是一种常见的自定义控件，用于显示设备的电池状态。通过Battery控件，用户可以直观地了解设备电量情况，提高用户体验和操作便利性。Battery电池控件作为Qt自定义控件的一种，为开发者提供了一种简单而有效的方法来集成电池状态显示功能到他们的应用程序中。通过Battery控件，开发者可以轻松地展示设备的电量信息，为用户提供更好的使用体验。
Qt编写的自定义控件属性设计器
03-26
### Qt编写的自定义控件属性设计器 #### 概述 在进行图形用户界面（GUI）开发时，自定义控件及其属性管理是一项常见的需求。特别是在工业自动化与控制领域，为了适应特定的应用场景，如仪表盘设计、状态监控界面等...
QT添加自定义控件
02-03
### QT添加自定义控件 #### 一、引言 在使用QT进行界面设计时，开发者往往会遇到标准控件库无法完全满足特定需求的情况。此时，实现自定义控件成为解决问题的有效途径之一。本文旨在详细介绍如何在QT环境中快速...
Qt自定义控件库.rar
01-15
10. 测试和调试：编写自定义控件后，需要进行充分的测试，确保在不同环境和配置下的行为都符合预期。利用Qt的调试工具，如`qDebug()`和`qInfo()`，可以帮助找出潜在的问题。 总的来说，Qt自定义控件库提供了丰富的...
Qt 自定义 Calendar 日历控件
07-31
在Qt框架中，自定义控件是开发人员为了满足特定需求而创建的用户界面元素。在本场景中，我们关注的是“Qt自定义Calendar日历控件”。这涉及到使用Qt库中的QCalendarWidget或者完全从头构建一个自定义的日历组件。...
Qt -自定义插件-电池插件
04-08
Qt -自定义插件。 具体可看博客了解：https://blog.csdn.net/automoblie0/article/details/105399584
Qt代码动态电池
06-13
qt纯代码写的电池程序
基于QT的电池电量显示控件
06-06
一个基于QT编写的电池电量显示控件，带有圆角矩形和可动态显示充电过程的控件
qt自定义控件（开源）
07-04
#QtCustomWidgets 说明格式如下: 项目名称 编译环境 运行截图 注意事项 #ColorProgressBar 多彩进度条 编译环境: Qt5.x + mingw-QtCreater 运行截图: progressbarcolor为原版代码 #DynamicProgressBar 多态进度条 编译环境: Qt5.x + mingw-QtCreater 运行截图: #RoundProgressBar 编译环境: Qt5.x + mingw-QtCreater 运行截图: #SlideNavigation 滑动导航条 编译环境: Qt5.x + mingw-QtCreater 运行截图: #SlideNavigationApp 滑动导航界面 编译环境: Qt5.x + mingw-QtCreater 运行截图: 注意事项: 此工程需要用到SlideNavigation这个工程中的2个文件slidenavigation.h和slidenavigation.cpp文件,不知道在如何引用,知道的希望留言帮助下 #RotateCircle 旋转的圆 编译环境: Qt5.x + mingw-QtCreater 运行截图: #ImageViewer 旋转的圆 编译环境: Qt5.x + mingw-QtCreater 运行截图: #CurveChart 简单曲线图 编译环境: Qt5.x + mingw-QtCreater 运行截图:
qt电池控件设计
weixin_42887343的博客
02-22 1714
效果 h文件（battery.h） #ifndef BATTERY_H #define BATTERY_H /** * 电池电量控件 * 1. 可设置电池电量,动态切换电池电量变化 * 2. 可设置电池电量警戒值 * 3. 可设置电池电量正常颜色和报警颜色 * 4. 可设置边框渐变颜色 * 5. 可设置电量变化时每次移动的步长 * 6. 可设置边框圆角角度/背景进度圆角角度/头部圆角角度 */ #include <QWidget> class Battery : publ
Qt：定制电池控件
炸酱面和他的博客们
06-07 578
闲来无聊做的电量显示小控件，提供了基本的实现思路，具体电池控件的接口和配色可以根据自己需要进行调整。
QT自定义控件----电池
TT的博客
08-25 432
网上参考一些代码修改了一个电池控件 #ifndef BATTERY_H #define BATTERY_H #include <qframe.h> #include <stdint.h> class Battery : public QFrame { Q_OBJECT public: Battery(QWidget *parent = nullptr); QColor PenColor; QColor BkColor; QColo
Qt进阶-绘制一个电池
羽士的博客
06-29 632
说明： MyBattery类继承自QWidget，在界面添加一个widget控件，提升为MyBattery类，将滑动条的valueChanged事件与sls_setValue()槽绑定。 borderWidth = 5; //边框宽度 borderRadius = 5; //边框倒角 currentValue = 0; //当前电量 alarmValue = 30; //电池电量警戒值 bgRadius = 5; //背景电量倒角 alarmColo
Qt 编写自定义控件
08-23
在 Qt 中编写自定义控件可以让你更好地满足应用程序的需求。下面是一个简单的步骤指南来帮助你开始编写自定义控件： 1. 创建一个新的类：使用继承的方式创建一个新的类，继承自 Qt 的基础控件类，如 QWidget、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值