Qt绘制指南针（仪表盘绘制封装利用）

        指南针是一种用来确定方向的工具。它由一个磁针制成，其一端被磁化，可以自由旋转。当放置在水平面上时，磁针会指向地球的磁北极。通过观察磁针的指向，我们可以确定地理北方的方向。本示例是在Qt中绘制一个指南针，通过继承QWidget类，并重写其paintEvent函数来实现。并对仪表盘绘制举行封装。
一、简述

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

• 创建一个QWidget子类CompassWidget用于绘制指南针。
  
• 在CompassWidget的构造函数中，设置指南针的配景色、大小等属性。
  
• 定义QcGaugeWidget类，绘制指南针的各个构成部分，重写干系部件的paintEvent()函数。
  
• 利用QPainter在paintEvent()函数中绘制指南针的主体部分，包括圆形配景、指针和刻度。
  
• 根据指南针的当前角度，盘算并绘制指针的位置和角度。
  
• 添加一个public的setCurrentValue()函数，用于设置指南针的角度，并在此中调用update()函数刷新界面。
  

三、结果 

 

四、核心代码  

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企服之家，中国第一个企服评测及商务社交产业平台。