静态仪表盘Qt Creator代码

最新推荐文章于 2024-08-14 13:53:45 发布
最新推荐文章于 2024-08-14 13:53:45 发布
阅读量153 收藏 1
点赞数 1
文章标签： qt
原文链接：https://zhuanlan.zhihu.com/p/63062099
版权

如何画仪表盘，https://zhuanlan.zhihu.com/p/63062099

知乎大佬已经分享动态代码，我在此把静态代码附上，复制粘贴就可以在Qt Creator上使用

静态效果如图：
在这里插入图片描述
widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QPainter>
#include <QColor>
#include <QtMath>
#include <QPainterPath>
#include <QDebug>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT
    Q_ENUMS(PieStyle)
    Q_ENUMS(PointerStyle)

    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(int precision READ getPrecision WRITE setPrecision)

    Q_PROPERTY(int scaleMajor READ getScaleMajor WRITE setScaleMajor)
    Q_PROPERTY(int scaleMinor READ getScaleMinor WRITE setScaleMinor)
    Q_PROPERTY(int startAngle READ getStartAngle WRITE setStartAngle)
    Q_PROPERTY(int endAngle READ getEndAngle WRITE setEndAngle)

    Q_PROPERTY(double piePercentStart READ getPiePercentStart WRITE setPiePercentStart)
    Q_PROPERTY(double piePercentMid READ getPiePercentMid WRITE setPiePercentMid)
    Q_PROPERTY(double piePercentEnd READ getPiePercentEnd WRITE setPiePercentEnd)

    Q_PROPERTY(QColor outerCircleColor READ getOuterCircleColor WRITE setOuterCircleColor)
    Q_PROPERTY(QColor innerCircleColor READ getInnerCircleColor WRITE setInnerCircleColor)

    Q_PROPERTY(QColor pieColorStart READ getPieColorStart WRITE setPieColorStart)
    Q_PROPERTY(QColor pieColorMid READ getPieColorMid WRITE setPieColorMid)
    Q_PROPERTY(QColor pieColorEnd READ getPieColorEnd WRITE setPieColorEnd)

    Q_PROPERTY(QColor coverCircleColor READ getCoverCircleColor WRITE setCoverCircleColor)
    Q_PROPERTY(QColor scaleColor READ getScaleColor WRITE setScaleColor)
    Q_PROPERTY(QColor pointerColor READ getPointerColor WRITE setPointerColor)
    Q_PROPERTY(QColor centerCircleColor READ getCenterCircleColor WRITE setCenterCircleColor)
    Q_PROPERTY(QColor textColor READ getTextColor WRITE setTextColor)

    Q_PROPERTY(bool showOverlay READ getShowOverlay WRITE setShowOverlay)
    Q_PROPERTY(QColor overlayColor READ getOverlayColor WRITE setOverlayColor)

    Q_PROPERTY(int circleWidth READ getCircleWidth WRITE setCircleWidth)
    Q_PROPERTY(PieStyle pieStyle READ getPieStyle WRITE setPieStyle)
    Q_PROPERTY(PointerStyle pointerStyle READ getPointerStyle WRITE setPointerStyle)

public:
    enum PieStyle
    {
        PieStyle_Three = 0,         	//三色圆环
        PieStyle_Current = 1        	//当前圆环
    };

    enum PointerStyle
    {
        PointerStyle_Circle = 0,        //圆形指示器
        PointerStyle_Indicator = 1,     //指针指示器
        PointerStyle_IndicatorR = 2,    //圆角指针指示器
        PointerStyle_Triangle = 3       //三角形指示器
    };


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

protected:
    void paintEvent(QPaintEvent *);
    void drawOuterCircle(QPainter *painter);//外圆
    void drawInnerCircle(QPainter *painter);//内圆
    void drawColorPie(QPainter *painter);//饼圆
    void drawCoverCircle(QPainter *painter);
    void drawScale(QPainter *painter);
    void drawScaleNum(QPainter *painter);
    void drawPointerCircle(QPainter *painter);
    void drawPointerIndicator(QPainter *painter);
    void drawPointerIndicatorR(QPainter *painter);
    void drawPointerTriangle(QPainter *painter);
    void drawRoundCircle(QPainter *painter);
    void drawCenterCircle(QPainter *painter);
    void drawValue(QPainter *painter);
    void drawOverlay(QPainter *painter);



private:
    Ui::Widget *ui;

    double minValue;//最小值
    double maxValue;//最大值
    double value;//目标值
    int precision;//精确度，小数点后几位

    int scaleMajor;//大刻度数量
    int scaleMinor;//小刻度数量
    int startAngle;//开始旋转角度
    int endAngle;  //结束旋转角度

    double piePercentStart;//饼圆开始占比
    double piePercentMid;//饼圆中间占比
    double piePercentEnd;//饼圆结束占比

    QColor outerCircleColor;//外圆背景颜色
    QColor innerCircleColor;//内圆背景颜色

    QColor pieColorStart;//饼圆开始颜色
    QColor pieColorMid;  //饼圆中间颜色
    QColor pieColorEnd;  //饼圆结束颜色

    QColor coverCircleColor;//覆盖圆背景颜色
    QColor scaleColor;  //刻度尺颜色
    QColor pointerColor;//指针颜色
    QColor centerCircleColor;//中心圆颜色
    QColor textColor;//文字颜色

    bool showOverlay;//显示遮罩层
    QColor overlayColor;//遮罩层颜色

    int circleWidth;//中间饼宽度
    PieStyle pieStyle;//饼图样式
    PointerStyle pointerStyle;//指针样式

    bool reverse;//是否往回走
    double currentValue;//当前值
    QTime *timer;//定时器绘制动画

public:
    //默认尺寸和尺寸最小值
    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    //设置范围值
    void setRange(double minValue,double maxValue);
    void setRange(int minValue,int maxValue);

    //获取和设置最小值
    double getMinValue() const;
    void setMinValue(double minValue);

    //获取和设置最大值
    double getMaxValue() const;
    void setMaxValue(double maxValue);

    //获取和设置当前值
    double getValue() const;
    void setValue(double value);

    //获取和设置精确度
    int getPrecision() const;
    void setPrecision(int precision);

    //获取和设置主刻度数量
    int getScaleMajor() const;
    void setScaleMajor(int scaleMajor);

    //获取和设置小刻度数量
    int getScaleMinor() const;
    void setScaleMinor(int scaleMinor);

    //获取和设置开始旋转按钮
    int getStartAngle() const;
    void setStartAngle(int startAngle);

    //获取和设置结束旋转按钮
    int getEndAngle() const;
    void setEndAngle(int endAngle);

    //获取和设置开始饼圆占比
    double getPiePercentStart() const;
    void setPiePercentStart(double piePercentStart);

    //获取和设置中间饼圆占比
    double getPiePercentMid() const;
    void setPiePercentMid(double piePercentMid);

    //获取和设置结束饼圆占比
    double getPiePercentEnd() const;
    void setPiePercentEnd(double piePercentEnd);

    //获取和设置外圆背景颜色
    QColor getOuterCircleColor() const;
    void setOuterCircleColor(const QColor &outerCircleColor);

    //获取和设置内圆背景颜色
    QColor getInnerCircleColor() const;
    void setInnerCircleColor(const QColor &innerCircleColor);

    //获取和设置开始饼圆颜色
    QColor getPieColorStart() const;
    void setPieColorStart(const QColor &pieColorStart);

    //获取和设置中间饼圆颜色
    QColor getPieColorMid() const;
    void setPieColorMid(const QColor &pieColorMid);

    //获取和设置结束饼圆颜色
    QColor getPieColorEnd() const;
    void setPieColorEnd(const QColor &pieColorEnd);

    //获取和设置覆盖圆背景颜色
    bool getAnimation() const;
    void setAnimation(bool animation);

    //获取和设置动画显示的步长
    double getAnimationStep() const;
    void setAnimationStep(double animationStep);

    //获取和设置文本颜色
    QColor getTextColor() const;
    void setTextColor(const QColor &textColor);

    //获取和设置是否显示遮罩层
    bool getShowOverlay() const;
    void setShowOverlay(bool showOverlay);

    //获取和设置遮罩层颜色
    QColor getOverlayColor() const;
    void setOverlayColor(const QColor &overlayColor);

    //获取和设置中间圆宽度
    int getCircleWidth() const;
    void setCircleWidth(int circleWidth);

    //获取和设置中心圆颜色
    QColor getCoverCircleColor() const;
    void setCoverCircleColor(const QColor &coverCircleColor);

    //获取和设置刻度尺颜色
    QColor getScaleColor() const;
    void setScaleColor(const QColor &scaleColor);

    //获取和设置指针颜色
    QColor getPointerColor() const;
    void setPointerColor(const QColor &pointerColor);

    //获取和设置中心圆颜色
    QColor getCenterCircleColor() const;
    void setCenterCircleColor(const QColor &centerCircleColor);

    //获取和设置饼图样式
    PieStyle getPieStyle() const;
    void setPieStyle(const PieStyle &pieStyle);

    //获取和设置指针样式
    PointerStyle getPointerStyle() const;
    void setPointerStyle(const PointerStyle &pointerStyle);

Q_SIGNALS:
    void valueChanged(int value);

public Q_SLOT:
    void setValue(int value);


};
#endif // WIDGET_H

main.cpp

#include "widget.h"

#include <QApplication>
#include <QTextCodec>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QFont font;
    font.setFamily("Microsoft Yahei");
    font.setPixelSize(13);
    a.setFont(font);
#if(QT_VERSION < QT_VERSION_CHECK(5,0,0))
#if _MSC_VER
    QTextCodec *codec = QTextCodec::codecForName("gbk");
#else
    QTextCodec *codec = QTextCodec::codecForName("utf-8");
#endif
    QTextCodec::setCodecForLocale(codec);
    QTextCodec::setCodecForCString(codec);
    QTextCodec::setCodecDForTr(codec);
#else
    QTextCodec *codec = QTextCodec::codecForName("utf-8");
    QTextCodec::setCodecForLocale(codec);
#endif

    Widget w;
    w.setWindowTitle("仪表盘");
    w.show();
    return a.exec();
}

widget.cpp

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

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

    minValue = 0;//刻度线最小值
    maxValue = 100;
    value = 50;//没有起到作用
    precision = 0;//刻度线上标的数字的小数点

    scaleMajor = 10;
    scaleMinor = 10;
    startAngle = 45;
    endAngle = 45;

    piePercentStart = 0.7;
    piePercentMid = 0.15;
    piePercentEnd = 0.15;

    outerCircleColor = QColor(80,80,80);
    innerCircleColor = QColor(60,60,60);

    pieColorStart = QColor(24,189,155);
    pieColorMid = QColor(218,218,155);
    pieColorEnd = QColor(255,107,107);

    coverCircleColor = QColor(100,100,100);
    scaleColor = QColor(255,255,255);
    pointerColor= QColor(255,107,107);
    centerCircleColor = QColor(250,250,250);
    textColor = QColor(0,0,0);

    showOverlay = true;
    overlayColor = QColor(255,255,255,60);

    circleWidth = 15;
    pieStyle =PieStyle_Three;
    pointerStyle = PointerStyle_Indicator;

    currentValue = 34;

    QFont font;
    font.setFamily("Arial");
    font.setPixelSize(11);
    setFont(font);
}

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

void Widget::paintEvent(QPaintEvent *)
{
    int width = this->width();
    int height = this->height();
    int side = qMin(width,height);

    QPainter painter(this);
    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
    painter.translate(width / 2, height / 2);
    painter.scale(side / 200.0, side / 200.0);

    drawOuterCircle(&painter);//绘制外圆
    drawInnerCircle(&painter);//绘制内圆
    drawColorPie(&painter);//绘制饼圆
    drawCoverCircle(&painter);//绘制覆盖圆，用以遮挡饼圆多余部分
    drawScale(&painter);//绘制刻度线
    drawScaleNum(&painter);//绘制刻度值


    //根据指示器形状绘制指示器
    if (pointerStyle == PointerStyle_Circle)
    {
        drawPointerCircle(&painter);
    }
    else if (pointerStyle == PointerStyle_Indicator)
    {
        drawPointerIndicator(&painter);
    }
    else if (pointerStyle == PointerStyle_IndicatorR)
    {
        drawPointerIndicatorR(&painter);
    }
    else if (pointerStyle == PointerStyle_Triangle)
    {
        drawPointerTriangle(&painter);
    }

    //绘制指针中心圆外边框
    drawRoundCircle(&painter);
    //绘制指针中心圆
    drawCenterCircle(&painter);
    //绘制当前值
    drawValue(&painter);
    //绘制遮罩层
    drawOverlay(&painter);


}

void Widget::drawOuterCircle(QPainter *painter)
{
    int radius = 99;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setBrush(outerCircleColor);//
    painter->drawEllipse(-radius, -radius, radius * 2, radius * 2);
    painter->restore();

}


void Widget::drawInnerCircle(QPainter *painter)
{
    int radius = 90;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setPen(innerCircleColor);//
    painter->drawEllipse(-radius, -radius, radius * 2, radius * 2);
    painter->restore();
}


void Widget::drawColorPie(QPainter *painter)
{
    int radius = 60;
    painter->save();
    painter->setPen(Qt::NoPen);

    QRectF rect(-radius, -radius, radius * 2, radius * 2);

    if (pieStyle == PieStyle_Three)
    {
        //计算总范围角度,根据占比例自动计算三色圆环范围角度
        //可以更改比例
        double angleAll = 360.0 - startAngle - endAngle;
        double angleStart = angleAll * 0.7;//饼圆的0.7
        double angleMid = angleAll * 0.15; //饼圆的0.15
        double angleEnd = angleAll * 0.15; //饼圆的0.15

        //增加偏移量使得看起来没有脱节
        int offset = 3;

        //绘制开始饼圆
        painter->setBrush(pieColorStart);
        painter->drawPie(rect, (270 - startAngle - angleStart) * 16, angleStart * 16);

        //绘制中间饼圆
        painter->setBrush(pieColorMid);
        painter->drawPie(rect, (270 - startAngle - angleStart - angleMid) * 16 + offset, angleMid * 16);

        //绘制结束饼圆
        painter->setBrush(pieColorEnd);
        painter->drawPie(rect, (270 - startAngle - angleStart - angleMid - angleEnd) * 16 + offset * 2, angleEnd * 16);
     }
     else if (pieStyle == PieStyle_Current)
     {
        //计算总范围角度,当前值范围角度,剩余值范围角度
        double angleAll = 360.0 - startAngle - endAngle;
        double angleCurrent = angleAll * ((currentValue - minValue) / (maxValue - minValue));
        double angleOther = angleAll - angleCurrent;

        //绘制当前值饼圆
        painter->setBrush(pieColorStart);
         painter->drawPie(rect, (270 - startAngle - angleCurrent) * 16, angleCurrent * 16);

        //绘制剩余值饼圆
        painter->setBrush(pieColorEnd);
        painter->drawPie(rect, (270 - startAngle - angleCurrent - angleOther) * 16, angleOther * 16);
     }
    painter->restore();
}

void Widget::drawCoverCircle(QPainter *painter)
{
    int radius = 50;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setBrush(coverCircleColor);
    painter->drawEllipse(-radius, -radius, radius * 2, radius * 2);
    painter->restore();
}

void Widget::drawScale(QPainter *painter)
{
    int radius = 72;
        painter->save();

        painter->rotate(startAngle);
        int steps = (scaleMajor * scaleMinor);
        double angleStep = (360.0 - startAngle - endAngle) / steps;

        QPen pen;
        pen.setColor(scaleColor);
        pen.setCapStyle(Qt::RoundCap);

        for (int i = 0; i <= steps; ++i) {
            if (i % scaleMinor == 0) {
                pen.setWidthF(1.5);
                painter->setPen(pen);
                painter->drawLine(0, radius - 10, 0, radius);
            } else {
                pen.setWidthF(0.5);
                painter->setPen(pen);
                painter->drawLine(0, radius - 5, 0, radius);
            }

            painter->rotate(angleStep);
        }

        painter->restore();
}

void Widget::drawScaleNum(QPainter *painter)
{
    int radius = 82;
       painter->save();
       painter->setPen(scaleColor);

       double startRad = (360 - startAngle - 90) * (M_PI / 180);
       double deltaRad = (360 - startAngle - endAngle) * (M_PI / 180) / scaleMajor;

       for (int i = 0; i <= scaleMajor; i++) {
           double sina = qSin(startRad - i * deltaRad);
           double cosa = qCos(startRad - i * deltaRad);
           double value = 1.0 * i * ((maxValue - minValue) / scaleMajor) + minValue;

           QString text = QString("%1").arg((double)value, 0, 'f', precision);
#if(QT_VERSION >= QT_VERSION_CHECK(5,11,0))
           double textWidth = fontMetrics().horizontalAdvance(text);
#else
           double textWidth = fontMetrics().width(text);
#endif
           double textHeight = fontMetrics().height();
           int x = radius * cosa - textWidth / 2;
           int y = -radius * sina + textHeight / 4;
           painter->drawText(x, y, text);
       }

       painter->restore();
}

void Widget::drawPointerCircle(QPainter *painter)
{
    int radius = 6;
    int offset = 30;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setBrush(pointerColor);

    painter->rotate(startAngle);
    double degRotate = (360.0 - startAngle - endAngle) / (maxValue - minValue) * (currentValue - minValue);
    painter->rotate(degRotate);
    painter->drawEllipse(-radius, radius + offset, radius * 2, radius * 2);

    painter->restore();
}

void Widget::drawPointerIndicator(QPainter *painter)
{
    int radius = 75;
       painter->save();
       painter->setOpacity(0.8);
       painter->setPen(Qt::NoPen);
       painter->setBrush(pointerColor);

       QPolygon pts;
       pts.setPoints(3, -5, 0, 5, 0, 0, radius);

       painter->rotate(startAngle);
       double degRotate = (360.0 - startAngle - endAngle) / (maxValue - minValue) * (currentValue - minValue);
       painter->rotate(degRotate);
       painter->drawConvexPolygon(pts);

       painter->restore();

}

void Widget::drawPointerIndicatorR(QPainter *painter)
{
    int radius = 75;
    painter->save();
    painter->setOpacity(1.0);

    QPen pen;
    pen.setWidth(1);
    pen.setColor(pointerColor);
    painter->setPen(pen);
    painter->setBrush(pointerColor);

    QPolygon pts;
    pts.setPoints(3, -5, 0, 5, 0, 0, radius);

    painter->rotate(startAngle);
    double degRotate = (360.0 - startAngle - endAngle) / (maxValue - minValue) * (currentValue - minValue);
    painter->rotate(degRotate);
    painter->drawConvexPolygon(pts);

    //增加绘制圆角直线,与之前三角形重叠,形成圆角指针
    pen.setCapStyle(Qt::RoundCap);
    pen.setWidthF(4);
    painter->setPen(pen);
    painter->drawLine(0, 0, 0, radius);

    painter->restore();
}

void Widget::drawPointerTriangle(QPainter *painter)
{
    int radius = 10;
    int offset = 38;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setBrush(pointerColor);

    QPolygon pts;
    pts.setPoints(3, -5, 0 + offset, 5, 0 + offset, 0, radius + offset);

    painter->rotate(startAngle);
    double degRotate = (360.0 - startAngle - endAngle) / (maxValue - minValue) * (currentValue - minValue);
    painter->rotate(degRotate);
    painter->drawConvexPolygon(pts);

    painter->restore();
}

void Widget::drawRoundCircle(QPainter *painter)
{
    int radius = 18;
    painter->save();
    painter->setOpacity(0.8);
    painter->setPen(Qt::NoPen);
    painter->setBrush(pointerColor);
    painter->drawEllipse(-radius, -radius, radius * 2, radius * 2);
    painter->restore();
}




void Widget::drawCenterCircle(QPainter *painter)
{
    int radius = 15;
    painter->save();
    painter->setPen(Qt::NoPen);
    painter->setBrush(centerCircleColor);
    painter->drawEllipse(-radius, -radius, radius * 2, radius * 2);
    painter->restore();

}

void Widget::drawValue(QPainter *painter)
{
    int radius = 100;
    painter->save();
    painter->setPen(textColor);

    QFont font;
    font.setPixelSize(18);
    painter->setFont(font);

    QRectF textRect(-radius, -radius, radius * 2, radius * 2);
    QString strValue = QString("%1").arg((double)currentValue, 0, 'f', precision);//最小中心圆数值currentValue
    painter->drawText(textRect, Qt::AlignCenter, strValue);

    painter->restore();

}

void Widget::drawOverlay(QPainter *painter)
{
    if (!showOverlay) {
        return;
    }

    int radius = 90;
    painter->save();
    painter->setPen(Qt::NoPen);

    QPainterPath smallCircle;
    QPainterPath bigCircle;
    radius -= 1;
    smallCircle.addEllipse(-radius, -radius, radius * 2, radius * 2);
    radius *= 2;
    bigCircle.addEllipse(-radius, -radius + 140, radius * 2, radius * 2);

    //高光的形状为小圆扣掉大圆的部分
    QPainterPath highlight = smallCircle - bigCircle;

    QLinearGradient linearGradient(0, -radius / 2, 0, 0);
    overlayColor.setAlpha(100);
    linearGradient.setColorAt(0.0, overlayColor);
    overlayColor.setAlpha(30);
    linearGradient.setColorAt(1.0, overlayColor);
    painter->setBrush(linearGradient);
    painter->rotate(-20);
    painter->drawPath(highlight);

    painter->restore();
}

QSize Widget::sizeHint() const
{
    return QSize(200,200);

}

QSize Widget::minimumSizeHint() const
{
    return QSize(50,50);
}

void Widget::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 Widget::setRange(int minValue, int maxValue)
{
    setRange((double)minValue,(double)maxValue);
}

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

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

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

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

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

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

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

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

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

int Widget::getPrecision() const
{
    return this->precision;
}

void Widget::setPrecision(int precision)
{
    //最大精确度为3
    if(precision <= 3 && this->precision !=precision)
    {
        this->precision = precision;
        this->update();
    }
}

int Widget::getScaleMajor() const
{
    return this->scaleMajor;
}

void Widget::setScaleMajor(int scaleMajor)
{
    if(scaleMajor >0 && this->scaleMajor != scaleMajor)
    {
        this->scaleMajor = scaleMajor;
        this->update();
    }
}

int Widget::getScaleMinor() const
{
    return this->scaleMinor;
}

void Widget::setScaleMinor(int scaleMinor)
{
    if(scaleMinor >0 && this->scaleMinor != scaleMinor)
    {
        this->scaleMinor = scaleMinor;
        this->update();
    }
}

int Widget::getStartAngle() const
{
    return this->startAngle;
}

void Widget::setStartAngle(int startAngle)
{
    if(this->startAngle != startAngle)
    {
        this->startAngle = startAngle;
        this->update();
    }
}

int Widget::getEndAngle() const
{
    return this->endAngle;
}

void Widget::setEndAngle(int endAngle)
{
    if(this->endAngle != endAngle)
    {
        this->endAngle = endAngle;
        this->update();
    }
}


double Widget::getPiePercentStart() const
{
    return this->piePercentStart;
}

void Widget::setPiePercentStart(double piePercentStart)
{
    if(this->piePercentStart != piePercentStart)
    {
        this->piePercentStart = piePercentStart;
        this->update();
    }
}

double Widget::getPiePercentMid() const
{
    return this->piePercentMid;
}

void Widget::setPiePercentMid(double piePercentMid)
{
    if(this->piePercentMid != piePercentMid)
    {
        this->piePercentMid = piePercentMid;
        this->update();
    }
}

double Widget::getPiePercentEnd() const
{
    return this->piePercentEnd;
}

void Widget::setPiePercentEnd(double piePercentEnd)
{
    if(this->piePercentEnd != piePercentEnd)
    {
        this->piePercentEnd = piePercentEnd;
        this->update();
    }
}

QColor Widget::getOuterCircleColor() const
{
    return this->outerCircleColor;
}

void Widget::setOuterCircleColor(const QColor &outerCircleColor)
{
    if(this->outerCircleColor !=outerCircleColor)
    {
        this->outerCircleColor = outerCircleColor;
        this->update();
    }
}

QColor Widget::getInnerCircleColor() const
{
    return this->innerCircleColor;
}

void Widget::setInnerCircleColor(const QColor &innerCircleColor)
{
    if(this->innerCircleColor !=innerCircleColor)
    {
        this->innerCircleColor = innerCircleColor;
        this->update();
    }
}

QColor Widget::getPieColorStart() const
{
    return this->pieColorStart;
}

void Widget::setPieColorStart(const QColor &pieColorStart)
{
    if(this->pieColorStart != pieColorStart)
    {
        this->pieColorStart = pieColorStart;
        this->update();
    }
}

QColor Widget::getPieColorMid() const
{
    return this->pieColorMid;
}

void Widget::setPieColorMid(const QColor &pieColorMid)
{
    if(this->pieColorMid != pieColorMid)
    {
        this->pieColorMid = pieColorMid;
        this->update();
    }
}

QColor Widget::getPieColorEnd() const
{
    return this->pieColorEnd;
}

void Widget::setPieColorEnd(const QColor &pieColorEnd)
{
    if(this->pieColorEnd != pieColorEnd)
    {
        this->pieColorEnd = pieColorEnd;
        this->update();
    }
}

QColor Widget::getCoverCircleColor() const
{
    return this->coverCircleColor;
}

void Widget::setCoverCircleColor(const QColor &coverCircleColor)
{
    if(this->coverCircleColor != coverCircleColor)
    {
        this->coverCircleColor = coverCircleColor;
        this->update();
    }
}

QColor Widget::getScaleColor() const
{
    return this->scaleColor;
}

void Widget::setScaleColor(const QColor &scaleColor)
{
    if(this->scaleColor != scaleColor)
    {
        this->scaleColor = scaleColor;
        this->update();
    }
}

QColor Widget::getPointerColor() const
{
    return this->pointerColor;
}

void Widget::setPointerColor(const QColor &pointerColor)
{
    if(this->pointerColor != pointerColor)
    {
        this->pointerColor = pointerColor;
        this->update();
    }
}

QColor Widget::getCenterCircleColor() const
{
    return this->centerCircleColor;
}

void Widget::setCenterCircleColor(const QColor &centerCircleColor)
{
    if(this->centerCircleColor != centerCircleColor)
    {
        this->centerCircleColor = centerCircleColor;
        this->update();
    }
}

QColor Widget::getTextColor() const
{
    return this->textColor;
}

void Widget::setTextColor(const QColor &textColor)
{
    if(this->textColor != textColor)
    {
        this->textColor = textColor;
        this->update();
    }
}

bool Widget::getShowOverlay() const
{
    return this->showOverlay;
}

void Widget::setShowOverlay(bool showOverlay)
{
    if(this->showOverlay !=showOverlay)
    {
        this->showOverlay = showOverlay;
        this->update();
    }
}

QColor Widget::getOverlayColor() const
{
    return this->overlayColor;
}

void Widget::setOverlayColor(const QColor &overlayColor)
{
    if(this->overlayColor != overlayColor)
    {
        this->overlayColor = overlayColor;
        this->update();
    }
}

int Widget::getCircleWidth() const
{
    return this->circleWidth;
}

void Widget::setCircleWidth(int circleWidth)
{
    if(this->circleWidth !=circleWidth)
    {
        this->circleWidth = circleWidth;
        this->update();
    }
}

Widget::PieStyle Widget::getPieStyle() const
{
    return this->pieStyle;
}

void Widget::setPieStyle(const PieStyle &pieStyle)
{
    if(this->pieStyle !=pieStyle)
    {
        this->pieStyle = pieStyle;
        this->update();
    }
}

Widget::PointerStyle Widget::getPointerStyle() const
{
    return this->pointerStyle;
}

void Widget::setPointerStyle(const PointerStyle &pointerStyle)
{
    if(this->pointerStyle != pointerStyle)
    {
        this->pointerStyle = pointerStyle;
        this->update();
    }
}
qq_46630245
关注
QT自定义简单表盘（完整代码）
dingjumin的博客
11-11 1011
运行结果： widget.cpp #include "widget.h" #include "ui_widget.h" #include<QPainter> #include<QDebug> Widget::Widget(QWidget *parent) : QWidget(parent) , ui(new Ui::Widget) { ui->setupUi(this); m_wgt_mileage =new QWidget(thi
qt 窗体缩放 installfilter_Qt编写自定义控件4-旋转仪表盘
weixin_39524048的博客
12-01 206
前言旋转仪表盘，一般用在需要触摸调节设置值的场景中，其实Qt本身就提供了QDial控件具有类似的功能，本控件最大的难点不在于绘制刻度和指针等，而在于自动计算当前用户按下处的坐标转换为当前值，这个功能想了很久，也看了QDial的源码，他里边写的非常复杂，最后还是参考的我打99分(100分留给自己未来写的书，哈哈！)的Qt书籍《c++ gui qt 4编程》中的篇章才写出来的，关键需要用到atan2将...
GitHub开源推荐 | 一个轻量级Qt UI库
热门推荐
青春不老，奋斗不止！
12-05 1万+
分享一个轻量级 Qt UI 库 - Skinny，可以在 C++/QML 中使用。
QT 仪表盘 Widget 源码
03-01
QT汽车仪表盘控件源码。 已测，正常运行，效率比较高。
Qt自定义控件--仪表盘源码
08-17
源码使用Qt4.8.6和Qt5.7.1编译均没有问题。源码解释请参考博客：https://blog.csdn.net/baidu_33850454/article/details/81773323
qt实现一个简单的仪表盘
qq_30400965的博客
09-07 3131
代码结构 其中dialplate 在Forms中 右键add new Qt–qt设计师界面类 下一步 类名 dialpate 下一步 完成 我这里类名都是小写的 注意一下 dialplate.h // An highlighted block #ifndef dialplate_H #define dialplate_H #include <QWidget> #include<QPainter> namespace Ui { class dialplate; } cl.
Qt控件：仪表盘
wws的博客
08-29 6040
1. 预览图 2. 代码 头文件 #ifndef GAUGEPANEL_H #define GAUGEPANEL_H #include <QWidget> #include <QPropertyAnimation> #include <QtMath> #include <QPainter> #ifdef quc #if (QT_VERSION < QT_VERSION_CHECK(5,7,0)) #include <QtDesigner/Q
Qt绘制仪表盘
chenyijun的专栏
01-23 1510
在Qt的开发过程中，有些复杂的界面展示需要自动绘制，比如仪表盘的数据变化，都是动态的，而显示的效果只能通过paintEvent事件来自绘，本篇介绍仪表盘的绘制。
Qwt6.1.3 mvcs2015 编译库文件包含qtcreator的插件
05-19
Qwt 是一个开源库，全称为 Qt Widget Toolkit，它为基于Qt的应用程序提供了一系列与科学绘图、仪表盘和工程图表相关的控件。Qwt6.1.3 是该库的一个版本，它针对 Microsoft Visual Studio 2015 (MVCs2015) 进行了编译...
QtCreator知识点总结讲解.docx
11-29
- `QLCDNumber`：显示数字，常用于仪表盘。 - `QSplitter`：分隔并调整部件大小。 - `QStackedWidget`：切换显示多个部件。 - `QToolBox`：类似抽屉，存储可切换的部件。 - `QAbstractScrollArea`：包含可滚动...
QT仪表盘实例(项目实战)
05-15
qt下仪表盘实例，源代码给大家参考学习使用 可用于实际工程中。 qt下仪表盘实例，源代码给大家参考学习使用 可用于实际工程中。 qt下仪表盘实例，源代码给大家参考学习使用 可用于实际工程中。
qwt6.0.1+QtCreator2.8.1+qt-win-opensource-4.8.5-mingw安装过程
01-04
在本文中，我们将详细探讨如何在Windows环境下安装和配置qwt6.0.1库，同时结合QtCreator2.8.1和qt-win-opensource-4.8.5-mingw。这个过程对于开发基于Qt的图形用户界面应用，特别是需要使用Qwt库的科学计算或仪表盘...
qwt静态编译库(vs2013+qt5.3)
09-16
4. 使用QWT功能：现在，你可以开始使用QWT提供的各种组件，如图表、仪表盘、滑块等，来构建你的应用的图形界面。 通过这种方式，QWT静态编译库使得在VS2013和Qt5.3环境下开发科学计算或数据可视化应用变得容易，...
基于STM32+Qt上位机设计的智慧停车场管理系统(207)
最新发布
08-14 497
本项目设计了一套基于STM32+Qt上位机的智慧停车场管理系统。该系统融合了先进的嵌入式技术、图像识别技术、数据库技术和移动互联网技术，通过STM32硬件端实时采集车库现场信息，包括车牌识别、车位占用状态监测等，并将数据上传至Qt上位机进行处理与展示。利用MySQL数据库存储车辆出入库记录及车位使用情况，确保数据的安全性和可追溯性；通过Android手机APP为用户提供查询、支付等功能，实现远程交互与便捷服务。
Qt：绘制仪表盘
北街末雨Yyg
11-21 3738
Qt：绘制仪表盘
Qt自定义控件之仪表盘的完整实现
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
09-21 8013
基于QT的仪表盘有很多种办法，比如使用QWT或Echart组件，或者基于QT的绘图功能绘制，或者基于美工提供的图片的基础上增加动态效果。然而搞明白QT自定义控件的绘图后，这种实现是最简单的。且定制度高，想要什么效果就可以自己绘制个。这里介绍下Qt自定义控件之仪表盘的完整实现。
从新手小白入门Qt编程(Windows 10)
07-11
Qt是由Qt Company开发的主流跨平台C++图形用户界面应用程序开发框架。Qt是面向对象的框架、容易扩展，并且允许真正地组件编程，既可以开发GUI程序，也可用于控制台工具和服务器。其跨平台集成开发环境Qt Creator 全面支持Windows ，mac、Linux、iOS、Android、WP等。本课程主要帮助学员熟练掌握Qt 5.9框架下的C++开发，通过核心类的详细讲解与源码分析，以及所有UI控件的讲解演示，迅速帮助学员达到企业级Qt开发工程师的能力！
Qt/C++编写地图综合应用4-仪表盘
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
04-07 1514
一、前言 仪表盘在很多汽车和物联网相关的系统中很常用，最直观的其实就是汽车仪表盘，这个以前主要是机械的仪表，现在逐步改成了智能的带屏带操作系统的仪表，这样美观性和拓展性功能性大大增强了，上了操作系统的话，除了基本的仪表指示以外，还可以听歌导航接电话等，这应该也是目前汽车领域发展的一个大趋势，Qt在这方面还单独搞了个3D studio设计的，可以让美工直接设计好效果图，设置一些动画效果之类的，可以说...
在QtCreator上使用版本控制系统Git（一）
架构设计
10-29 1169
&lt;style type="text/css"&gt; &lt;!-- @page {margin:2cm} p {margin-bottom:0.21cm} --&gt; &lt;/style&gt; 在QtCreator上 使用版本控制系统Git（一） 在一篇介绍Git的文章中，作者说版本控制系统是为懒人准备的，它让懒人们比那些善于备份文档的勤劳人拥有更干净的文件系统...
qt 仪表盘 代码下载
08-06
若要下载 QT 仪表盘的代码，您可以按照以下步骤进行操作： 1. 打开浏览器，输入 "QT 仪表盘代码下载" 进行搜索。 2. 在搜索结果中，找到可靠的来源，如官方网站或开源代码库。 3. 点击进入该网站，并在搜索框中输入...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值