ToB企服应用市场:ToB评测及商务社交产业平台

标题: Qt绘制指南针（仪表盘绘制封装利用） [打印本页]
作者: 河曲智叟    时间: 2024-7-23 14:35
标题: Qt绘制指南针（仪表盘绘制封装利用）
        指南针是一种用来确定方向的工具。它由一个磁针制成，其一端被磁化，可以自由旋转。当放置在水平面上时，磁针会指向地球的磁北极。通过观察磁针的指向，我们可以确定地理北方的方向。本示例是在Qt中绘制一个指南针，通过继承QWidget类，并重写其paintEvent函数来实现。并对仪表盘绘制举行封装。
一、简述

         这个示例创建了一个名为CompassWidget的自定义小部件，它继承自QWidget类。在paintEvent()函数中，我们利用QPainter类举行绘图操纵。
二、 计划思绪    

三、结果 

 

四、核心代码  

1、头文件

        compasswidget.h 指南针表盘控件
  
  1. #ifndef COMPASSWIDGET_H
  2. #define COMPASSWIDGET_H
  4. #include <QWidget>
  6. class QcGaugeWidget;
  7. class QcNeedleItem;
  8. class QVBoxLayout;
  10. class CompassWidget : public QWidget
  11. {
  12.     Q_OBJECT
  13. public:
  14.     explicit CompassWidget(QWidget *parent = 0);
  15.     ~CompassWidget();
  17. public slots:
  18.     void setCurrentValue(int value);
  20. private:
  21.     void init();
  23. private:
  24.     QcGaugeWidget   *m_pCompassGauge; //表盘
  25.     QcNeedleItem    *m_pCompassNeedle; //指针
  26.     QVBoxLayout     *m_pMainLayout;
  27. };
  29. #endif // COMPASSWIDGET_H
复制代码
qcgaugewidget.h 仪表盘绘制封装（此处只有绘制指南针所需代码，全部代码请下载） 
  
  1. #ifndef QCGAUGEWIDGET_H
  2. #define QCGAUGEWIDGET_H
  4. #include <QWidget>
  5. #include <QPainter>
  6. #include <QObject>
  7. #include <QRectF>
  8. #include <QtMath>
  10. class QcGaugeWidget;
  11. class QcItem;
  12. class QcBackgroundItem;
  13. class QcDegreesItem;
  14. class QcNeedleItem;
  15. class QcLabelItem;
  16. class QcGlassItem;
  18. ///
  19. class QcGaugeWidget : public QWidget
  20. {
  21.     Q_OBJECT
  22. public:
  23.     explicit QcGaugeWidget(QWidget *parent = 0);   
  25.     QcBackgroundItem* addBackground(float position);
  26.     QcDegreesItem* addDegrees(float position);
  27.     QcNeedleItem* addNeedle(float position);
  28.     QcLabelItem* addLabel(float position);
  29.     QcGlassItem* addGlass(float position);
  31.     void addItem(QcItem* item, float position);
  32.     int removeItem(QcItem* item);
  33.     QList <QcItem*> items();
  34.     QList <QcItem*> mItems;
  36. private:
  37.     void paintEvent(QPaintEvent *);
  39. };
  41. ///
  42. class QcItem : public QObject
  43. {
  44.     Q_OBJECT
  45. public:
  46.     explicit QcItem(QObject *parent = 0);
  47.     virtual void draw(QPainter *) = 0;
  48.     virtual int type();
  50.     void setPosition(float percentage);
  51.     float position();
  52.     QRectF rect();
  53.     enum Error{InvalidValueRange,InvalidDegreeRange,InvalidStep};
  55. protected:
  56.     QRectF adjustRect(float percentage);
  57.     float getRadius(const QRectF &);
  58.     float getAngle(const QPointF&, const QRectF &tmpRect);
  59.     QPointF getPoint(float deg, const QRectF &tmpRect);
  60.     QRectF resetRect();
  61.     void update();
  63. private:
  64.     QRectF mRect;
  65.     QWidget *parentWidget;
  66.     float mPosition;
  67. };
  69. ///
  70. class QcScaleItem : public QcItem
  71. {
  72.     Q_OBJECT
  73. public:
  74.     explicit QcScaleItem(QObject *parent = 0);
  76.     void setValueRange(float minValue,float maxValue);
  77.     void setDgereeRange(float minDegree,float maxDegree);
  78.     void setMinValue(float minValue);
  79.     void setMaxValue(float maxValue);
  80.     void setMinDegree(float minDegree);
  81.     void setMaxDegree(float maxDegree);
  83. protected:
  84.     float getDegFromValue(float);
  86.     float mMinValue;
  87.     float mMaxValue;
  88.     float mMinDegree;
  89.     float mMaxDegree;
  90. };
  92. ///
  93. class QcBackgroundItem : public QcItem
  94. {
  95.     Q_OBJECT
  96. public:
  97.     explicit QcBackgroundItem(QObject *parent = 0);
  98.     void draw(QPainter*);
  99.     void addColor(float position, const QColor& color);
  100.     void clearrColors();
  102. private:
  103.     QPen mPen;
  104.     QList<QPair<float,QColor> > mColors;
  105.     QLinearGradient mLinearGrad;
  106. };
  108. ///
  109. class QcGlassItem : public QcItem
  110. {
  111.     Q_OBJECT
  112. public:
  113.     explicit QcGlassItem(QObject *parent = 0);
  114.     void draw(QPainter*);
  115. };
  117. ///
  118. class QcLabelItem : public QcItem
  119. {
  120.     Q_OBJECT
  121. public:
  122.     explicit QcLabelItem(QObject *parent = 0);
  123.     virtual void draw(QPainter *);
  124.     void setAngle(float);
  125.     float angle();
  126.     void setText(const QString &text, bool repaint = true);
  127.     QString text();
  128.     void setColor(const QColor& color);
  129.     QColor color();
  131. private:
  132.     float mAngle;
  133.     QString mText;
  134.     QColor mColor;
  135. };
  137. ///
  138. class  QcDegreesItem : public QcScaleItem
  139. {
  140.     Q_OBJECT
  141. public:
  142.     explicit QcDegreesItem(QObject *parent = 0);
  143.     void draw(QPainter *painter);
  144.     void setStep(float step);
  145.     void setColor(const QColor& color);
  146.     void setSubDegree(bool );
  147. private:
  148.     float mStep;
  149.     QColor mColor;
  150.     bool mSubDegree;
  151. };
  153. ///
  154. class QcNeedleItem : public QcScaleItem
  155. {
  156.     Q_OBJECT
  157. public:
  158.     explicit QcNeedleItem(QObject *parent = 0);
  159.     void draw(QPainter*);
  160.     void setCurrentValue(float value);
  161.     float currentValue();
  162.     void setValueFormat(QString format);
  163.     QString currentValueFormat();
  164.     void setColor(const QColor & color);
  165.     QColor color();
  167.     void setLabel(QcLabelItem*);
  168.     QcLabelItem * label();
  170.     enum NeedleType{
  171.         DiamonNeedle,
  172.         TriangleNeedle,//三角指针
  173.         FeatherNeedle,
  174.         AttitudeMeterNeedle,
  175.         CompassNeedle   //指南针
  176.     };
  178.     void setNeedle(QcNeedleItem::NeedleType needleType);
  179. private:
  180.     QPolygonF mNeedlePoly;
  181.     float mCurrentValue;
  182.     QColor mColor;
  183.     void createDiamonNeedle(float r);
  184.     void createTriangleNeedle(float r);
  185.     void createFeatherNeedle(float r);
  186.     void createAttitudeNeedle(float r);
  187.     void createCompassNeedle(float r);
  188.     NeedleType mNeedleType;
  189.     QcLabelItem *mLabel;
  190.     QString mFormat;
  191. };
  193. #endif // QCGAUGEWIDGET_H
复制代码
2、实当代码

compasswidget.cpp 
  
  1. #include "compasswidget.h"
  2. #include <QVBoxLayout>
  3. #include "qcgaugewidget.h"
  5. CompassWidget::CompassWidget(QWidget *parent)
  6.     : QWidget(parent)
  7. {
  8.     init();
  9. }
  11. CompassWidget::~CompassWidget()
  12. {
  13. }
  15. void CompassWidget::setCurrentValue(int value)
  16. {
  17.     m_pCompassNeedle->setCurrentValue(value);
  18. }
  20. void CompassWidget::init()
  21. {
  22.     m_pCompassGauge = new QcGaugeWidget;
  24.     m_pCompassGauge->addBackground(99);
  25.     QcBackgroundItem *bkg1 = m_pCompassGauge->addBackground(92);
  26.     bkg1->clearrColors();
  27.     bkg1->addColor(0.1,Qt::black);
  28.     bkg1->addColor(1.0,Qt::white);
  30.     QcBackgroundItem *bkg2 = m_pCompassGauge->addBackground(88);
  31.     bkg2->clearrColors();
  32.     bkg2->addColor(0.1,Qt::white);
  33.     bkg2->addColor(1.0,Qt::black);
  35.     QcLabelItem *w = m_pCompassGauge->addLabel(80);//标签
  36.     w->setText("W");
  37.     w->setAngle(0);
  38.     w->setColor(Qt::white);
  40.     QcLabelItem *n = m_pCompassGauge->addLabel(80);
  41.     n->setText("N");
  42.     n->setAngle(90);
  43.     n->setColor(Qt::white);
  45.     QcLabelItem *e = m_pCompassGauge->addLabel(80);
  46.     e->setText("E");
  47.     e->setAngle(180);
  48.     e->setColor(Qt::white);
  50.     QcLabelItem *s = m_pCompassGauge->addLabel(80);
  51.     s->setText("S");
  52.     s->setAngle(270);
  53.     s->setColor(Qt::white);
  55.     QcDegreesItem *deg = m_pCompassGauge->addDegrees(70);//刻度
  56.     deg->setStep(5);
  57.     deg->setMaxDegree(270);
  58.     deg->setMinDegree(-75);
  59.     deg->setColor(Qt::white);
  60.     m_pCompassNeedle = m_pCompassGauge->addNeedle(60);//指针
  61.     m_pCompassNeedle->setNeedle(QcNeedleItem::CompassNeedle);
  62.     m_pCompassNeedle->setValueRange(0,360);
  63.     m_pCompassNeedle->setMaxDegree(360);
  64.     m_pCompassNeedle->setMinDegree(0);
  65.     m_pCompassGauge->addBackground(7);
  66.     m_pCompassGauge->addGlass(88);//毛玻璃
  68.     m_pMainLayout = new QVBoxLayout(this);
  69.     m_pMainLayout->addWidget(m_pCompassGauge);
  70. }
复制代码
qcgaugewidget.cpp  仪表盘绘制封装（此处只有绘制指南针所需代码，全部代码请下载） 
  1. #include "qcgaugewidget.h"
  3. QcGaugeWidget::QcGaugeWidget(QWidget *parent) :
  4.     QWidget(parent)
  5. {
  6.     setMinimumSize(250,250);
  7. }
  9. QcBackgroundItem *QcGaugeWidget::addBackground(float position)
  10. {
  11.     QcBackgroundItem * item = new QcBackgroundItem(this);
  12.     item->setPosition(position);
  13.     mItems.append(item);
  14.     return item;
  15. }
  17. QcDegreesItem *QcGaugeWidget::addDegrees(float position)
  18. {
  19.     QcDegreesItem * item = new QcDegreesItem(this);
  20.     item->setPosition(position);
  22.     mItems.append(item);
  23.     return item;
  24. }
  26. QcNeedleItem *QcGaugeWidget::addNeedle(float position)
  27. {
  28.     QcNeedleItem * item = new QcNeedleItem(this);
  29.     item->setPosition(position);
  30.     mItems.append(item);
  31.     return item;
  32. }
  34. QcLabelItem *QcGaugeWidget::addLabel(float position)
  35. {
  36.     QcLabelItem * item = new QcLabelItem(this);
  37.     item->setPosition(position);
  38.     mItems.append(item);
  39.     return item;
  40. }
  42. QcGlassItem *QcGaugeWidget::addGlass(float position)
  43. {
  44.     QcGlassItem * item = new QcGlassItem(this);
  45.     item->setPosition(position);
  46.     mItems.append(item);
  47.     return item;
  48. }
  50. void QcGaugeWidget::addItem(QcItem *item,float position)
  51. {
  52.     item->setParent(this);
  53.     item->setPosition(position);
  54.     mItems.append(item);
  55. }
  57. int QcGaugeWidget::removeItem(QcItem *item)
  58. {
  59.    return mItems.removeAll(item);
  60. }
  62. QList<QcItem *> QcGaugeWidget::items()
  63. {
  64.     return mItems;
  65. }
  68. void QcGaugeWidget::paintEvent(QPaintEvent */*paintEvt*/)
  69. {
  70.     QPainter painter(this);
  71.     painter.setRenderHint(QPainter::Antialiasing);
  73.     foreach (QcItem * item, mItems) {
  74.         item->draw(&painter);
  75.     }
  76. }
  78. ///
  79. QcItem::QcItem(QObject *parent) :
  80.     QObject(parent)
  81. {
  83.     parentWidget = qobject_cast<QWidget*>(parent);
  84.     mPosition = 50;
  85. }
  87. int QcItem::type()
  88. {
  89.     return 50;
  90. }
  92. void QcItem::update()
  93. {
  94.     parentWidget->update();
  95. }
  97. float QcItem::position()
  98. {
  99.     return mPosition;
  100. }
  102. QRectF QcItem::rect()
  103. {
  104.     return mRect;
  105. }
  107. void QcItem::setPosition(float position)
  108. {
  109.     if(position>100)
  110.         mPosition = 100;
  111.     else if(position<0)
  112.         mPosition = 0;
  113.     else
  114.         mPosition = position;
  115.     update();
  116. }
  118. QRectF QcItem::adjustRect(float percentage)
  119. {
  120.     float r = getRadius(mRect);
  121.     float offset =   r-(percentage*r)/100.0;
  122.     QRectF tmpRect = mRect.adjusted(offset,offset,-offset,-offset);
  123.     return tmpRect;
  124. }
  126. float QcItem::getRadius(const QRectF &tmpRect)
  127. {
  128.     float r = 0;
  129.     if(tmpRect.width()<tmpRect.height())
  130.         r = tmpRect.width()/2.0;
  131.     else
  132.         r = tmpRect.height()/2.0;
  133.     return r;
  134. }
  136. QRectF QcItem::resetRect()
  137. {
  138.     mRect = parentWidget->rect();
  139.     float r = getRadius(mRect);
  140.     mRect.setWidth(2.0*r);
  141.     mRect.setHeight(2.0*r);
  142.     mRect.moveCenter(parentWidget->rect().center());
  143.     return mRect;
  144. }
  146. QPointF QcItem::getPoint(float deg,const QRectF &tmpRect)
  147. {
  148.     float r = getRadius(tmpRect);
  149.     float xx=cos(qDegreesToRadians(deg))*r;
  150.     float yy=sin(qDegreesToRadians(deg))*r;
  151.     QPointF pt;
  152.     xx=tmpRect.center().x()-xx;
  153.     yy=tmpRect.center().y()-yy;
  154.     pt.setX(xx);
  155.     pt.setY(yy);
  156.     return pt;
  157. }
  159. float QcItem::getAngle(const QPointF&pt, const QRectF &tmpRect)
  160. {
  161.     float xx=tmpRect.center().x()-pt.x();
  162.     float yy=tmpRect.center().y()-pt.y();
  163.     return qRadiansToDegrees( atan2(yy,xx));
  164. }
  166. ///
  167. QcScaleItem::QcScaleItem(QObject *parent) :
  168.     QcItem(parent)
  169. {
  170.     mMinDegree = -45;
  171.     mMaxDegree = 225;
  172.     mMinValue = 0;
  173.     mMaxValue = 100;
  174. }
  176. void QcScaleItem::setValueRange(float minValue, float maxValue)
  177. {
  178.     if(!(minValue<maxValue))
  179.         throw( InvalidValueRange);
  180.     mMinValue = minValue;
  181.     mMaxValue = maxValue;
  183. }
  185. void QcScaleItem::setDgereeRange(float minDegree, float maxDegree)
  186. {
  187.     if(!(minDegree<maxDegree))
  188.         throw( InvalidValueRange);
  189.     mMinDegree = minDegree;
  190.     mMaxDegree = maxDegree;
  191. }
  193. float QcScaleItem::getDegFromValue(float v)
  194. {
  195.     float a = (mMaxDegree-mMinDegree)/(mMaxValue-mMinValue);
  196.     float b = -a*mMinValue+mMinDegree;
  197.     return a*v+b;
  198. }
  201. void QcScaleItem::setMinValue(float minValue)
  202. {
  203.     if(minValue>mMaxValue)
  204.         throw (InvalidValueRange);
  205.     mMinValue = minValue;
  206.     update();
  207. }
  210. void QcScaleItem::setMaxValue(float maxValue)
  211. {
  212.     if(maxValue<mMinValue )
  213.         throw (InvalidValueRange);
  214.     mMaxValue = maxValue;
  215.     update();
  216. }
  218. void QcScaleItem::setMinDegree(float minDegree)
  219. {
  220.     if(minDegree>mMaxDegree)
  221.         throw (InvalidDegreeRange);
  222.     mMinDegree = minDegree;
  223.     update();
  224. }
  225. void QcScaleItem::setMaxDegree(float maxDegree)
  226. {
  227.     if(maxDegree<mMinDegree)
  228.         throw (InvalidDegreeRange);
  229.     mMaxDegree = maxDegree;
  230.     update();
  231. }
  233. ///
  234. QcBackgroundItem::QcBackgroundItem(QObject *parent) :
  235.     QcItem(parent)
  236. {
  237.     setPosition(88);
  238.     mPen = Qt::NoPen;
  239.     setPosition(88);
  241.     addColor(0.4,Qt::darkGray);
  242.     addColor(0.8,Qt::black);
  244. }
  246. void QcBackgroundItem::draw(QPainter* painter)
  247. {
  248.     QRectF tmpRect = resetRect();
  249.     painter->setBrush(Qt::NoBrush);
  250.     QLinearGradient linearGrad(tmpRect.topLeft(), tmpRect.bottomRight());
  251.     for(int i = 0;i<mColors.size();i++){
  252.         linearGrad.setColorAt(mColors[i].first,mColors[i].second);
  253.     }
  254.     painter->setPen(mPen);
  255.     painter->setBrush(linearGrad);
  256.     painter->drawEllipse(adjustRect(position()));
  257. }
  259. void QcBackgroundItem::addColor(float position, const QColor &color)
  260. {
  261.     if(position<0||position>1)
  262.         return;
  263.       QPair<float,QColor> pair;
  264.       pair.first = position;
  265.       pair.second = color;
  266.       mColors.append(pair);
  267.       update();
  268. }
  270. void QcBackgroundItem::clearrColors()
  271. {
  272.     mColors.clear();
  273. }
  275. ///
  276. QcGlassItem::QcGlassItem(QObject *parent) :
  277.     QcItem(parent)
  278. {
  279.     setPosition(88);
  280. }
  282. void QcGlassItem::draw(QPainter *painter)
  283. {
  284.     resetRect();
  285.     QRectF tmpRect1 = adjustRect(position());
  286.     QRectF tmpRect2 = tmpRect1;
  287.     float r = getRadius(tmpRect1);
  288.     tmpRect2.setHeight(r/2.0);
  289.     painter->setPen(Qt::NoPen);
  291.     QColor clr1 = Qt::gray ;
  292.     QColor clr2 = Qt::white;
  293.     clr1.setAlphaF(0.2);
  294.     clr2.setAlphaF(0.4);
  296.     QLinearGradient linearGrad1(tmpRect1.topLeft(), tmpRect1.bottomRight());
  297.     linearGrad1.setColorAt(0.1, clr1);
  298.     linearGrad1.setColorAt(0.5, clr2);
  300.     painter->setBrush(linearGrad1);
  301.     painter->drawPie(tmpRect1,0,16*180);
  302.     tmpRect2.moveCenter(rect().center());
  303.     painter->drawPie(tmpRect2,0,-16*180);
  304. }
  306. ///
  307. QcLabelItem::QcLabelItem(QObject *parent) :
  308.     QcItem(parent)
  309. {
  310.     setPosition(50);
  311.     mAngle = 270;
  312.     mText = "%";
  313.     mColor = Qt::black;
  314. }
  316. void QcLabelItem::draw(QPainter *painter)
  317. {
  318.     resetRect();
  319.     QRectF tmpRect = adjustRect(position());
  320.     float r = getRadius(rect());
  321.     QFont font("Meiryo UI", r/10.0, QFont::Bold);
  322.     painter->setFont(font);
  323.     painter->setPen(QPen(mColor));
  325.     QPointF txtCenter = getPoint(mAngle,tmpRect);
  326.     QFontMetrics fMetrics = painter->fontMetrics();
  327.     QSize sz = fMetrics.size( Qt::TextSingleLine, mText );
  328.     QRectF txtRect(QPointF(0,0), sz );
  329.     txtRect.moveCenter(txtCenter);
  331.     painter->drawText( txtRect, Qt::TextSingleLine,mText );
  332. }
  334. void QcLabelItem::setAngle(float a)
  335. {
  336.     mAngle = a;
  337.     update();
  338. }
  340. float QcLabelItem::angle()
  341. {
  342.     return mAngle;
  343. }
  345. void QcLabelItem::setText(const QString &text, bool repaint)
  346. {
  347.     mText = text;
  348.     if(repaint)
  349.         update();
  350. }
  352. QString QcLabelItem::text()
  353. {
  354.     return mText;
  355. }
  357. void QcLabelItem::setColor(const QColor &color)
  358. {
  359.     mColor = color;
  360.     update();
  361. }
  363. QColor QcLabelItem::color()
  364. {
  365.     return mColor;
  366. }
  368. ///
  369. QcDegreesItem::QcDegreesItem(QObject *parent) :
  370.     QcScaleItem(parent)
  371. {
  372.     mStep = 10;
  373.     mColor = Qt::black;
  374.     mSubDegree = false;
  375.     setPosition(90);
  376. }
  378. void QcDegreesItem::draw(QPainter *painter)
  379. {
  380.     resetRect();
  381.     QRectF tmpRect = adjustRect(position());
  383.     painter->setPen(mColor);
  384.     float r = getRadius(tmpRect);
  385.     for(float val = mMinValue;val<=mMaxValue;val+=mStep){
  386.         float deg = getDegFromValue(val);
  387.         QPointF pt = getPoint(deg,tmpRect);
  388.         QPainterPath path;
  389.         path.moveTo(pt);
  390.         path.lineTo(tmpRect.center());
  391.         pt = path.pointAtPercent(0.03);
  392.         QPointF newPt = path.pointAtPercent(0.13);
  394.         QPen pen;
  395.         pen.setColor(mColor);
  396.         if(!mSubDegree)
  397.             pen.setWidthF(r/25.0);
  399.         painter->setPen(pen);
  400.         painter->drawLine(pt,newPt);
  401.     }
  402. }
  404. void QcDegreesItem::setStep(float step)
  405. {
  406.     mStep = step;
  407.     update();
  408. }
  410. void QcDegreesItem::setColor(const QColor& color)
  411. {
  412.     mColor = color;
  413.     update();
  414. }
  416. void QcDegreesItem::setSubDegree(bool b)
  417. {
  418.     mSubDegree = b;
  419.     update();
  420. }
  422. ///
  423. QcNeedleItem::QcNeedleItem(QObject *parent) :
  424.     QcScaleItem(parent)
  425. {
  426.     mCurrentValue = 0;
  427.     mColor = Qt::black;
  428.     mLabel = NULL;
  429.     mNeedleType = FeatherNeedle;
  430. }
  432. void QcNeedleItem::draw(QPainter *painter)
  433. {
  434.     resetRect();
  435.     QRectF tmpRect = adjustRect(position());
  436.     painter->save();
  437.     painter->translate(tmpRect.center());
  438.     float deg = getDegFromValue( mCurrentValue);
  439.     painter->rotate(deg+90.0);
  440.     painter->setBrush(QBrush(mColor));
  441.     painter->setPen(Qt::NoPen);
  443.     QLinearGradient grad;
  445.     switch (mNeedleType) {
  446.     case QcNeedleItem::FeatherNeedle:
  447.         createFeatherNeedle(getRadius(tmpRect));
  448.         break;
  449.     case QcNeedleItem::DiamonNeedle:
  450.         createDiamonNeedle(getRadius(tmpRect));
  451.         break;
  452.     case QcNeedleItem::TriangleNeedle:
  453.         createTriangleNeedle(getRadius(tmpRect));
  454.         break;
  455.     case QcNeedleItem::AttitudeMeterNeedle:
  456.         createAttitudeNeedle(getRadius(tmpRect));
  457.         break;
  458.     case QcNeedleItem::CompassNeedle:
  459.         createCompassNeedle(getRadius(tmpRect));
  460.         grad.setStart(mNeedlePoly[0]);
  461.         grad.setFinalStop(mNeedlePoly[1]);
  462.         grad.setColorAt(0.9,Qt::red);
  463.         grad.setColorAt(1,Qt::blue);
  464.         painter->setBrush(grad);
  466.         break;
  468.     default:
  469.         break;
  470.     }
  471.     painter->drawConvexPolygon(mNeedlePoly);
  472.     painter->restore();
  473. }
  475. void QcNeedleItem::setCurrentValue(float value)
  476. {
  477.        if(value<mMinValue)
  478.         mCurrentValue = mMinValue;
  479.     else if(value>mMaxValue)
  480.         mCurrentValue = mMaxValue;
  481.     else
  482.         mCurrentValue = value;
  484.     if(mLabel!=0)
  485.         mLabel->setText(QString::number(mCurrentValue),false);
  487.     update();
  488. }
  490. float QcNeedleItem::currentValue()
  491. {
  492.     return mCurrentValue;
  493. }
  495. void QcNeedleItem::setValueFormat(QString format){
  496.     mFormat = format;
  497.     update();
  498. }
  500. QString QcNeedleItem::currentValueFormat(){
  501.     return mFormat;
  502. }
  504. void QcNeedleItem::setColor(const QColor &color)
  505. {
  506.     mColor = color;
  507.     update();
  508. }
  510. QColor QcNeedleItem::color()
  511. {
  512.     return mColor;
  513. }
  515. void QcNeedleItem::setLabel(QcLabelItem *label)
  516. {
  517.     mLabel = label;
  518.     update();
  519. }
  521. QcLabelItem *QcNeedleItem::label()
  522. {
  523.     return mLabel;
  524. }
  527. void QcNeedleItem::setNeedle(QcNeedleItem::NeedleType needleType)
  528. {
  529.     mNeedleType = needleType;
  530.     update();
  531. }
  534. void QcNeedleItem::createDiamonNeedle(float r)
  535. {
  536.     QVector<QPointF> tmpPoints;
  537.     tmpPoints.append(QPointF(0.0, 0.0));
  538.     tmpPoints.append(QPointF(-r/20.0,r/20.0));
  539.     tmpPoints.append(QPointF(0.0, r));
  540.     tmpPoints.append(QPointF(r/20.0,r/20.0));
  541.     mNeedlePoly = tmpPoints;
  542. }
  544. void QcNeedleItem::createTriangleNeedle(float r)
  545. {
  546.     QVector<QPointF> tmpPoints;
  547.     tmpPoints.append(QPointF(0.0, r));
  548.     tmpPoints.append(QPointF(-r/40.0, 0.0));
  549.     tmpPoints.append(QPointF(r/40.0,0.0));
  550.     mNeedlePoly = tmpPoints;
  551. }
  553. void QcNeedleItem::createFeatherNeedle(float r)
  554. {
  555.     QVector<QPointF> tmpPoints;
  556.     tmpPoints.append(QPointF(0.0, r));
  557.     tmpPoints.append(QPointF(-r/40.0, 0.0));
  558.     tmpPoints.append(QPointF(-r/15.0, -r/5.0));
  559.     tmpPoints.append(QPointF(r/15.0,-r/5));
  560.     tmpPoints.append(QPointF(r/40.0,0.0));
  561.     mNeedlePoly = tmpPoints;
  562. }
  564. void QcNeedleItem::createAttitudeNeedle(float r)
  565. {
  566.     QVector<QPointF> tmpPoints;
  567.     tmpPoints.append(QPointF(0.0, r));
  568.     tmpPoints.append(QPointF(-r/20.0, 0.85*r));
  569.     tmpPoints.append(QPointF(r/20.0,0.85*r));
  570.     mNeedlePoly = tmpPoints;
  571. }
  573. void QcNeedleItem::createCompassNeedle(float r)
  574. {
  575.     QVector<QPointF> tmpPoints;
  576.     tmpPoints.append(QPointF(0.0, r));
  577.     tmpPoints.append(QPointF(-r/15.0, 0.0));
  578.     tmpPoints.append(QPointF(0.0, -r));
  579.     tmpPoints.append(QPointF(r/15.0,0.0));
  580.     mNeedlePoly = tmpPoints;
  581. }
复制代码
以上是Qt绘制指南针实当代码，在实际利用中，可以根据需要自定义动画文件和样式。
该自定义控件主要特点有：
1、纯QPaint绘制，不包括图片等文件；
2、多种自定义控制，非常机动；
3、能够自顺应大小，不需要手动调整；
        需要留意的是，在利用QPainter时，需要机动运用QPainter的绘图函数和提供给用户的交互函数，并留意处置惩罚用户的交互操纵和组件的尺寸调整等问题。
五、利用示例

以下是一个简单的示例代码，演示了如何在Qt中利用此控件：
  
  1. #include "mainwindow.h"
  2. #include "compasswidget.h"
  3. #include <QSlider>
  4. #include <QHBoxLayout>
  6. MainWindow::MainWindow(QWidget *parent)
  7.     : QMainWindow(parent)
  8. {
  9.     CompassWidget *pCompassWidget = new CompassWidget(this);
  11.     QSlider *slider = new QSlider(this);
  12.     slider->setRange(0, 360);
  14.     connect(slider, &QSlider::valueChanged, pCompassWidget, &CompassWidget::setCurrentValue);
  16.     QWidget *widget = new QWidget(this);
  17.     QHBoxLayout *layout = new QHBoxLayout(widget);
  18.     layout->addWidget(pCompassWidget);
  19.     layout->addWidget(slider);
  20.     setCentralWidget(widget);
  22.     resize(400, 400);
  23. }
  25. MainWindow::~MainWindow()
  26. {
  27. }
复制代码
总结一下，指南针的计划方法和流程如下：
1、绘制指南针的配景。可以利用QPainter的drawEllipse方法来绘制一个圆形配景，然后填充颜色。
2、绘制指南针的刻度。可以利用QPainter的drawLine方法绘制指南针的刻度线，通过循环来绘制全部的刻度。
3、绘制指南针的指针。可以利用QPainter的drawLine方法绘制指南针的指针线，通过盘算指针的角度来确定其位置。
4、绘制指南针的文字标签。可以利用QPainter的drawText方法绘制文字，并根据指南针的角度来确定文字标签的位置。
六、绘制一个速度表盘 

        我们利用QcGaugeWidget 将CompassWidget内init稍作修改即可实现一个速度仪表盘，代码如下（表盘和指针对象名称已修改）：  
  1.     m_pSpeedGauge = new QcGaugeWidget(this);
  2.     m_pSpeedGauge->addBackground(99);
  3.     QcBackgroundItem *bkg1 = m_pSpeedGauge->addBackground(92);
  4.     bkg1->clearrColors();
  5.     bkg1->addColor(0.1,Qt::black);
  6.     bkg1->addColor(1.0,Qt::white);
  8.     QcBackgroundItem *bkg2 = m_pSpeedGauge->addBackground(88);
  9.     bkg2->clearrColors();
  10.     bkg2->addColor(0.1,Qt::gray);
  11.     bkg2->addColor(1.0,Qt::darkGray);
  13.     m_pSpeedGauge->addArc(55);
  14.     m_pSpeedGauge->addDegrees(65)->setValueRange(0,80);
  15.     m_pSpeedGauge->addColorBand(50);
  17.     m_pSpeedGauge->addValues(80)->setValueRange(0,80);
  19.     m_pSpeedGauge->addLabel(70)->setText("Km/h");
  20.     QcLabelItem *lab = m_pSpeedGauge->addLabel(40);
  21.     lab->setText("0");
  22.     m_pSpeedNeedle = m_pSpeedGauge->addNeedle(60);
  23.     m_pSpeedNeedle->setLabel(lab);
  24.     m_pSpeedNeedle->setColor(Qt::white);
  25.     m_pSpeedNeedle->setValueRange(0,80);
  26.     m_pSpeedGauge->addBackground(7);
  27.     m_pSpeedGauge->addGlass(88);
  29.     m_pMainLayout = new QVBoxLayout(this);
  30.     m_pMainLayout->addWidget(m_pSpeedGauge);
  32.     setLayout(m_pMainLayout);
复制代码
结果如下：
 

        谢谢您的关注和阅读。如果您还有其他问题或需要进一步的资助，请随时联系我。祝您一切顺利！
七、源代码下载



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4