Qt 绘制电池

最新推荐文章于 2024-07-12 09:51:49 发布
最新推荐文章于 2024-07-12 09:51:49 发布
阅读量756 收藏 4
点赞数 2
分类专栏： Qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xpg4321/article/details/113938109
版权

实现如下功能：

 * 1. 可设置电池电量,动态切换电池电量变化
 * 2. 可设置电池电量警戒值
 * 3. 可设置电池电量正常颜色和报警颜色
 * 4. 可设置边框渐变颜色
 * 5. 可设置电量变化时每次移动的步长
 * 6. 可设置边框圆角角度/背景进度圆角角度/头部圆角角度
#ifndef BATTERY_H
#define BATTERY_H
#include <QWidget>

class Battery : 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 borderWidth READ getBorderWidth WRITE setBorderWidth)
    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)

public:
    explicit Battery(QWidget *parent = 0);
    ~Battery();

protected:
    void paintEvent(QPaintEvent *);
    void drawBorder(QPainter *painter);
    void drawBg(QPainter *painter);
    void drawHead(QPainter *painter);

private slots:
    void updateValue();

private:    
    double minValue;                //最小值
    double maxValue;                //最大值
    double value;                   //目标电量
    double alarmValue;              //电池电量警戒值

    double step;                    //每次移动的步长
    int borderWidth;                //边框粗细
    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;                  //绘制定时器

public:    
    double getMinValue()            const;
    double getMaxValue()            const;
    double getValue()               const;
    double getAlarmValue()          const;

    double getStep()                const;
    int getBorderWidth()            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;

public Q_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 setBorderWidth(int borderWidth);
    //设置边框圆角角度
    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);

Q_SIGNALS:
    void valueChanged(double value);
};

#endif // BATTERY_H

 

#pragma execution_character_set("utf-8")

#include "battery.h"
#include "qpainter.h"
#include "qtimer.h"
#include "qdebug.h"

Battery::Battery(QWidget *parent) : QWidget(parent)
{
    minValue = 0;
    maxValue = 100;
    value = 0;
    alarmValue = 30;
    step = 0.5;

    borderWidth = 5;
    borderRadius = 8;
    bgRadius = 5;
    headRadius = 3;

    borderColorStart = QColor(100, 100, 100);
    borderColorEnd = QColor(80, 80, 80);
    alarmColorStart = QColor(250, 118, 113);
    alarmColorEnd = QColor(204, 38, 38);
    normalColorStart = QColor(50, 205, 51);
    normalColorEnd = QColor(60, 179, 133);

    isForward = false;
    currentValue = 0;

    timer = new QTimer(this);
    timer->setInterval(10);
    connect(timer, SIGNAL(timeout()), this, SLOT(updateValue()));
}

Battery::~Battery()
{
    if (timer->isActive()) {
        timer->stop();
    }
}

void Battery::paintEvent(QPaintEvent *)
{
    //绘制准备工作,启用反锯齿
    QPainter painter(this);
    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);

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

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

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

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

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

    painter->restore();
}

void Battery::drawBg(QPainter *painter)
{
    if (value == minValue) {
        return;
    }

    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 + borderWidth, batteryRect.bottomRight().y() - margin);
    QRectF rect(topLeft, bottomRight);

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

    painter->restore();
}

void Battery::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();
}

void Battery::updateValue()
{
    if (isForward) {
        currentValue -= step;
        if (currentValue <= value) {
            timer->stop();
        }
    } else {
        currentValue += step;
        if (currentValue >= value) {
            timer->stop();
        }
    }

    this->update();
}

double Battery::getMinValue() const
{
    return this->minValue;
}

double Battery::getMaxValue() const
{
    return this->maxValue;
}

double Battery::getValue() const
{
    return this->value;
}

double Battery::getAlarmValue() const
{
    return this->alarmValue;
}

double Battery::getStep() const
{
    return this->step;
}

int Battery::getBorderWidth() const
{
    return this->borderWidth;
}

int Battery::getBorderRadius() const
{
    return this->borderRadius;
}

int Battery::getBgRadius() const
{
    return this->bgRadius;
}

int Battery::getHeadRadius() const
{
    return this->headRadius;
}

QColor Battery::getBorderColorStart() const
{
    return this->borderColorStart;
}

QColor Battery::getBorderColorEnd() const
{
    return this->borderColorEnd;
}

QColor Battery::getAlarmColorStart() const
{
    return this->alarmColorStart;
}

QColor Battery::getAlarmColorEnd() const
{
    return this->alarmColorEnd;
}

QColor Battery::getNormalColorStart() const
{
    return this->normalColorStart;
}

QColor Battery::getNormalColorEnd() const
{
    return this->normalColorEnd;
}

QSize Battery::sizeHint() const
{
    return QSize(150, 80);
}

QSize Battery::minimumSizeHint() const
{
    return QSize(30, 10);
}

void Battery::setRange(double minValue, double maxValue)
{
    //如果最小值大于或者等于最大值则不设置
    if (minValue >= maxValue) {
        return;
    }

    this->minValue = minValue;
    this->maxValue = maxValue;

    //如果目标值不在范围值内,则重新设置目标值
    //值小于最小值则取最小值,大于最大值则取最大值
    if (value < minValue) {
        setValue(minValue);
    } else if (value > maxValue) {
        setValue(maxValue);
    }

    this->update();
}

void Battery::setRange(int minValue, int maxValue)
{
    setRange((double)minValue, (double)maxValue);
}

void Battery::setMinValue(double minValue)
{
    setRange(minValue, maxValue);
}

void Battery::setMaxValue(double maxValue)
{
    setRange(minValue, maxValue);
}

void Battery::setValue(double value)
{
    //值和当前值一致则无需处理
    if (value == this->value) {
        return;
    }

    //值小于最小值则取最小值,大于最大值则取最大值
    if (value < minValue) {
        value = minValue;
    } else if (value > maxValue) {
        value = maxValue;
    }

    if (value > currentValue) {
        isForward = false;
    } else if (value < currentValue) {
        isForward = true;
    } else {
        this->value = value;
        this->update();
        return;
    }

    this->value = value;
    this->update();
    emit valueChanged(value);
    timer->stop();
    timer->start();
}

void Battery::setValue(int value)
{
    setValue((double)value);
}

void Battery::setAlarmValue(double alarmValue)
{
    if (this->alarmValue != alarmValue) {
        this->alarmValue = alarmValue;
        this->update();
    }
}

void Battery::setAlarmValue(int alarmValue)
{
    setAlarmValue((double)alarmValue);
}

void Battery::setStep(double step)
{
    if (this->step != step) {
        this->step = step;
        this->update();
    }
}

void Battery::setStep(int step)
{
    setStep((double)step);
}

void Battery::setBorderWidth(int borderWidth)
{
    if (this->borderWidth != borderWidth) {
        this->borderWidth = borderWidth;
        this->update();
    }
}

void Battery::setBorderRadius(int borderRadius)
{
    if (this->borderRadius != borderRadius) {
        this->borderRadius = borderRadius;
        this->update();
    }
}

void Battery::setBgRadius(int bgRadius)
{
    if (this->bgRadius != bgRadius) {
        this->bgRadius = bgRadius;
        this->update();
    }
}

void Battery::setHeadRadius(int headRadius)
{
    if (this->headRadius != headRadius) {
        this->headRadius = headRadius;
        this->update();
    }
}

void Battery::setBorderColorStart(const QColor &borderColorStart)
{
    if (this->borderColorStart != borderColorStart) {
        this->borderColorStart = borderColorStart;
        this->update();
    }
}

void Battery::setBorderColorEnd(const QColor &borderColorEnd)
{
    if (this->borderColorEnd != borderColorEnd) {
        this->borderColorEnd = borderColorEnd;
        this->update();
    }
}

void Battery::setAlarmColorStart(const QColor &alarmColorStart)
{
    if (this->alarmColorStart != alarmColorStart) {
        this->alarmColorStart = alarmColorStart;
        this->update();
    }
}

void Battery::setAlarmColorEnd(const QColor &alarmColorEnd)
{
    if (this->alarmColorEnd != alarmColorEnd) {
        this->alarmColorEnd = alarmColorEnd;
        this->update();
    }
}

void Battery::setNormalColorStart(const QColor &normalColorStart)
{
    if (this->normalColorStart != normalColorStart) {
        this->normalColorStart = normalColorStart;
        this->update();
    }
}

void Battery::setNormalColorEnd(const QColor &normalColorEnd)
{
    if (this->normalColorEnd != normalColorEnd) {
        this->normalColorEnd = normalColorEnd;
        this->update();
    }
}

效果图:

很菜但努力
关注
专栏目录
基于QT的电池电量显示控件
06-06
一个基于QT编写的电池电量显示控件，带有圆角矩形和可动态显示充电过程的控件
qt电池控件设计
weixin_42887343的博客
02-22 1727
效果 h文件（battery.h） #ifndef BATTERY_H #define BATTERY_H /** * 电池电量控件 * 1. 可设置电池电量,动态切换电池电量变化 * 2. 可设置电池电量警戒值 * 3. 可设置电池电量正常颜色和报警颜色 * 4. 可设置边框渐变颜色 * 5. 可设置电量变化时每次移动的步长 * 6. 可设置边框圆角角度/背景进度圆角角度/头部圆角角度 */ #include <QWidget> class Battery : publ
qt实现电池电量显示-一个简单的实用小工具
u012959478的博客
07-12 1040
本文介绍了如何在Qt应用中使用Batterywidget类创建自定义电池显示控件，包括基本用法、功能API（如设置电量、状态、颜色等）以及如何在QtDesigner中配置。通过示例代码展示了具体实现。
Qt Widget 之电池控件(QPainter)
火山上的企鹅
09-12 3343
文章目录二、关键信息1. 驱动输入2. 绘制过程三、完整代码 GitHub 地址:     QWidgetPro ，选择子工程 Battery QT 其它文章请点击这里:     QT QUICK QML 学习笔记 # 一、效果 本文采用 QPainter 来绘制电池控件，顺便很适合用来初学 **QT Widget** 主要参考了飞扬青云大神的 Qt开源作品25-电池电量控件 ，相比之下， 此文更加适合新手学习
Qt绘制的电池电量显示小Demo
10-28
qt绘制的简单的电池控件，电量低于阈值时显示电量为红色，大于阈值设置电量为绿色，阈值可设置，简单Demo
Qt绘制电池进度条（paintEvent）
Q泥T挖的博客
03-22 1933
做了一个电池的进度条，加了警示色和正常色的判断，还加了一些动画效果，分享一下，适合初学者，开发环境是Qt5.14.2+MSVC2017。想看源码的可以直接滑到最后有源码链接。
QT自定义绘制电池效果demo
10-27
本示例“QT自定义绘制电池效果demo”聚焦于使用QT的paintEvent方法来实现一个电池电量显示的可视化效果。这个过程涉及到多个关键知识点，包括事件处理、绘图API的使用以及状态管理。 首先，`paintEvent`是QT中的一...
Qt绘制自定义数字电压表
10-28
在这个案例中，我们将重点关注Qt的Painter模块，它是Qt进行2D图形绘制的核心工具。 首先，让我们了解电压表的基本原理。电压表是一种测量电路中电压的设备，通常具有一定的量程和分辨率。在这个项目中，我们关注的...
Qt绘制电池UI
qq_44896246的博客
02-05 499
QT绘制电池UI
QT自定义控件--电池
贝勒里恩的博客
05-16 1300
文章目录一、效果展示二、绘制过程2.1、控件分析2.2、原理详解2.3、绘制框体2.4、绘制电量2.3、其余代码 一、效果展示 二、绘制过程 2.1、控件分析 电池控件主要由电池框体和电量组成，电池会根据电量的高低改变电量的表示颜色，由此可以将任务分为三部分：绘制电池框体、绘制电量、实现电量增减表示 2.2、原理详解 电量表示是在电池框体绘制了一个填充了颜色的圆角矩形框体。如果把电量分为100份，可以设置一个power变量，取值为0-100，然后电量表示的圆角矩形框体在绘制时，宽度参考power变量就可以
Qt代码动态电池
06-13
qt纯代码写的电池程序
Qt获取并显示电池电量和WIFI信号强度
04-05
Qt获取并显示电池电量和WIFI信号强度，在win7下可用，其他平台未试，详见我的博客http://blog.csdn.net/caoshangpa/article/details/51062351
基于QT的电池电量
06-06
基于QT的电池电量，类3D效果的电池电量显示，用户可根据自己选择去控制电量大小
Qt自定义电池控件
weixin_43820764的博客
04-30 527
Qt用久了，总觉得自带的UI不够用，正好在网上找到了个自定义控件很厉害的大佬，留个痕迹。 https://www.cnblogs.com/feiyangqingyun/category/1296367.html
QT自定义控件----电池
TT的博客
08-25 435
网上参考一些代码修改了一个电池控件 #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编写自定义控件电池
亦轩的专栏
12-15 717
核心代码来自 feiyangqingyun大神链接：https://blog.csdn.net/feiyangqingyun/article/details/98586038 这边主要加上大神感觉特别简单没有贴出来的代码，并修改成四格类型的电池，同时参考书籍《Qt 5.9 C++开发指南》 致敬大神们 #ifndef QMYBATTERY_H #define QMYBATT...
QtWidget绘制电池控件
Thinking777的博客
01-26 912
使用QPainter来进行绘制自定义的控件，然后通过QTimer来实现电池控件的电量变化效果，效果图如下：
Qt Windows 7（Win7）下获取并显示电池电量和WIFI信号强度
草上爬的博客
04-05 9624
实际上是在Qt里调用Windows库函数实现的，需在头文件中包含“windows.h”和“wlanapi.h”，wlanapi库用于处理无线相关信息，在.pro文件中还需引用wlanapi.lib。 1.获取并显示电池电量 void Widget::showBattery() { SYSTEM_POWER_STATUS systemPowerSatus; GetSystemPo
qt绘制五分之一圆弧
最新发布
07-24
QT是一个跨平台的应用程序开发框架，它允许开发者创建丰富的用户界面和复杂的图形处理应用。要在QT中绘制五分之一圆弧，你可以利用`QPainter`类及其提供的绘图功能。 以下是一个简化的步骤来帮助你在QT中绘制五分之一圆弧： ### 步骤 1: 设置画布 首先，在你的QWidget或其他支持绘制的对象内部设置一个`QPainter`对象。通常，你会通过调用`paintEvent`槽函数或直接在特定位置调用`drawArc`等方法来实现这一目标。 ```cpp void YourWidget::paintEvent(QPaintEvent *) { QPainter painter(this); // 其他画笔和背景色设置... } ``` ### 步骤 2: 绘制五分之一圆弧 QT中绘制圆弧的基本语法如下： ```cpp painter.drawArc(rectX, rectY, width, height, startAngle, spanAngle) ``` 其中： - `rectX`, `rectY`: 圆弧所在的矩形区域的左上角坐标； - `width`, `height`: 矩形区域的宽度和高度； - `startAngle`: 圆弧开始的角度（从0度开始计算），单位为十进制度数； - `spanAngle`: 圆弧覆盖的角度长度（同样以十进制度数表示）； 为了绘制五分之一圆弧，你需要指定开始角度、结束角度以及对应的跨度角度。 由于我们需要绘制五分之一圆弧，我们可以假设起点为(90度)开始，并选择适当的角度跨度使得总角度接近于180度（即半个圆）。例如，如果我们要绘制从45度到135度的部分，可以这样做： ```cpp // 假设宽高等于半径 * 2，因此我们只需要指定半径即可 int radius = 50; // 半径 int centerX = rectX + radius; int centerY = rectY + radius; // 开始角度为45度 int startAngle = 45; // 覆盖的角度长度为90度（半个圆弧的一半） int spanAngle = 90; painter.setPen(Qt::blue); // 设置线条颜色 painter.drawArc(centerX - radius, centerY - radius, 2*radius, 2*radius, startAngle * 16, spanAngle * 16); ``` 注意，角度转换为QT中的十六进制角度表示需要乘以16，因为QT内部使用的是一种基于字节的度量系统。 ### 相关问题: 1. **如何调整圆弧的颜色和宽度**? 可以通过设置`painter.setPen()`的参数来调整颜色和宽度，如： ```cpp painter.setPen(QPen(Qt::red, 2)); // 设置红色线条，宽度为2像素 ``` 2. **能否添加阴影效果到圆弧**? 对于简单的阴影效果，可以使用渐变填充配合`painter.setBrush()`方法。然而，要添加更复杂的效果，比如模糊阴影，可能需要使用OpenGL或者第三方库。 3. **在动态大小的窗口中保持圆弧的比例不变**? 当窗口大小改变时，保持圆弧相对于其容器大小的比例不变可以通过在事件处理器中获取当前窗口尺寸并相应地调整圆心坐标和边界进行计算。例如： ```cpp int newRadius = std::min(width(), height()) / 2; // 新的半径为较小边长的一半 int newX = width() / 2; int newY = height() / 2; // 使用新中心点和新的半径值来计算圆弧 ``` 这提供了一个基本的框架和指导原则用于在QT应用程序中绘制五分之一圆弧。通过这种方式，你可以进一步自定义和优化你的圆形绘制需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值