1 | NO CONTENT: modified file |
|
NO CONTENT: modified file |
@@ -1,77 +1,75 | |||||
1 | #include "axisanimationitem_p.h" |
|
1 | #include "axisanimationitem_p.h" | |
2 | #include <QTimer> |
|
2 | #include <QTimer> | |
3 |
|
3 | |||
4 | Q_DECLARE_METATYPE(QVector<qreal>) |
|
4 | Q_DECLARE_METATYPE(QVector<qreal>) | |
5 |
|
5 | |||
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
7 |
|
7 | |||
8 | const static int duration = 500; |
|
8 | const static int duration = 500; | |
9 |
|
9 | |||
10 | AxisAnimationItem::AxisAnimationItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) : |
|
10 | AxisAnimationItem::AxisAnimationItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) : | |
11 | AxisItem(axis,type,parent), |
|
11 | AxisItem(axis,type,parent), | |
12 | m_animation(new AxisAnimator(this,this)) |
|
12 | m_animation(new AxisAnimator(this,this)) | |
13 | { |
|
13 | { | |
14 | } |
|
14 | } | |
15 |
|
15 | |||
16 | AxisAnimationItem::~AxisAnimationItem() |
|
16 | AxisAnimationItem::~AxisAnimationItem() | |
17 | { |
|
17 | { | |
18 | } |
|
18 | } | |
19 |
|
19 | |||
20 |
void AxisAnimationItem::update |
|
20 | void AxisAnimationItem::updateLayout(QVector<qreal>& newLayout) | |
21 | { |
|
21 | { | |
22 | QVector<qreal> oldLayout = layout(); |
|
22 | QVector<qreal> oldLayout = layout(); | |
23 | AxisItem::updateItem(); |
|
|||
24 | QVector<qreal> newLayout = layout(); |
|
|||
25 |
|
23 | |||
26 | if(newLayout.count()==0) return; |
|
24 | if(newLayout.count()==0) return; | |
27 | oldLayout.resize(newLayout.size()); |
|
25 | oldLayout.resize(newLayout.size()); | |
28 |
|
26 | |||
29 | if(m_animation->state()!=QAbstractAnimation::Stopped){ |
|
27 | if(m_animation->state()!=QAbstractAnimation::Stopped){ | |
30 | m_animation->stop(); |
|
28 | m_animation->stop(); | |
31 | } |
|
29 | } | |
32 |
|
30 | |||
33 | m_animation->setDuration(duration); |
|
31 | m_animation->setDuration(duration); | |
34 | m_animation->setEasingCurve(QEasingCurve::InOutBack); |
|
32 | m_animation->setEasingCurve(QEasingCurve::InOutBack); | |
35 | m_animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout)); |
|
33 | m_animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout)); | |
36 | m_animation->setKeyValueAt(1.0, qVariantFromValue(newLayout)); |
|
34 | m_animation->setKeyValueAt(1.0, qVariantFromValue(newLayout)); | |
37 | QTimer::singleShot(0,m_animation,SLOT(start())); |
|
35 | QTimer::singleShot(0,m_animation,SLOT(start())); | |
38 | } |
|
36 | } | |
39 |
|
37 | |||
40 | void AxisAnimationItem::setLabelsAngle(int angle) |
|
38 | void AxisAnimationItem::setLabelsAngle(int angle) | |
41 | { |
|
39 | { | |
42 | AxisItem::setLabelsAngle(angle); |
|
40 | AxisItem::setLabelsAngle(angle); | |
43 | } |
|
41 | } | |
44 |
|
42 | |||
45 | AxisAnimator::AxisAnimator(AxisItem *axis,QObject *parent): QVariantAnimation(parent), |
|
43 | AxisAnimator::AxisAnimator(AxisItem *axis,QObject *parent): QVariantAnimation(parent), | |
46 | m_axis(axis) |
|
44 | m_axis(axis) | |
47 | { |
|
45 | { | |
48 | } |
|
46 | } | |
49 |
|
47 | |||
50 | AxisAnimator::~AxisAnimator() |
|
48 | AxisAnimator::~AxisAnimator() | |
51 | { |
|
49 | { | |
52 | } |
|
50 | } | |
53 |
|
51 | |||
54 | QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const |
|
52 | QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const | |
55 | { |
|
53 | { | |
56 | QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start); |
|
54 | QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start); | |
57 | QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end); |
|
55 | QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end); | |
58 | QVector<qreal> result; |
|
56 | QVector<qreal> result; | |
59 | Q_ASSERT(startVector.count() == endVecotr.count()); |
|
57 | Q_ASSERT(startVector.count() == endVecotr.count()); | |
60 |
|
58 | |||
61 | for(int i =0 ;i< startVector.count();i++){ |
|
59 | for(int i =0 ;i< startVector.count();i++){ | |
62 | qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0)); |
|
60 | qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0)); | |
63 | result << value; |
|
61 | result << value; | |
64 | } |
|
62 | } | |
65 | return qVariantFromValue(result); |
|
63 | return qVariantFromValue(result); | |
66 | } |
|
64 | } | |
67 |
|
65 | |||
68 |
|
66 | |||
69 | void AxisAnimator::updateCurrentValue (const QVariant & value ) |
|
67 | void AxisAnimator::updateCurrentValue (const QVariant & value ) | |
70 | { |
|
68 | { | |
71 | QVector<qreal> vector = qVariantValue<QVector<qreal> >(value); |
|
69 | QVector<qreal> vector = qVariantValue<QVector<qreal> >(value); | |
72 | m_axis->setLayout(vector); |
|
70 | m_axis->setLayout(vector); | |
73 | } |
|
71 | } | |
74 |
|
72 | |||
75 | #include "moc_axisanimationitem_p.cpp" |
|
73 | #include "moc_axisanimationitem_p.cpp" | |
76 |
|
74 | |||
77 | QTCOMMERCIALCHART_END_NAMESPACE |
|
75 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -1,45 +1,46 | |||||
1 | #ifndef AXISANIMATIONITEM_H_ |
|
1 | #ifndef AXISANIMATIONITEM_H_ | |
2 | #define AXISANIMATIONITEM_H_ |
|
2 | #define AXISANIMATIONITEM_H_ | |
3 |
|
3 | |||
4 | #include "domain_p.h" |
|
4 | #include "domain_p.h" | |
5 | #include "axisitem_p.h" |
|
5 | #include "axisitem_p.h" | |
6 | #include <QGraphicsItem> |
|
6 | #include <QGraphicsItem> | |
7 | #include <QVariantAnimation> |
|
7 | #include <QVariantAnimation> | |
8 |
|
8 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
10 |
|
10 | |||
11 | class AxisAnimator; |
|
11 | class AxisAnimator; | |
12 |
|
12 | |||
13 | class AxisAnimationItem : public AxisItem |
|
13 | class AxisAnimationItem : public AxisItem | |
14 | { |
|
14 | { | |
15 | Q_OBJECT |
|
15 | Q_OBJECT | |
16 |
|
16 | |||
17 | public: |
|
17 | public: | |
18 | AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); |
|
18 | AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); | |
19 | ~AxisAnimationItem(); |
|
19 | ~AxisAnimationItem(); | |
20 |
|
20 | |||
21 | void setLabelsAngle(int angle); |
|
21 | void setLabelsAngle(int angle); | |
22 |
|
22 | |||
23 | protected: |
|
23 | protected: | |
24 |
virtual void update |
|
24 | virtual void updateLayout(QVector<qreal>& layout); | |
|
25 | ||||
25 | private: |
|
26 | private: | |
26 | AxisAnimator *m_animation; |
|
27 | AxisAnimator *m_animation; | |
27 | }; |
|
28 | }; | |
28 |
|
29 | |||
29 | class AxisAnimator: public QVariantAnimation |
|
30 | class AxisAnimator: public QVariantAnimation | |
30 | { |
|
31 | { | |
31 | public: |
|
32 | public: | |
32 | AxisAnimator(AxisItem *axis,QObject *parent = 0); |
|
33 | AxisAnimator(AxisItem *axis,QObject *parent = 0); | |
33 | ~AxisAnimator(); |
|
34 | ~AxisAnimator(); | |
34 | protected: |
|
35 | protected: | |
35 | virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const; |
|
36 | virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const; | |
36 | virtual void updateCurrentValue (const QVariant & value ); |
|
37 | virtual void updateCurrentValue (const QVariant & value ); | |
37 | private: |
|
38 | private: | |
38 | AxisItem* m_axis; |
|
39 | AxisItem* m_axis; | |
39 | }; |
|
40 | }; | |
40 |
|
41 | |||
41 | QTCOMMERCIALCHART_END_NAMESPACE |
|
42 | QTCOMMERCIALCHART_END_NAMESPACE | |
42 |
|
43 | |||
43 |
|
44 | |||
44 |
|
45 | |||
45 | #endif /* AXISITEM_H_ */ |
|
46 | #endif /* AXISITEM_H_ */ |
@@ -1,397 +1,416 | |||||
1 | #include "axisitem_p.h" |
|
1 | #include "axisitem_p.h" | |
2 | #include "qchartaxis.h" |
|
2 | #include "qchartaxis.h" | |
3 | #include "chartpresenter_p.h" |
|
3 | #include "chartpresenter_p.h" | |
4 | #include <QPainter> |
|
4 | #include <QPainter> | |
5 | #include <QDebug> |
|
5 | #include <QDebug> | |
6 |
|
6 | |||
7 | static int label_padding = 5; |
|
7 | static int label_padding = 5; | |
8 |
|
8 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
10 |
|
10 | |||
11 | AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) : |
|
11 | AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) : | |
12 | ChartItem(parent), |
|
12 | ChartItem(parent), | |
13 | m_chartAxis(axis), |
|
13 | m_chartAxis(axis), | |
14 | m_type(type), |
|
14 | m_type(type), | |
15 | m_labelsAngle(0), |
|
15 | m_labelsAngle(0), | |
16 | m_grid(parent), |
|
16 | m_grid(parent), | |
17 | m_shades(parent), |
|
17 | m_shades(parent), | |
18 | m_labels(parent), |
|
18 | m_labels(parent), | |
19 | m_axis(parent) |
|
19 | m_axis(parent), | |
|
20 | m_min(0), | |||
|
21 | m_max(0), | |||
|
22 | m_ticksCount(0) | |||
20 | { |
|
23 | { | |
21 | //initial initialization |
|
24 | //initial initialization | |
22 | m_axis.setZValue(ChartPresenter::AxisZValue); |
|
25 | m_axis.setZValue(ChartPresenter::AxisZValue); | |
23 | m_shades.setZValue(ChartPresenter::ShadesZValue); |
|
26 | m_shades.setZValue(ChartPresenter::ShadesZValue); | |
24 | m_grid.setZValue(ChartPresenter::GridZValue); |
|
27 | m_grid.setZValue(ChartPresenter::GridZValue); | |
25 | setFlags(QGraphicsItem::ItemHasNoContents); |
|
28 | setFlags(QGraphicsItem::ItemHasNoContents); | |
26 |
|
29 | |||
27 | QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated())); |
|
30 | QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated())); | |
28 | QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated())); |
|
31 | QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated())); | |
|
32 | ||||
|
33 | handleAxisUpdated(); | |||
29 | } |
|
34 | } | |
30 |
|
35 | |||
31 | AxisItem::~AxisItem() |
|
36 | AxisItem::~AxisItem() | |
32 | { |
|
37 | { | |
33 | } |
|
38 | } | |
34 |
|
39 | |||
35 | QRectF AxisItem::boundingRect() const |
|
40 | QRectF AxisItem::boundingRect() const | |
36 | { |
|
41 | { | |
37 | return QRectF(); |
|
42 | return QRectF(); | |
38 | } |
|
43 | } | |
39 |
|
44 | |||
40 | void AxisItem::createItems(int count) |
|
45 | void AxisItem::createItems(int count) | |
41 | { |
|
46 | { | |
42 | if(m_axis.children().size()==0) |
|
47 | if(m_axis.children().size()==0) | |
43 | m_axis.addToGroup(new QGraphicsLineItem()); |
|
48 | m_axis.addToGroup(new QGraphicsLineItem()); | |
44 | for (int i = 0; i < count; ++i) { |
|
49 | for (int i = 0; i < count; ++i) { | |
45 | m_grid.addToGroup(new QGraphicsLineItem()); |
|
50 | m_grid.addToGroup(new QGraphicsLineItem()); | |
46 | m_labels.addToGroup(new QGraphicsSimpleTextItem()); |
|
51 | m_labels.addToGroup(new QGraphicsSimpleTextItem()); | |
47 | if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem()); |
|
52 | if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem()); | |
48 | m_axis.addToGroup(new QGraphicsLineItem()); |
|
53 | m_axis.addToGroup(new QGraphicsLineItem()); | |
49 | } |
|
54 | } | |
50 | } |
|
55 | } | |
51 |
|
56 | |||
52 |
void AxisItem:: |
|
57 | void AxisItem::deleteItems(int count) | |
53 | { |
|
58 | { | |
54 | QList<QGraphicsItem *> lines = m_grid.childItems(); |
|
59 | QList<QGraphicsItem *> lines = m_grid.childItems(); | |
55 | QList<QGraphicsItem *> labels = m_labels.childItems(); |
|
60 | QList<QGraphicsItem *> labels = m_labels.childItems(); | |
56 | QList<QGraphicsItem *> shades = m_shades.childItems(); |
|
61 | QList<QGraphicsItem *> shades = m_shades.childItems(); | |
57 | QList<QGraphicsItem *> axis = m_axis.childItems(); |
|
62 | QList<QGraphicsItem *> axis = m_axis.childItems(); | |
58 |
|
63 | |||
59 | for (int i = 0; i < count; ++i) { |
|
64 | for (int i = 0; i < count; ++i) { | |
60 | delete(lines.takeLast()); |
|
65 | delete(lines.takeLast()); | |
61 | delete(labels.takeLast()); |
|
66 | delete(labels.takeLast()); | |
62 | if(lines.size()%2) delete(shades.takeLast()); |
|
67 | if(lines.size()%2) delete(shades.takeLast()); | |
63 | delete(axis.takeLast()); |
|
68 | delete(axis.takeLast()); | |
64 | } |
|
69 | } | |
65 | } |
|
70 | } | |
66 |
|
71 | |||
67 | void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) |
|
72 | void AxisItem::updateLayout(QVector<qreal>& layout) | |
68 | { |
|
73 | { | |
69 | Q_UNUSED(painter); |
|
|||
70 | Q_UNUSED(option); |
|
|||
71 | Q_UNUSED(widget); |
|
|||
72 | } |
|
|||
73 |
|
||||
74 | void AxisItem::updateItem() |
|
|||
75 | { |
|
|||
76 | QStringList labels = createLabels(m_ticks,m_min,m_max); |
|
|||
77 |
|
||||
78 | int diff = m_thicksList.size() - labels.size(); |
|
|||
79 |
|
||||
80 | if(diff>0) { |
|
|||
81 | clear(diff); |
|
|||
82 | } |
|
|||
83 | else if(diff<0) { |
|
|||
84 | createItems(-diff); |
|
|||
85 | } |
|
|||
86 |
|
||||
87 | if(diff!=0) handleAxisUpdated(); |
|
|||
88 |
|
||||
89 | m_thicksList=labels; |
|
|||
90 |
|
||||
91 | QVector<qreal> layout = calculateLayout(); |
|
|||
92 | if(layout.count()==0) return; |
|
|||
93 | setLayout(layout); |
|
74 | setLayout(layout); | |
94 |
|
||||
95 | } |
|
75 | } | |
96 |
|
76 | |||
97 | QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) |
|
77 | QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const | |
98 | { |
|
78 | { | |
99 | Q_ASSERT(max>=min); |
|
79 | Q_ASSERT(max>=min); | |
|
80 | Q_ASSERT(ticks>0); | |||
100 |
|
81 | |||
101 | QStringList labels; |
|
82 | QStringList labels; | |
102 |
|
83 | |||
103 | QChartAxisCategories* categories = m_chartAxis->categories(); |
|
84 | QChartAxisCategories* categories = m_chartAxis->categories(); | |
104 |
|
85 | |||
105 |
for(int i=0; i< |
|
86 | for(int i=0; i< ticks; i++) { | |
106 | qreal value = min + (i * (max - min)/ ticks); |
|
87 | qreal value = min + (i * (max - min)/ (ticks-1)); | |
107 | if(categories->count()==0) { |
|
88 | if(categories->count()==0) { | |
108 | labels << QString::number(value); |
|
89 | labels << QString::number(value); | |
109 | } |
|
90 | } | |
110 | else { |
|
91 | else { | |
111 | QString label = categories->label(value); |
|
92 | QString label = categories->label(value); | |
112 | labels << label; |
|
93 | labels << label; | |
113 | } |
|
94 | } | |
114 | } |
|
95 | } | |
|
96 | ||||
|
97 | ||||
115 | return labels; |
|
98 | return labels; | |
116 | } |
|
99 | } | |
117 |
|
100 | |||
118 | void AxisItem::setAxisOpacity(qreal opacity) |
|
101 | void AxisItem::setAxisOpacity(qreal opacity) | |
119 | { |
|
102 | { | |
120 | m_axis.setOpacity(opacity); |
|
103 | m_axis.setOpacity(opacity); | |
121 | } |
|
104 | } | |
122 |
|
105 | |||
123 | qreal AxisItem::axisOpacity() const |
|
106 | qreal AxisItem::axisOpacity() const | |
124 | { |
|
107 | { | |
125 | return m_axis.opacity(); |
|
108 | return m_axis.opacity(); | |
126 | } |
|
109 | } | |
127 |
|
110 | |||
128 | void AxisItem::setGridOpacity(qreal opacity) |
|
111 | void AxisItem::setGridOpacity(qreal opacity) | |
129 | { |
|
112 | { | |
130 | m_grid.setOpacity(opacity); |
|
113 | m_grid.setOpacity(opacity); | |
131 | } |
|
114 | } | |
132 |
|
115 | |||
133 | qreal AxisItem::gridOpacity() const |
|
116 | qreal AxisItem::gridOpacity() const | |
134 | { |
|
117 | { | |
135 | return m_grid.opacity(); |
|
118 | return m_grid.opacity(); | |
136 | } |
|
119 | } | |
137 |
|
120 | |||
138 | void AxisItem::setLabelsOpacity(qreal opacity) |
|
121 | void AxisItem::setLabelsOpacity(qreal opacity) | |
139 | { |
|
122 | { | |
140 | m_labels.setOpacity(opacity); |
|
123 | m_labels.setOpacity(opacity); | |
141 | } |
|
124 | } | |
142 |
|
125 | |||
143 | qreal AxisItem::labelsOpacity() const |
|
126 | qreal AxisItem::labelsOpacity() const | |
144 | { |
|
127 | { | |
145 | return m_labels.opacity(); |
|
128 | return m_labels.opacity(); | |
146 | } |
|
129 | } | |
147 |
|
130 | |||
148 | void AxisItem::setShadesOpacity(qreal opacity) |
|
131 | void AxisItem::setShadesOpacity(qreal opacity) | |
149 | { |
|
132 | { | |
150 | m_shades.setOpacity(opacity); |
|
133 | m_shades.setOpacity(opacity); | |
151 | } |
|
134 | } | |
152 |
|
135 | |||
153 | qreal AxisItem::shadesOpacity() const |
|
136 | qreal AxisItem::shadesOpacity() const | |
154 | { |
|
137 | { | |
155 | return m_shades.opacity(); |
|
138 | return m_shades.opacity(); | |
156 | } |
|
139 | } | |
157 |
|
140 | |||
158 | void AxisItem::setLabelsAngle(int angle) |
|
141 | void AxisItem::setLabelsAngle(int angle) | |
159 | { |
|
142 | { | |
160 | foreach(QGraphicsItem* item , m_labels.childItems()) { |
|
143 | foreach(QGraphicsItem* item , m_labels.childItems()) { | |
161 | QPointF center = item->boundingRect().center(); |
|
144 | QPointF center = item->boundingRect().center(); | |
162 | item->setRotation(angle); |
|
145 | item->setRotation(angle); | |
163 | } |
|
146 | } | |
164 |
|
147 | |||
165 | m_labelsAngle=angle; |
|
148 | m_labelsAngle=angle; | |
166 | } |
|
149 | } | |
167 |
|
150 | |||
168 | void AxisItem::setLabelsPen(const QPen& pen) |
|
151 | void AxisItem::setLabelsPen(const QPen& pen) | |
169 | { |
|
152 | { | |
170 | foreach(QGraphicsItem* item , m_labels.childItems()) { |
|
153 | foreach(QGraphicsItem* item , m_labels.childItems()) { | |
171 | static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen); |
|
154 | static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen); | |
172 | } |
|
155 | } | |
173 | } |
|
156 | } | |
174 |
|
157 | |||
175 | void AxisItem::setLabelsBrush(const QBrush& brush) |
|
158 | void AxisItem::setLabelsBrush(const QBrush& brush) | |
176 | { |
|
159 | { | |
177 | foreach(QGraphicsItem* item , m_labels.childItems()) { |
|
160 | foreach(QGraphicsItem* item , m_labels.childItems()) { | |
178 | static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush); |
|
161 | static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush); | |
179 | } |
|
162 | } | |
180 | } |
|
163 | } | |
181 |
|
164 | |||
182 | void AxisItem::setLabelsFont(const QFont& font) |
|
165 | void AxisItem::setLabelsFont(const QFont& font) | |
183 | { |
|
166 | { | |
184 | foreach(QGraphicsItem* item , m_labels.childItems()) { |
|
167 | foreach(QGraphicsItem* item , m_labels.childItems()) { | |
185 | static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font); |
|
168 | static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font); | |
186 | } |
|
169 | } | |
187 | } |
|
170 | } | |
188 |
|
171 | |||
189 | void AxisItem::setShadesBrush(const QBrush& brush) |
|
172 | void AxisItem::setShadesBrush(const QBrush& brush) | |
190 | { |
|
173 | { | |
191 | foreach(QGraphicsItem* item , m_shades.childItems()) { |
|
174 | foreach(QGraphicsItem* item , m_shades.childItems()) { | |
192 | static_cast<QGraphicsRectItem*>(item)->setBrush(brush); |
|
175 | static_cast<QGraphicsRectItem*>(item)->setBrush(brush); | |
193 | } |
|
176 | } | |
194 | } |
|
177 | } | |
195 |
|
178 | |||
196 | void AxisItem::setShadesPen(const QPen& pen) |
|
179 | void AxisItem::setShadesPen(const QPen& pen) | |
197 | { |
|
180 | { | |
198 | foreach(QGraphicsItem* item , m_shades.childItems()) { |
|
181 | foreach(QGraphicsItem* item , m_shades.childItems()) { | |
199 | static_cast<QGraphicsRectItem*>(item)->setPen(pen); |
|
182 | static_cast<QGraphicsRectItem*>(item)->setPen(pen); | |
200 | } |
|
183 | } | |
201 | } |
|
184 | } | |
202 |
|
185 | |||
203 | void AxisItem::setAxisPen(const QPen& pen) |
|
186 | void AxisItem::setAxisPen(const QPen& pen) | |
204 | { |
|
187 | { | |
205 | foreach(QGraphicsItem* item , m_axis.childItems()) { |
|
188 | foreach(QGraphicsItem* item , m_axis.childItems()) { | |
206 | static_cast<QGraphicsLineItem*>(item)->setPen(pen); |
|
189 | static_cast<QGraphicsLineItem*>(item)->setPen(pen); | |
207 | } |
|
190 | } | |
208 | } |
|
191 | } | |
209 |
|
192 | |||
210 | void AxisItem::setGridPen(const QPen& pen) |
|
193 | void AxisItem::setGridPen(const QPen& pen) | |
211 | { |
|
194 | { | |
212 | foreach(QGraphicsItem* item , m_grid.childItems()) { |
|
195 | foreach(QGraphicsItem* item , m_grid.childItems()) { | |
213 | static_cast<QGraphicsLineItem*>(item)->setPen(pen); |
|
196 | static_cast<QGraphicsLineItem*>(item)->setPen(pen); | |
214 | } |
|
197 | } | |
215 | } |
|
198 | } | |
216 |
|
199 | |||
217 | QVector<qreal> AxisItem::calculateLayout() const |
|
200 | QVector<qreal> AxisItem::calculateLayout() const | |
218 | { |
|
201 | { | |
|
202 | Q_ASSERT(m_ticksCount>=2); | |||
|
203 | ||||
219 | QVector<qreal> points; |
|
204 | QVector<qreal> points; | |
220 |
points.resize(m_t |
|
205 | points.resize(m_ticksCount); | |
221 |
|
206 | |||
222 | switch (m_type) |
|
207 | switch (m_type) | |
223 | { |
|
208 | { | |
224 | case X_AXIS: |
|
209 | case X_AXIS: | |
225 | { |
|
210 | { | |
226 |
const qreal deltaX = m_rect.width()/(m_t |
|
211 | const qreal deltaX = m_rect.width()/(m_ticksCount-1); | |
227 |
for (int i = 0; i < m_t |
|
212 | for (int i = 0; i < m_ticksCount; ++i) { | |
228 | int x = i * deltaX + m_rect.left(); |
|
213 | int x = i * deltaX + m_rect.left(); | |
229 | points[i] = x; |
|
214 | points[i] = x; | |
230 | } |
|
215 | } | |
231 | } |
|
216 | } | |
232 | break; |
|
217 | break; | |
233 | case Y_AXIS: |
|
218 | case Y_AXIS: | |
234 | { |
|
219 | { | |
235 |
const qreal deltaY = m_rect.height()/(m_t |
|
220 | const qreal deltaY = m_rect.height()/(m_ticksCount-1); | |
236 |
for (int i = 0; i < m_t |
|
221 | for (int i = 0; i < m_ticksCount; ++i) { | |
237 | int y = i * -deltaY + m_rect.bottom(); |
|
222 | int y = i * -deltaY + m_rect.bottom(); | |
238 | points[i] = y; |
|
223 | points[i] = y; | |
239 | } |
|
224 | } | |
240 | } |
|
225 | } | |
241 | break; |
|
226 | break; | |
242 | } |
|
227 | } | |
243 | return points; |
|
228 | return points; | |
244 | } |
|
229 | } | |
245 |
|
230 | |||
246 |
void AxisItem::setLayout( |
|
231 | void AxisItem::setLayout(QVector<qreal>& layout) | |
247 | { |
|
232 | { | |
|
233 | int diff = m_layoutVector.size() - layout.size(); | |||
|
234 | ||||
|
235 | if(diff>0) { | |||
|
236 | deleteItems(diff); | |||
|
237 | } | |||
|
238 | else if(diff<0) { | |||
|
239 | createItems(-diff); | |||
|
240 | } | |||
248 |
|
241 | |||
249 |
|
|
242 | QList<QGraphicsItem *> lines = m_grid.childItems(); | |
250 |
|
|
243 | QList<QGraphicsItem *> labels = m_labels.childItems(); | |
251 |
|
|
244 | QList<QGraphicsItem *> shades = m_shades.childItems(); | |
252 |
|
|
245 | QList<QGraphicsItem *> axis = m_axis.childItems(); | |
253 |
|
246 | |||
254 |
|
|
247 | Q_ASSERT(labels.size() == m_ticksList.size()); | |
255 |
|
|
248 | Q_ASSERT(layout.size() == m_ticksList.size()); | |
256 |
|
249 | |||
257 |
|
|
250 | switch (m_type) | |
258 | { |
|
251 | { | |
259 |
|
|
252 | case X_AXIS: | |
260 | { |
|
253 | { | |
261 |
|
|
254 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); | |
262 |
|
|
255 | lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom()); | |
263 |
|
256 | |||
264 |
|
|
257 | for (int i = 0; i < layout.size(); ++i) { | |
265 |
|
|
258 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); | |
266 |
|
|
259 | lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom()); | |
267 |
|
|
260 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); | |
268 |
|
|
261 | labelItem->setText(m_ticksList.at(i)); | |
269 |
|
|
262 | QPointF center = labelItem->boundingRect().center(); | |
270 |
|
|
263 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
271 |
|
|
264 | labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding); | |
272 |
|
|
265 | if(i%2 && i+1 < layout.size()) { | |
273 |
|
|
266 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); | |
274 |
|
|
267 | rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height()); | |
275 | } |
|
268 | } | |
276 |
|
|
269 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1)); | |
277 |
|
|
270 | lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5); | |
278 | } |
|
271 | } | |
279 | } |
|
272 | } | |
280 | break; |
|
273 | break; | |
281 |
|
274 | |||
282 |
|
|
275 | case Y_AXIS: | |
283 | { |
|
276 | { | |
284 |
|
|
277 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0)); | |
285 |
|
|
278 | lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom()); | |
286 |
|
279 | |||
287 |
|
|
280 | for (int i = 0; i < layout.size(); ++i) { | |
288 |
|
|
281 | QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i)); | |
289 |
|
|
282 | lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]); | |
290 |
|
|
283 | QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i)); | |
291 |
|
|
284 | labelItem->setText(m_ticksList.at(i)); | |
292 |
|
|
285 | QPointF center = labelItem->boundingRect().center(); | |
293 |
|
|
286 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
294 |
|
|
287 | labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y()); | |
295 |
|
|
288 | if(i%2 && i+1 < layout.size()) { | |
296 |
|
|
289 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); | |
297 |
|
|
290 | rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]); | |
298 | } |
|
291 | } | |
299 |
|
|
292 | lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1)); | |
300 |
|
|
293 | lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]); | |
301 | } |
|
294 | } | |
302 | } |
|
295 | } | |
303 | break; |
|
296 | break; | |
304 | default: |
|
297 | default: | |
305 |
|
|
298 | qDebug()<<"Unknown axis type"; | |
306 | break; |
|
299 | break; | |
307 | } |
|
300 | } | |
308 |
|
301 | |||
|
302 | if(diff!=0) handleAxisUpdated(); | |||
309 |
|
|
303 | m_layoutVector=layout; | |
310 | } |
|
304 | } | |
311 |
|
305 | |||
|
306 | bool AxisItem::isEmpty() | |||
|
307 | { | |||
|
308 | return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0; | |||
|
309 | } | |||
|
310 | ||||
312 | //handlers |
|
311 | //handlers | |
313 |
|
312 | |||
314 | void AxisItem::handleAxisCategoriesUpdated() |
|
313 | void AxisItem::handleAxisCategoriesUpdated() | |
315 | { |
|
314 | { | |
316 | updateItem(); |
|
315 | if(isEmpty()) return; | |
|
316 | m_ticksList = createLabels(m_ticksCount,m_min,m_max); | |||
|
317 | updateLayout(m_layoutVector); | |||
317 | } |
|
318 | } | |
318 |
|
319 | |||
319 | void AxisItem::handleAxisUpdated() |
|
320 | void AxisItem::handleAxisUpdated() | |
320 | { |
|
321 | { | |
321 |
|
322 | |||
322 | int count = m_chartAxis->ticksCount(); |
|
323 | int count = m_chartAxis->ticksCount(); | |
323 |
|
324 | |||
324 | if(m_ticks!=count){ |
|
325 | if(m_ticksCount!=count){ | |
325 | m_ticks=count; |
|
326 | handleTicksCountChanged(count); | |
326 | updateItem(); |
|
|||
327 | } |
|
327 | } | |
328 |
|
328 | |||
329 | if(isEmpty()) return; |
|
329 | if(isEmpty()) return; | |
330 |
|
330 | |||
331 | if(m_chartAxis->isAxisVisible()) { |
|
331 | if(m_chartAxis->isAxisVisible()) { | |
332 | setAxisOpacity(100); |
|
332 | setAxisOpacity(100); | |
333 | } |
|
333 | } | |
334 | else { |
|
334 | else { | |
335 | setAxisOpacity(0); |
|
335 | setAxisOpacity(0); | |
336 | } |
|
336 | } | |
337 |
|
337 | |||
338 | if(m_chartAxis->isGridVisible()) { |
|
338 | if(m_chartAxis->isGridVisible()) { | |
339 | setGridOpacity(100); |
|
339 | setGridOpacity(100); | |
340 | } |
|
340 | } | |
341 | else { |
|
341 | else { | |
342 | setGridOpacity(0); |
|
342 | setGridOpacity(0); | |
343 | } |
|
343 | } | |
344 |
|
344 | |||
345 | if(m_chartAxis->labelsVisible()) |
|
345 | if(m_chartAxis->labelsVisible()) | |
346 | { |
|
346 | { | |
347 | setLabelsOpacity(100); |
|
347 | setLabelsOpacity(100); | |
348 | } |
|
348 | } | |
349 | else { |
|
349 | else { | |
350 | setLabelsOpacity(0); |
|
350 | setLabelsOpacity(0); | |
351 | } |
|
351 | } | |
352 |
|
352 | |||
353 | if(m_chartAxis->shadesVisible()) { |
|
353 | if(m_chartAxis->shadesVisible()) { | |
354 | setShadesOpacity(m_chartAxis->shadesOpacity()); |
|
354 | setShadesOpacity(m_chartAxis->shadesOpacity()); | |
355 | } |
|
355 | } | |
356 | else { |
|
356 | else { | |
357 | setShadesOpacity(0); |
|
357 | setShadesOpacity(0); | |
358 | } |
|
358 | } | |
359 |
|
359 | |||
360 | setLabelsAngle(m_chartAxis->labelsAngle()); |
|
360 | setLabelsAngle(m_chartAxis->labelsAngle()); | |
361 | setAxisPen(m_chartAxis->axisPen()); |
|
361 | setAxisPen(m_chartAxis->axisPen()); | |
362 | setLabelsPen(m_chartAxis->labelsPen()); |
|
362 | setLabelsPen(m_chartAxis->labelsPen()); | |
363 | setLabelsBrush(m_chartAxis->labelsBrush()); |
|
363 | setLabelsBrush(m_chartAxis->labelsBrush()); | |
364 | setLabelsFont(m_chartAxis->labelsFont()); |
|
364 | setLabelsFont(m_chartAxis->labelsFont()); | |
365 | setGridPen(m_chartAxis->gridPen()); |
|
365 | setGridPen(m_chartAxis->gridPen()); | |
366 | setShadesPen(m_chartAxis->shadesPen()); |
|
366 | setShadesPen(m_chartAxis->shadesPen()); | |
367 | setShadesBrush(m_chartAxis->shadesBrush()); |
|
367 | setShadesBrush(m_chartAxis->shadesBrush()); | |
368 |
|
368 | |||
369 | } |
|
369 | } | |
370 |
|
370 | |||
|
371 | void AxisItem::handleTicksCountChanged(int count) | |||
|
372 | { | |||
|
373 | m_ticksCount=count; | |||
|
374 | ||||
|
375 | if(isEmpty()) return; | |||
|
376 | m_ticksList = createLabels(m_ticksCount,m_min,m_max); | |||
|
377 | QVector<qreal> layout = calculateLayout(); | |||
|
378 | updateLayout(layout); | |||
|
379 | } | |||
|
380 | ||||
371 | void AxisItem::handleRangeChanged(qreal min, qreal max) |
|
381 | void AxisItem::handleRangeChanged(qreal min, qreal max) | |
372 | { |
|
382 | { | |
373 |
|
383 | |||
374 | m_min = min; |
|
384 | m_min = min; | |
375 | m_max = max; |
|
385 | m_max = max; | |
376 |
|
386 | |||
377 | if(isEmpty()) return; |
|
387 | if(isEmpty()) return; | |
378 | updateItem(); |
|
388 | m_ticksList = createLabels(m_ticksCount,m_min,m_max); | |
|
389 | QVector<qreal> layout = calculateLayout(); | |||
|
390 | updateLayout(layout); | |||
379 |
|
391 | |||
380 | } |
|
392 | } | |
381 |
|
393 | |||
382 | void AxisItem::handleGeometryChanged(const QRectF& rect) |
|
394 | void AxisItem::handleGeometryChanged(const QRectF& rect) | |
383 | { |
|
395 | { | |
|
396 | ||||
384 | m_rect = rect; |
|
397 | m_rect = rect; | |
385 | if(isEmpty()) return; |
|
398 | if(isEmpty()) return; | |
386 | updateItem(); |
|
399 | m_ticksList = createLabels(m_ticksCount,m_min,m_max); | |
|
400 | QVector<qreal> layout = calculateLayout(); | |||
|
401 | updateLayout(layout); | |||
387 | } |
|
402 | } | |
388 |
|
403 | |||
389 | bool AxisItem::isEmpty() |
|
404 | //painter | |
|
405 | ||||
|
406 | void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) | |||
390 | { |
|
407 | { | |
391 | return m_rect.isEmpty() || m_min==m_max || m_ticks==0; |
|
408 | Q_UNUSED(painter); | |
|
409 | Q_UNUSED(option); | |||
|
410 | Q_UNUSED(widget); | |||
392 | } |
|
411 | } | |
393 |
|
412 | |||
394 | //TODO "nice numbers algorithm" |
|
413 | //TODO "nice numbers algorithm" | |
395 | #include "moc_axisitem_p.cpp" |
|
414 | #include "moc_axisitem_p.cpp" | |
396 |
|
415 | |||
397 | QTCOMMERCIALCHART_END_NAMESPACE |
|
416 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -1,89 +1,90 | |||||
1 | #ifndef AXISITEM_H_ |
|
1 | #ifndef AXISITEM_H_ | |
2 | #define AXISITEM_H_ |
|
2 | #define AXISITEM_H_ | |
3 |
|
3 | |||
4 | #include "domain_p.h" |
|
4 | #include "domain_p.h" | |
5 | #include "chartitem_p.h" |
|
5 | #include "chartitem_p.h" | |
6 | #include <QGraphicsItem> |
|
6 | #include <QGraphicsItem> | |
7 |
|
7 | |||
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
9 |
|
9 | |||
10 | class QChartAxis; |
|
10 | class QChartAxis; | |
11 |
|
11 | |||
12 | class AxisItem : public QObject, public ChartItem |
|
12 | class AxisItem : public QObject, public ChartItem | |
13 | { |
|
13 | { | |
14 | Q_OBJECT |
|
14 | Q_OBJECT | |
15 | public: |
|
15 | public: | |
16 | enum AxisType{X_AXIS,Y_AXIS}; |
|
16 | enum AxisType{X_AXIS,Y_AXIS}; | |
17 |
|
17 | |||
18 | AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); |
|
18 | AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); | |
19 | ~AxisItem(); |
|
19 | ~AxisItem(); | |
20 |
|
20 | |||
21 | //from QGraphicsItem |
|
21 | //from QGraphicsItem | |
22 | QRectF boundingRect() const; |
|
22 | QRectF boundingRect() const; | |
23 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); |
|
23 | void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); | |
24 |
|
24 | |||
25 | AxisType axisType() const {return m_type;}; |
|
25 | AxisType axisType() const {return m_type;}; | |
26 |
|
26 | |||
27 | void setAxisOpacity(qreal opacity); |
|
27 | void setAxisOpacity(qreal opacity); | |
28 | qreal axisOpacity() const; |
|
28 | qreal axisOpacity() const; | |
29 |
|
29 | |||
30 | void setGridOpacity(qreal opacity); |
|
30 | void setGridOpacity(qreal opacity); | |
31 | qreal gridOpacity() const; |
|
31 | qreal gridOpacity() const; | |
32 |
|
32 | |||
33 | void setLabelsOpacity(qreal opacity); |
|
33 | void setLabelsOpacity(qreal opacity); | |
34 | qreal labelsOpacity() const; |
|
34 | qreal labelsOpacity() const; | |
35 |
|
35 | |||
36 | void setShadesOpacity(qreal opacity); |
|
36 | void setShadesOpacity(qreal opacity); | |
37 | qreal shadesOpacity() const; |
|
37 | qreal shadesOpacity() const; | |
38 |
|
38 | |||
39 | void setLabelsAngle(int angle); |
|
39 | void setLabelsAngle(int angle); | |
40 | int labelsAngle()const { return m_labelsAngle; } |
|
40 | int labelsAngle()const { return m_labelsAngle; } | |
41 |
|
41 | |||
42 | void setShadesBrush(const QBrush& brush); |
|
42 | void setShadesBrush(const QBrush& brush); | |
43 | void setShadesPen(const QPen& pen); |
|
43 | void setShadesPen(const QPen& pen); | |
44 |
|
44 | |||
45 | void setAxisPen(const QPen& pen); |
|
45 | void setAxisPen(const QPen& pen); | |
46 | void setGridPen(const QPen& pen); |
|
46 | void setGridPen(const QPen& pen); | |
47 |
|
47 | |||
48 | void setLabelsPen(const QPen& pen); |
|
48 | void setLabelsPen(const QPen& pen); | |
49 | void setLabelsBrush(const QBrush& brush); |
|
49 | void setLabelsBrush(const QBrush& brush); | |
50 | void setLabelsFont(const QFont& font); |
|
50 | void setLabelsFont(const QFont& font); | |
51 |
|
51 | |||
52 | public slots: |
|
52 | public slots: | |
53 |
void handleAxisUpdated(); |
|
53 | void handleAxisUpdated(); | |
54 |
void handleAxisCategoriesUpdated(); |
|
54 | void handleAxisCategoriesUpdated(); | |
55 |
void handleRangeChanged(qreal min , qreal max); |
|
55 | void handleRangeChanged(qreal min , qreal max); | |
56 | void handleGeometryChanged(const QRectF& size); //geometry update calls |
|
56 | void handleTicksCountChanged(int count); | |
|
57 | void handleGeometryChanged(const QRectF& size); | |||
57 |
|
58 | |||
58 | public: |
|
59 | public: | |
59 |
virtual void update |
|
60 | virtual void updateLayout(QVector<qreal>& layout); | |
60 |
QVector<qreal> |
|
61 | void setLayout(QVector<qreal>& layout); | |
61 | void setLayout(const QVector<qreal>& points); |
|
|||
62 | QVector<qreal> layout() { return m_layoutVector;}; |
|
62 | QVector<qreal> layout() { return m_layoutVector;}; | |
63 |
|
63 | |||
64 | private: |
|
64 | private: | |
65 | inline bool isEmpty(); |
|
65 | inline bool isEmpty(); | |
66 | void clear(int count); |
|
|||
67 | void createItems(int count); |
|
66 | void createItems(int count); | |
68 | QStringList createLabels(int ticks, qreal min, qreal max); |
|
67 | void deleteItems(int count); | |
|
68 | QVector<qreal> calculateLayout() const; | |||
|
69 | QStringList createLabels(int ticks, qreal min, qreal max) const; | |||
69 |
|
70 | |||
70 | private: |
|
71 | private: | |
71 | QChartAxis* m_chartAxis; |
|
72 | QChartAxis* m_chartAxis; | |
72 | AxisType m_type; |
|
73 | AxisType m_type; | |
73 | QRectF m_rect; |
|
74 | QRectF m_rect; | |
74 | int m_labelsAngle; |
|
75 | int m_labelsAngle; | |
75 | QGraphicsItemGroup m_grid; |
|
76 | QGraphicsItemGroup m_grid; | |
76 | QGraphicsItemGroup m_shades; |
|
77 | QGraphicsItemGroup m_shades; | |
77 | QGraphicsItemGroup m_labels; |
|
78 | QGraphicsItemGroup m_labels; | |
78 | QGraphicsItemGroup m_axis; |
|
79 | QGraphicsItemGroup m_axis; | |
79 |
QStringList m_t |
|
80 | QStringList m_ticksList; | |
80 | QVector<qreal> m_layoutVector; |
|
81 | QVector<qreal> m_layoutVector; | |
81 | qreal m_min; |
|
82 | qreal m_min; | |
82 | qreal m_max; |
|
83 | qreal m_max; | |
83 | int m_ticks; |
|
84 | int m_ticksCount; | |
84 |
|
85 | |||
85 | }; |
|
86 | }; | |
86 |
|
87 | |||
87 | QTCOMMERCIALCHART_END_NAMESPACE |
|
88 | QTCOMMERCIALCHART_END_NAMESPACE | |
88 |
|
89 | |||
89 | #endif /* AXISITEM_H_ */ |
|
90 | #endif /* AXISITEM_H_ */ |
@@ -1,177 +1,178 | |||||
1 | #include "barpresenterbase_p.h" |
|
1 | #include "barpresenterbase_p.h" | |
2 | #include "bar_p.h" |
|
2 | #include "bar_p.h" | |
3 | #include "barvalue_p.h" |
|
3 | #include "barvalue_p.h" | |
4 | #include "separator_p.h" |
|
4 | #include "separator_p.h" | |
5 | #include "qbarset.h" |
|
5 | #include "qbarset.h" | |
6 | #include "qbarseries.h" |
|
6 | #include "qbarseries.h" | |
7 | #include "qchart.h" |
|
7 | #include "qchart.h" | |
8 | #include "qchartaxis.h" |
|
8 | #include "qchartaxis.h" | |
9 | #include "qchartaxiscategories.h" |
|
9 | #include "qchartaxiscategories.h" | |
10 | #include <QDebug> |
|
10 | #include <QDebug> | |
11 | #include <QToolTip> |
|
11 | #include <QToolTip> | |
12 |
|
12 | |||
13 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
13 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
14 |
|
14 | |||
15 | BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent) |
|
15 | BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent) | |
16 | : ChartItem(parent) |
|
16 | : ChartItem(parent) | |
17 | ,mLayoutSet(false) |
|
17 | ,mLayoutSet(false) | |
18 | ,mSeparatorsEnabled(false) |
|
18 | ,mSeparatorsEnabled(false) | |
19 | ,mSeries(series) |
|
19 | ,mSeries(series) | |
20 | ,mChart(parent) |
|
20 | ,mChart(parent) | |
21 | { |
|
21 | { | |
22 | connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString))); |
|
22 | connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString))); | |
23 | initAxisLabels(); |
|
23 | initAxisLabels(); | |
24 | dataChanged(); |
|
24 | dataChanged(); | |
25 | } |
|
25 | } | |
26 |
|
26 | |||
27 | BarPresenterBase::~BarPresenterBase() |
|
27 | BarPresenterBase::~BarPresenterBase() | |
28 | { |
|
28 | { | |
29 | disconnect(this,SLOT(showToolTip(QPoint,QString))); |
|
29 | disconnect(this,SLOT(showToolTip(QPoint,QString))); | |
30 | } |
|
30 | } | |
31 |
|
31 | |||
32 | void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) |
|
32 | void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) | |
33 | { |
|
33 | { | |
34 | if (!mLayoutSet) { |
|
34 | if (!mLayoutSet) { | |
35 | qDebug() << "BarPresenterBase::paint called without layout set. Aborting."; |
|
35 | qDebug() << "BarPresenterBase::paint called without layout set. Aborting."; | |
36 | return; |
|
36 | return; | |
37 | } |
|
37 | } | |
38 | foreach(QGraphicsItem* i, childItems()) { |
|
38 | foreach(QGraphicsItem* i, childItems()) { | |
39 | i->paint(painter,option,widget); |
|
39 | i->paint(painter,option,widget); | |
40 | } |
|
40 | } | |
41 | } |
|
41 | } | |
42 |
|
42 | |||
43 | QRectF BarPresenterBase::boundingRect() const |
|
43 | QRectF BarPresenterBase::boundingRect() const | |
44 | { |
|
44 | { | |
45 | return QRectF(0,0,mWidth,mHeight); |
|
45 | return QRectF(0,0,mWidth,mHeight); | |
46 | } |
|
46 | } | |
47 |
|
47 | |||
48 | void BarPresenterBase::dataChanged() |
|
48 | void BarPresenterBase::dataChanged() | |
49 | { |
|
49 | { | |
50 | // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them? |
|
50 | // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them? | |
51 | // Delete old bars |
|
51 | // Delete old bars | |
52 | foreach (QGraphicsItem* item, childItems()) { |
|
52 | foreach (QGraphicsItem* item, childItems()) { | |
53 | delete item; |
|
53 | delete item; | |
54 | } |
|
54 | } | |
55 |
|
55 | |||
56 | mBars.clear(); |
|
56 | mBars.clear(); | |
57 | mSeparators.clear(); |
|
57 | mSeparators.clear(); | |
58 | mFloatingValues.clear(); |
|
58 | mFloatingValues.clear(); | |
59 |
|
59 | |||
60 | // Create new graphic items for bars |
|
60 | // Create new graphic items for bars | |
61 | for (int c=0; c<mSeries->categoryCount(); c++) { |
|
61 | for (int c=0; c<mSeries->categoryCount(); c++) { | |
62 | QString category = mSeries->categoryName(c); |
|
62 | QString category = mSeries->categoryName(c); | |
63 | for (int s=0; s<mSeries->barsetCount(); s++) { |
|
63 | for (int s=0; s<mSeries->barsetCount(); s++) { | |
64 | QBarSet *set = mSeries->barsetAt(s); |
|
64 | QBarSet *set = mSeries->barsetAt(s); | |
65 | Bar *bar = new Bar(category,this); |
|
65 | Bar *bar = new Bar(category,this); | |
66 | childItems().append(bar); |
|
66 | childItems().append(bar); | |
67 | mBars.append(bar); |
|
67 | mBars.append(bar); | |
68 | connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString))); |
|
68 | connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString))); | |
69 | connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString))); |
|
69 | connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString))); | |
70 | connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint))); |
|
70 | connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint))); | |
71 | connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent())); |
|
71 | connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent())); | |
72 | } |
|
72 | } | |
73 | } |
|
73 | } | |
74 |
|
74 | |||
75 | // Create separators |
|
75 | // Create separators | |
76 | int count = mSeries->categoryCount() - 1; // There is one less separator than columns |
|
76 | int count = mSeries->categoryCount() - 1; // There is one less separator than columns | |
77 | for (int i=0; i<count; i++) { |
|
77 | for (int i=0; i<count; i++) { | |
78 | Separator* sep = new Separator(this); |
|
78 | Separator* sep = new Separator(this); | |
79 | sep->setColor(QColor(255,0,0,255)); // TODO: color for separations from theme |
|
79 | sep->setColor(QColor(255,0,0,255)); // TODO: color for separations from theme | |
80 | sep->setVisible(mSeparatorsEnabled); |
|
80 | sep->setVisible(mSeparatorsEnabled); | |
81 | childItems().append(sep); |
|
81 | childItems().append(sep); | |
82 | mSeparators.append(sep); |
|
82 | mSeparators.append(sep); | |
83 | } |
|
83 | } | |
84 |
|
84 | |||
85 | // Create floating values |
|
85 | // Create floating values | |
86 | for (int category=0; category<mSeries->categoryCount(); category++) { |
|
86 | for (int category=0; category<mSeries->categoryCount(); category++) { | |
87 | for (int s=0; s<mSeries->barsetCount(); s++) { |
|
87 | for (int s=0; s<mSeries->barsetCount(); s++) { | |
88 | QBarSet *set = mSeries->barsetAt(s); |
|
88 | QBarSet *set = mSeries->barsetAt(s); | |
89 | BarValue *value = new BarValue(*set, this); |
|
89 | BarValue *value = new BarValue(*set, this); | |
90 | childItems().append(value); |
|
90 | childItems().append(value); | |
91 | mFloatingValues.append(value); |
|
91 | mFloatingValues.append(value); | |
92 | connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible())); |
|
92 | connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible())); | |
93 | } |
|
93 | } | |
94 | } |
|
94 | } | |
95 | } |
|
95 | } | |
96 |
|
96 | |||
97 | void BarPresenterBase::initAxisLabels() |
|
97 | void BarPresenterBase::initAxisLabels() | |
98 | { |
|
98 | { | |
99 | int count = mSeries->categoryCount(); |
|
99 | int count = mSeries->categoryCount(); | |
100 | if (0 == count) { |
|
100 | if (0 == count) { | |
101 | return; |
|
101 | return; | |
102 | } |
|
102 | } | |
103 | count++; |
|
|||
104 |
|
103 | |||
105 | mChart->axisX()->setTicksCount(count); |
|
104 | mChart->axisX()->setTicksCount(count+2); | |
106 |
|
105 | |||
107 | qreal min = 0; |
|
106 | qreal min = 0; | |
108 | qreal max = count; |
|
107 | qreal max = count+1; | |
109 |
|
108 | |||
110 | mChart->axisX()->setMin(min); |
|
109 | mChart->axisX()->setMin(min); | |
111 | mChart->axisX()->setMax(max); |
|
110 | mChart->axisX()->setMax(max); | |
112 | min++; |
|
111 | ||
113 | QChartAxisCategories* categories = mChart->axisX()->categories(); |
|
112 | QChartAxisCategories* categories = mChart->axisX()->categories(); | |
114 | categories->clear(); |
|
113 | categories->clear(); | |
115 |
for (int i=0; i<count |
|
114 | for (int i=0; i<count; i++) { | |
116 |
categories->insert( |
|
115 | categories->insert(i+1,mSeries->categoryName(i)); | |
117 | min++; |
|
|||
118 | } |
|
116 | } | |
|
117 | ||||
|
118 | ||||
|
119 | ||||
119 | mChart->axisX()->setLabelsVisible(true); |
|
120 | mChart->axisX()->setLabelsVisible(true); | |
120 | } |
|
121 | } | |
121 |
|
122 | |||
122 | //handlers |
|
123 | //handlers | |
123 |
|
124 | |||
124 | void BarPresenterBase::handleModelChanged(int index) |
|
125 | void BarPresenterBase::handleModelChanged(int index) | |
125 | { |
|
126 | { | |
126 | // qDebug() << "BarPresenterBase::handleModelChanged" << index; |
|
127 | // qDebug() << "BarPresenterBase::handleModelChanged" << index; | |
127 | dataChanged(); |
|
128 | dataChanged(); | |
128 | } |
|
129 | } | |
129 |
|
130 | |||
130 | void BarPresenterBase::handleDomainChanged(const Domain& domain) |
|
131 | void BarPresenterBase::handleDomainChanged(const Domain& domain) | |
131 | { |
|
132 | { | |
132 | qDebug() << "BarPresenterBase::handleDomainChanged"; |
|
133 | qDebug() << "BarPresenterBase::handleDomainChanged"; | |
133 | /* |
|
134 | /* | |
134 | int count = mSeries->categoryCount(); |
|
135 | int count = mSeries->categoryCount(); | |
135 | if (0 == count) { |
|
136 | if (0 == count) { | |
136 | return; |
|
137 | return; | |
137 | } |
|
138 | } | |
138 |
|
139 | |||
139 | // Position labels to domain |
|
140 | // Position labels to domain | |
140 | qreal min = domain.minX(); |
|
141 | qreal min = domain.minX(); | |
141 | qreal max = domain.maxX(); |
|
142 | qreal max = domain.maxX(); | |
142 | qreal step = (max-min)/count; |
|
143 | qreal step = (max-min)/count; | |
143 | QChartAxisCategories& categories = mChart->axisX()->categories(); |
|
144 | QChartAxisCategories& categories = mChart->axisX()->categories(); | |
144 | categories.clear(); |
|
145 | categories.clear(); | |
145 | for (int i=0; i<count; i++) { |
|
146 | for (int i=0; i<count; i++) { | |
146 | categories.insert(min,mSeries->categoryName(i)); |
|
147 | categories.insert(min,mSeries->categoryName(i)); | |
147 | min += step; |
|
148 | min += step; | |
148 | } |
|
149 | } | |
149 | */ |
|
150 | */ | |
150 | } |
|
151 | } | |
151 |
|
152 | |||
152 | void BarPresenterBase::handleGeometryChanged(const QRectF& rect) |
|
153 | void BarPresenterBase::handleGeometryChanged(const QRectF& rect) | |
153 | { |
|
154 | { | |
154 | mWidth = rect.width(); |
|
155 | mWidth = rect.width(); | |
155 | mHeight = rect.height(); |
|
156 | mHeight = rect.height(); | |
156 | layoutChanged(); |
|
157 | layoutChanged(); | |
157 | mLayoutSet = true; |
|
158 | mLayoutSet = true; | |
158 | setPos(rect.topLeft()); |
|
159 | setPos(rect.topLeft()); | |
159 | } |
|
160 | } | |
160 |
|
161 | |||
161 | void BarPresenterBase::showToolTip(QPoint pos, QString tip) |
|
162 | void BarPresenterBase::showToolTip(QPoint pos, QString tip) | |
162 | { |
|
163 | { | |
163 | // TODO: cool tooltip instead of default |
|
164 | // TODO: cool tooltip instead of default | |
164 | QToolTip::showText(pos,tip); |
|
165 | QToolTip::showText(pos,tip); | |
165 | } |
|
166 | } | |
166 |
|
167 | |||
167 | void BarPresenterBase::enableSeparators(bool enabled) |
|
168 | void BarPresenterBase::enableSeparators(bool enabled) | |
168 | { |
|
169 | { | |
169 | for (int i=0; i<mSeparators.count(); i++) { |
|
170 | for (int i=0; i<mSeparators.count(); i++) { | |
170 | mSeparators.at(i)->setVisible(enabled); |
|
171 | mSeparators.at(i)->setVisible(enabled); | |
171 | } |
|
172 | } | |
172 | mSeparatorsEnabled = enabled; |
|
173 | mSeparatorsEnabled = enabled; | |
173 | } |
|
174 | } | |
174 |
|
175 | |||
175 | #include "moc_barpresenterbase_p.cpp" |
|
176 | #include "moc_barpresenterbase_p.cpp" | |
176 |
|
177 | |||
177 | QTCOMMERCIALCHART_END_NAMESPACE |
|
178 | QTCOMMERCIALCHART_END_NAMESPACE |
General Comments 0
You need to be logged in to leave comments.
Login now