@@ -0,0 +1,13 | |||||
|
1 | INCLUDEPATH += $$PWD | |||
|
2 | DEPENDPATH += $$PWD | |||
|
3 | ||||
|
4 | SOURCES += \ | |||
|
5 | $$PWD/axisanimation.cpp \ | |||
|
6 | $$PWD/chartanimator.cpp \ | |||
|
7 | $$PWD/xyanimation.cpp | |||
|
8 | ||||
|
9 | PRIVATE_HEADERS += \ | |||
|
10 | $$PWD/axisanimation_p.h \ | |||
|
11 | $$PWD/chartanimator_p.h \ | |||
|
12 | $$PWD/chartanimation_p.h \ | |||
|
13 | $$PWD/xyanimation_p.h No newline at end of file |
@@ -0,0 +1,45 | |||||
|
1 | #include "axisanimation_p.h" | |||
|
2 | #include <QTimer> | |||
|
3 | ||||
|
4 | Q_DECLARE_METATYPE(QVector<qreal>) | |||
|
5 | ||||
|
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
|
7 | ||||
|
8 | ||||
|
9 | AxisAnimation::AxisAnimation(AxisItem *axis): ChartAnimation(axis), | |||
|
10 | m_axis(axis) | |||
|
11 | { | |||
|
12 | } | |||
|
13 | ||||
|
14 | AxisAnimation::~AxisAnimation() | |||
|
15 | { | |||
|
16 | } | |||
|
17 | ||||
|
18 | QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const | |||
|
19 | { | |||
|
20 | QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start); | |||
|
21 | QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end); | |||
|
22 | QVector<qreal> result; | |||
|
23 | ||||
|
24 | Q_ASSERT(startVector.count() == endVecotr.count()) ; | |||
|
25 | ||||
|
26 | for(int i =0 ;i< startVector.count();i++){ | |||
|
27 | qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0)); | |||
|
28 | result << value; | |||
|
29 | } | |||
|
30 | return qVariantFromValue(result); | |||
|
31 | } | |||
|
32 | ||||
|
33 | ||||
|
34 | void AxisAnimation::updateCurrentValue (const QVariant & value ) | |||
|
35 | { | |||
|
36 | if(state()!=QAbstractAnimation::Stopped)//workaround | |||
|
37 | { | |||
|
38 | QVector<qreal> vector = qVariantValue<QVector<qreal> >(value); | |||
|
39 | Q_ASSERT(vector.count()!=0); | |||
|
40 | m_axis->setLayout(vector); | |||
|
41 | } | |||
|
42 | ||||
|
43 | } | |||
|
44 | ||||
|
45 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -0,0 +1,19 | |||||
|
1 | #ifndef CHARTANIMATION_H_ | |||
|
2 | #define CHARTANIMATION_H_ | |||
|
3 | ||||
|
4 | #include "qchartglobal.h" | |||
|
5 | #include <QVariantAnimation> | |||
|
6 | ||||
|
7 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
|
8 | ||||
|
9 | class ChartAnimation: public QVariantAnimation | |||
|
10 | { | |||
|
11 | public: | |||
|
12 | ChartAnimation(QObject* parent=0):QVariantAnimation(parent){}; | |||
|
13 | }; | |||
|
14 | ||||
|
15 | QTCOMMERCIALCHART_END_NAMESPACE | |||
|
16 | ||||
|
17 | ||||
|
18 | ||||
|
19 | #endif /* AXISITEM_H_ */ |
@@ -0,0 +1,141 | |||||
|
1 | #include "chartanimator_p.h" | |||
|
2 | #include "axisanimation_p.h" | |||
|
3 | #include "xyanimation_p.h" | |||
|
4 | #include "xychartitem_p.h" | |||
|
5 | #include <QTimer> | |||
|
6 | ||||
|
7 | Q_DECLARE_METATYPE(QVector<QPointF>) | |||
|
8 | Q_DECLARE_METATYPE(QVector<qreal>) | |||
|
9 | ||||
|
10 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
|
11 | ||||
|
12 | const static int duration = 1000; | |||
|
13 | ||||
|
14 | ChartAnimator::ChartAnimator(QObject *parent):QObject(parent) | |||
|
15 | { | |||
|
16 | } | |||
|
17 | ||||
|
18 | ChartAnimator::~ChartAnimator() | |||
|
19 | { | |||
|
20 | } | |||
|
21 | ||||
|
22 | void ChartAnimator::addAnimation(AxisItem* item) | |||
|
23 | { | |||
|
24 | AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item)); | |||
|
25 | ||||
|
26 | if(!animation) { | |||
|
27 | animation = new AxisAnimation(item); | |||
|
28 | m_animations.insert(item,animation); | |||
|
29 | } | |||
|
30 | ||||
|
31 | item->setAnimator(this); | |||
|
32 | } | |||
|
33 | ||||
|
34 | void ChartAnimator::addAnimation(XYChartItem* item) | |||
|
35 | { | |||
|
36 | XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item)); | |||
|
37 | ||||
|
38 | if(!animation) { | |||
|
39 | animation = new XYAnimation(item); | |||
|
40 | m_animations.insert(item,animation); | |||
|
41 | } | |||
|
42 | ||||
|
43 | item->setAnimator(this); | |||
|
44 | } | |||
|
45 | ||||
|
46 | void ChartAnimator::removeAnimation(ChartItem* item) | |||
|
47 | { | |||
|
48 | item->setAnimator(0); | |||
|
49 | m_animations.remove(item); | |||
|
50 | } | |||
|
51 | ||||
|
52 | void ChartAnimator::applyLayout(AxisItem* item , QVector<qreal>& newLayout) | |||
|
53 | { | |||
|
54 | AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item)); | |||
|
55 | ||||
|
56 | if(!animation) return; | |||
|
57 | ||||
|
58 | QVector<qreal> oldLayout = item->layout(); | |||
|
59 | ||||
|
60 | if(newLayout.count()==0) return; | |||
|
61 | ||||
|
62 | if(item->zoomFactor()<0) { | |||
|
63 | ||||
|
64 | QRectF rect = item->geometry(); | |||
|
65 | oldLayout.resize(newLayout.count()); | |||
|
66 | ||||
|
67 | for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--) | |||
|
68 | { | |||
|
69 | oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.bottom(); | |||
|
70 | oldLayout[j]= item->axisType()==AxisItem::X_AXIS?rect.right():rect.top(); | |||
|
71 | } | |||
|
72 | ||||
|
73 | } | |||
|
74 | else { | |||
|
75 | ||||
|
76 | int index = qMin(oldLayout.count()*item->zoomFactor(),newLayout.count()-1.0); | |||
|
77 | oldLayout.resize(newLayout.count()); | |||
|
78 | ||||
|
79 | for(int i=0;i<oldLayout.count();i++) | |||
|
80 | { | |||
|
81 | oldLayout[i]= oldLayout[index]; //axisType()==X_AXIS?rect.center.x():rect.center().y(); | |||
|
82 | } | |||
|
83 | } | |||
|
84 | ||||
|
85 | if(animation->state()!=QAbstractAnimation::Stopped) { | |||
|
86 | animation->stop(); | |||
|
87 | } | |||
|
88 | ||||
|
89 | animation->setDuration(duration); | |||
|
90 | animation->setEasingCurve(QEasingCurve::OutQuart); | |||
|
91 | QVariantAnimation::KeyValues value; | |||
|
92 | animation->setKeyValues(value); //workaround for wrong interpolation call | |||
|
93 | animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout)); | |||
|
94 | animation->setKeyValueAt(1.0, qVariantFromValue(newLayout)); | |||
|
95 | ||||
|
96 | QTimer::singleShot(0,animation,SLOT(start())); | |||
|
97 | } | |||
|
98 | ||||
|
99 | void ChartAnimator::applyLayout(XYChartItem* item, QVector<QPointF>& newPoints) | |||
|
100 | { | |||
|
101 | ||||
|
102 | XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item)); | |||
|
103 | ||||
|
104 | if(!animation) return; | |||
|
105 | ||||
|
106 | QVector<QPointF> oldPoints = item->points(); | |||
|
107 | ||||
|
108 | if(newPoints.count()==0) return; | |||
|
109 | ||||
|
110 | bool empty = oldPoints.count()==0; | |||
|
111 | oldPoints.resize(newPoints.size()); | |||
|
112 | ||||
|
113 | if(animation->state()!=QAbstractAnimation::Stopped) { | |||
|
114 | animation->stop(); | |||
|
115 | } | |||
|
116 | ||||
|
117 | animation->setDuration(duration); | |||
|
118 | if(!empty) | |||
|
119 | animation->setAnimationType(XYAnimation::MoveDownAnimation); | |||
|
120 | else | |||
|
121 | animation->setAnimationType(XYAnimation::LineDrawAnimation); | |||
|
122 | animation->setEasingCurve(QEasingCurve::OutQuart); | |||
|
123 | animation->setValues(oldPoints,newPoints); | |||
|
124 | QTimer::singleShot(0,animation,SLOT(start())); | |||
|
125 | } | |||
|
126 | ||||
|
127 | void ChartAnimator::updateLayout(XYChartItem* item, QVector<QPointF>& newPoints) | |||
|
128 | { | |||
|
129 | XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item)); | |||
|
130 | ||||
|
131 | if(!animation) return; | |||
|
132 | ||||
|
133 | animation->setDuration(duration); | |||
|
134 | animation->setAnimationType(XYAnimation::MoveDownAnimation); | |||
|
135 | animation->setEasingCurve(QEasingCurve::OutQuart); | |||
|
136 | animation->updateValues(newPoints); | |||
|
137 | ||||
|
138 | QTimer::singleShot(0,animation,SLOT(start())); | |||
|
139 | } | |||
|
140 | ||||
|
141 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -0,0 +1,35 | |||||
|
1 | #ifndef CHARTANIMATOR_P_H_ | |||
|
2 | #define CHARTANIMATOR_P_H_ | |||
|
3 | #include "qchartglobal.h" | |||
|
4 | #include "chartanimation_p.h" | |||
|
5 | ||||
|
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
|
7 | ||||
|
8 | class ChartItem; | |||
|
9 | class XYChartItem; | |||
|
10 | class AxisItem; | |||
|
11 | ||||
|
12 | ||||
|
13 | class ChartAnimator : public QObject { | |||
|
14 | ||||
|
15 | public: | |||
|
16 | ChartAnimator(QObject *parent = 0); | |||
|
17 | virtual ~ChartAnimator(); | |||
|
18 | ||||
|
19 | void addAnimation(AxisItem* item); | |||
|
20 | void addAnimation(XYChartItem* item); | |||
|
21 | ||||
|
22 | void removeAnimation(ChartItem* item); | |||
|
23 | ||||
|
24 | void animationStarted(); | |||
|
25 | void applyLayout(XYChartItem* item, QVector<QPointF>& layout); | |||
|
26 | void updateLayout(XYChartItem* item, QVector<QPointF>& layout); | |||
|
27 | void applyLayout(AxisItem* item, QVector<qreal>& layout); | |||
|
28 | ||||
|
29 | private: | |||
|
30 | QMap<ChartItem*,ChartAnimation*> m_animations; | |||
|
31 | }; | |||
|
32 | ||||
|
33 | QTCOMMERCIALCHART_END_NAMESPACE | |||
|
34 | ||||
|
35 | #endif |
@@ -0,0 +1,34 | |||||
|
1 | #ifndef XYCHARTANIMATION_P_H_ | |||
|
2 | #define XYCHARTANIMATION_P_H_ | |||
|
3 | #include "chartanimation_p.h" | |||
|
4 | #include <QPointF> | |||
|
5 | ||||
|
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
|
7 | ||||
|
8 | class XYChartItem; | |||
|
9 | ||||
|
10 | class XYAnimation : public ChartAnimation | |||
|
11 | { | |||
|
12 | public: | |||
|
13 | enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation }; | |||
|
14 | XYAnimation(XYChartItem *item); | |||
|
15 | ~XYAnimation(); | |||
|
16 | void setAnimationType(Animation type); | |||
|
17 | void setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints); | |||
|
18 | void updateValues(QVector<QPointF>& newPoints); | |||
|
19 | ||||
|
20 | protected: | |||
|
21 | QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const; | |||
|
22 | void updateCurrentValue (const QVariant & value ); | |||
|
23 | void updateState ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | |||
|
24 | ||||
|
25 | private: | |||
|
26 | XYChartItem *m_item; | |||
|
27 | Animation m_type; | |||
|
28 | QVector<QPointF> m_points; | |||
|
29 | bool m_dirty; | |||
|
30 | }; | |||
|
31 | ||||
|
32 | QTCOMMERCIALCHART_END_NAMESPACE | |||
|
33 | ||||
|
34 | #endif |
@@ -33,6 +33,7 int main(int argc, char *argv[]) | |||||
33 | ChartWidget* chartWidget = new ChartWidget(&window); |
|
33 | ChartWidget* chartWidget = new ChartWidget(&window); | |
34 | chartWidget->setRenderHint(QPainter::Antialiasing); |
|
34 | chartWidget->setRenderHint(QPainter::Antialiasing); | |
35 | chartWidget->setChartTitle("Zoom in/out line chart example"); |
|
35 | chartWidget->setChartTitle("Zoom in/out line chart example"); | |
|
36 | chartWidget->setAnimationOptions(QChart::AllAnimations); | |||
36 | chartWidget->addSeries(series0); |
|
37 | chartWidget->addSeries(series0); | |
37 | chartWidget->addSeries(series1); |
|
38 | chartWidget->addSeries(series1); | |
38 |
|
39 |
@@ -1,37 +1,17 | |||||
1 | #ifndef AXISANIMATIONITEM_H_ |
|
1 | #ifndef AXISANIMATIONITEM_H_ | |
2 | #define AXISANIMATIONITEM_H_ |
|
2 | #define AXISANIMATIONITEM_H_ | |
3 |
|
3 | |||
4 | #include "domain_p.h" |
|
|||
5 | #include "axisitem_p.h" |
|
4 | #include "axisitem_p.h" | |
6 | #include <QGraphicsItem> |
|
5 | #include "chartanimation_p.h" | |
7 | #include <QVariantAnimation> |
|
|||
8 |
|
6 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
|||
10 |
|
||||
11 | class AxisAnimator; |
|
|||
12 |
|
||||
13 | class AxisAnimationItem : public AxisItem |
|
|||
14 | { |
|
|||
15 | Q_OBJECT |
|
|||
16 |
|
||||
17 | public: |
|
|||
18 | AxisAnimationItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); |
|
|||
19 | ~AxisAnimationItem(); |
|
|||
20 |
|
7 | |||
21 | void setLabelsAngle(int angle); |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
22 |
|
||||
23 | protected: |
|
|||
24 | virtual void updateLayout(QVector<qreal>& layout); |
|
|||
25 |
|
||||
26 | private: |
|
|||
27 | AxisAnimator *m_animation; |
|
|||
28 | }; |
|
|||
29 |
|
9 | |||
30 |
class AxisAnimat |
|
10 | class AxisAnimation: public ChartAnimation | |
31 | { |
|
11 | { | |
32 | public: |
|
12 | public: | |
33 |
AxisAnimat |
|
13 | AxisAnimation(AxisItem *axis); | |
34 |
~AxisAnimat |
|
14 | ~AxisAnimation(); | |
35 | protected: |
|
15 | protected: | |
36 | virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const; |
|
16 | virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const; | |
37 | virtual void updateCurrentValue (const QVariant & value ); |
|
17 | virtual void updateCurrentValue (const QVariant & value ); |
@@ -1,54 +1,51 | |||||
1 | #ifndef XYCHARTANIMATOR_P_H_ |
|
1 | #include "xyanimation_p.h" | |
2 | #define XYCHARTANIMATOR_P_H_ |
|
2 | #include "xychartitem_p.h" | |
3 | #include "qchartglobal.h" |
|
|||
4 | #include <QVariantAnimation> |
|
|||
5 | #include <QPointF> |
|
|||
6 |
|
3 | |||
7 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
4 | Q_DECLARE_METATYPE(QVector<QPointF>) | |
8 |
|
||||
9 | template <class T, class U> |
|
|||
10 | class XYChartAnimationItem; |
|
|||
11 |
|
5 | |||
|
6 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||
12 |
|
7 | |||
13 | template <class T, class U> |
|
8 | XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item), | |
14 | class XYChartAnimator : public QVariantAnimation |
|
|||
15 | { |
|
|||
16 | public: |
|
|||
17 | enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation }; |
|
|||
18 | XYChartAnimator(XYChartAnimationItem<T,U> *item, QObject *parent = 0 ); |
|
|||
19 | ~XYChartAnimator(); |
|
|||
20 | void setAnimationType(Animation type); |
|
|||
21 |
|
||||
22 | protected: |
|
|||
23 | QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const; |
|
|||
24 | void updateCurrentValue (const QVariant & value ); |
|
|||
25 | void updateState ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState); |
|
|||
26 |
|
||||
27 | private: |
|
|||
28 | XYChartAnimationItem<T,U> *m_item; |
|
|||
29 | Animation m_type; |
|
|||
30 | }; |
|
|||
31 |
|
||||
32 | template <class T, class U> |
|
|||
33 | XYChartAnimator<T,U>::XYChartAnimator(XYChartAnimationItem<T,U> *item , QObject *parent):QVariantAnimation(parent), |
|
|||
34 | m_item(item), |
|
9 | m_item(item), | |
35 | m_type(MoveDownAnimation) |
|
10 | m_type(MoveDownAnimation), | |
|
11 | m_dirty(false) | |||
36 | { |
|
12 | { | |
37 | } |
|
13 | } | |
38 |
|
14 | |||
39 | template <class T,class U> |
|
15 | XYAnimation::~XYAnimation() | |
40 | XYChartAnimator<T,U>::~XYChartAnimator() |
|
|||
41 | { |
|
16 | { | |
42 | } |
|
17 | } | |
43 |
|
18 | |||
44 | template <class T,class U> |
|
19 | void XYAnimation::setAnimationType(Animation type) | |
45 | void XYChartAnimator<T,U>::setAnimationType(Animation type) |
|
|||
46 | { |
|
20 | { | |
47 | m_type=type; |
|
21 | m_type=type; | |
48 | } |
|
22 | } | |
49 |
|
23 | |||
50 | template <class T, class U> |
|
24 | void XYAnimation::setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints) | |
51 | QVariant XYChartAnimator<T,U>::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const |
|
25 | { | |
|
26 | setKeyValueAt(0.0, qVariantFromValue(oldPoints)); | |||
|
27 | setKeyValueAt(1.0, qVariantFromValue(newPoints)); | |||
|
28 | m_points = newPoints; | |||
|
29 | m_dirty=false; | |||
|
30 | } | |||
|
31 | ||||
|
32 | void XYAnimation::updateValues(QVector<QPointF>& newPoints) | |||
|
33 | { | |||
|
34 | if(state()!=QAbstractAnimation::Stopped) { | |||
|
35 | stop(); | |||
|
36 | m_dirty=true; | |||
|
37 | } | |||
|
38 | ||||
|
39 | if(m_dirty) { | |||
|
40 | m_points=newPoints; | |||
|
41 | m_dirty=false; | |||
|
42 | } | |||
|
43 | ||||
|
44 | setKeyValueAt(0.0, qVariantFromValue(m_points)); | |||
|
45 | setKeyValueAt(1.0, qVariantFromValue(newPoints)); | |||
|
46 | } | |||
|
47 | ||||
|
48 | QVariant XYAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const | |||
52 | { |
|
49 | { | |
53 |
|
|
50 | QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start); | |
54 |
|
|
51 | QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end); | |
@@ -81,8 +78,7 QVariant XYChartAnimator<T,U>::interpolated(const QVariant &start, const QVarian | |||||
81 |
|
|
78 | return qVariantFromValue(result); | |
82 | } |
|
79 | } | |
83 |
|
80 | |||
84 | template <class T, class U> |
|
81 | void XYAnimation::updateCurrentValue (const QVariant & value ) | |
85 | void XYChartAnimator<T,U>::updateCurrentValue (const QVariant & value ) |
|
|||
86 | { |
|
82 | { | |
87 |
|
|
83 | if(state()!=QAbstractAnimation::Stopped){ //workaround | |
88 |
|
|
84 | QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value); | |
@@ -90,14 +86,11 void XYChartAnimator<T,U>::updateCurrentValue (const QVariant & value ) | |||||
90 | } |
|
86 | } | |
91 | } |
|
87 | } | |
92 |
|
88 | |||
93 | template <class T, class U> |
|
89 | void XYAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) | |
94 | void XYChartAnimator<T,U>::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
|
|||
95 | { |
|
90 | { | |
96 |
|
|
91 | Q_UNUSED(oldState) | |
97 |
|
|
92 | if (newState==QAbstractAnimation::Running) m_dirty=true; | |
98 |
|
|
93 | QVariantAnimation::updateState(newState,oldState); | |
99 | } |
|
94 | } | |
100 |
|
95 | |||
101 | QTCOMMERCIALCHART_END_NAMESPACE |
|
96 | QTCOMMERCIALCHART_END_NAMESPACE | |
102 |
|
||||
103 | #endif /* XYCHARTANIMATOR_P_H_ */ |
|
@@ -7,7 +7,6 | |||||
7 |
|
7 | |||
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
9 |
|
9 | |||
10 | class ChartPresenter; |
|
|||
11 | class QAreaSeries; |
|
10 | class QAreaSeries; | |
12 | class AreaChartItem; |
|
11 | class AreaChartItem; | |
13 |
|
12 |
@@ -2,13 +2,11 INCLUDEPATH += $$PWD | |||||
2 | DEPENDPATH += $$PWD |
|
2 | DEPENDPATH += $$PWD | |
3 |
|
3 | |||
4 | SOURCES += \ |
|
4 | SOURCES += \ | |
5 | $$PWD/axisanimationitem.cpp \ |
|
|||
6 | $$PWD/axisitem.cpp \ |
|
5 | $$PWD/axisitem.cpp \ | |
7 | $$PWD/qchartaxis.cpp \ |
|
6 | $$PWD/qchartaxis.cpp \ | |
8 | $$PWD/qchartaxiscategories.cpp |
|
7 | $$PWD/qchartaxiscategories.cpp | |
9 |
|
8 | |||
10 | PRIVATE_HEADERS += \ |
|
9 | PRIVATE_HEADERS += \ | |
11 | $$PWD/axisanimationitem_p.h \ |
|
|||
12 | $$PWD/axisitem_p.h |
|
10 | $$PWD/axisitem_p.h | |
13 |
|
11 | |||
14 | PUBLIC_HEADERS += \ |
|
12 | PUBLIC_HEADERS += \ |
@@ -1,6 +1,7 | |||||
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 "chartanimator_p.h" | |||
4 | #include <QPainter> |
|
5 | #include <QPainter> | |
5 | #include <QDebug> |
|
6 | #include <QDebug> | |
6 |
|
7 | |||
@@ -8,8 +9,9 static int label_padding = 5; | |||||
8 |
|
9 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
10 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
10 |
|
11 | |||
11 | AxisItem::AxisItem(QChartAxis* axis,AxisType type,QGraphicsItem* parent) : |
|
12 | AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) : | |
12 | ChartItem(parent), |
|
13 | ChartItem(parent), | |
|
14 | m_presenter(presenter), | |||
13 | m_chartAxis(axis), |
|
15 | m_chartAxis(axis), | |
14 | m_type(type), |
|
16 | m_type(type), | |
15 | m_labelsAngle(0), |
|
17 | m_labelsAngle(0), | |
@@ -45,13 +47,14 QRectF AxisItem::boundingRect() const | |||||
45 |
|
47 | |||
46 | void AxisItem::createItems(int count) |
|
48 | void AxisItem::createItems(int count) | |
47 | { |
|
49 | { | |
|
50 | ||||
48 | if(m_axis.children().size()==0) |
|
51 | if(m_axis.children().size()==0) | |
49 | m_axis.addToGroup(new QGraphicsLineItem()); |
|
52 | m_axis.addToGroup(new QGraphicsLineItem()); | |
50 | for (int i = 0; i < count; ++i) { |
|
53 | for (int i = 0; i < count; ++i) { | |
51 | m_grid.addToGroup(new QGraphicsLineItem()); |
|
54 | m_grid.addToGroup(new QGraphicsLineItem()); | |
52 | m_labels.addToGroup(new QGraphicsSimpleTextItem()); |
|
55 | m_labels.addToGroup(new QGraphicsSimpleTextItem()); | |
53 | if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem()); |
|
|||
54 | m_axis.addToGroup(new QGraphicsLineItem()); |
|
56 | m_axis.addToGroup(new QGraphicsLineItem()); | |
|
57 | if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem()); | |||
55 | } |
|
58 | } | |
56 | } |
|
59 | } | |
57 |
|
60 | |||
@@ -63,16 +66,19 void AxisItem::deleteItems(int count) | |||||
63 | QList<QGraphicsItem *> axis = m_axis.childItems(); |
|
66 | QList<QGraphicsItem *> axis = m_axis.childItems(); | |
64 |
|
67 | |||
65 | for (int i = 0; i < count; ++i) { |
|
68 | for (int i = 0; i < count; ++i) { | |
|
69 | if(lines.size()%2 && lines.size()>1) delete(shades.takeLast()); | |||
66 | delete(lines.takeLast()); |
|
70 | delete(lines.takeLast()); | |
67 | delete(labels.takeLast()); |
|
71 | delete(labels.takeLast()); | |
68 | if(lines.size()%2) delete(shades.takeLast()); |
|
|||
69 | delete(axis.takeLast()); |
|
72 | delete(axis.takeLast()); | |
70 | } |
|
73 | } | |
71 | } |
|
74 | } | |
72 |
|
75 | |||
73 | void AxisItem::updateLayout(QVector<qreal>& layout) |
|
76 | void AxisItem::updateLayout(QVector<qreal>& layout) | |
74 | { |
|
77 | { | |
75 | setLayout(layout); |
|
78 | if(m_animator){ | |
|
79 | m_animator->applyLayout(this,layout); | |||
|
80 | } | |||
|
81 | else setLayout(layout); | |||
76 | } |
|
82 | } | |
77 |
|
83 | |||
78 | QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const |
|
84 | QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const | |
@@ -240,7 +246,7 void AxisItem::setLayout(QVector<qreal>& layout) | |||||
240 |
|
246 | |||
241 | if(diff!=0) handleAxisUpdated(); |
|
247 | if(diff!=0) handleAxisUpdated(); | |
242 |
|
248 | |||
243 |
QStringList ticksList = createLabels( |
|
249 | QStringList ticksList = createLabels(layout.size(),m_min,m_max); | |
244 |
|
250 | |||
245 | QList<QGraphicsItem *> lines = m_grid.childItems(); |
|
251 | QList<QGraphicsItem *> lines = m_grid.childItems(); | |
246 | QList<QGraphicsItem *> labels = m_labels.childItems(); |
|
252 | QList<QGraphicsItem *> labels = m_labels.childItems(); | |
@@ -249,6 +255,7 void AxisItem::setLayout(QVector<qreal>& layout) | |||||
249 |
|
255 | |||
250 | Q_ASSERT(labels.size() == ticksList.size()); |
|
256 | Q_ASSERT(labels.size() == ticksList.size()); | |
251 | Q_ASSERT(layout.size() == ticksList.size()); |
|
257 | Q_ASSERT(layout.size() == ticksList.size()); | |
|
258 | Q_ASSERT(layout.size() == m_ticksCount); | |||
252 |
|
259 | |||
253 | switch (m_type) |
|
260 | switch (m_type) | |
254 | { |
|
261 | { | |
@@ -265,7 +272,7 void AxisItem::setLayout(QVector<qreal>& layout) | |||||
265 | QPointF center = labelItem->boundingRect().center(); |
|
272 | QPointF center = labelItem->boundingRect().center(); | |
266 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
273 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
267 | labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding); |
|
274 | labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding); | |
268 | if(i%2 && i+1 < layout.size()) { |
|
275 | if(i%2 && i+1 < layout.size() && i>1) { | |
269 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); |
|
276 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); | |
270 | rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height()); |
|
277 | rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height()); | |
271 | } |
|
278 | } | |
@@ -288,7 +295,7 void AxisItem::setLayout(QVector<qreal>& layout) | |||||
288 | QPointF center = labelItem->boundingRect().center(); |
|
295 | QPointF center = labelItem->boundingRect().center(); | |
289 | labelItem->setTransformOriginPoint(center.x(), center.y()); |
|
296 | labelItem->setTransformOriginPoint(center.x(), center.y()); | |
290 | labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y()); |
|
297 | labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y()); | |
291 | if(i%2 && i+1 < layout.size()) { |
|
298 | if(i%2 && i+1 < layout.size() && i>1) { | |
292 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); |
|
299 | QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2)); | |
293 | rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]); |
|
300 | rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]); | |
294 | } |
|
301 | } | |
@@ -302,7 +309,6 void AxisItem::setLayout(QVector<qreal>& layout) | |||||
302 | break; |
|
309 | break; | |
303 | } |
|
310 | } | |
304 |
|
311 | |||
305 | //if(diff!=0) handleAxisUpdated(); |
|
|||
306 | m_layoutVector=layout; |
|
312 | m_layoutVector=layout; | |
307 | } |
|
313 | } | |
308 |
|
314 | |||
@@ -391,6 +397,7 void AxisItem::handleRangeChanged(qreal min, qreal max) | |||||
391 | m_min = min; |
|
397 | m_min = min; | |
392 | m_max = max; |
|
398 | m_max = max; | |
393 |
|
399 | |||
|
400 | ||||
394 | m_ticksCount = qrand()%10; |
|
401 | m_ticksCount = qrand()%10; | |
395 |
|
402 | |||
396 | while(m_ticksCount<2){ |
|
403 | while(m_ticksCount<2){ | |
@@ -408,7 +415,6 void AxisItem::handleRangeChanged(qreal min, qreal max) | |||||
408 |
|
415 | |||
409 | void AxisItem::handleGeometryChanged(const QRectF& rect) |
|
416 | void AxisItem::handleGeometryChanged(const QRectF& rect) | |
410 | { |
|
417 | { | |
411 |
|
||||
412 | m_rect = rect; |
|
418 | m_rect = rect; | |
413 | if(isEmpty()) return; |
|
419 | if(isEmpty()) return; | |
414 | QVector<qreal> layout = calculateLayout(); |
|
420 | QVector<qreal> layout = calculateLayout(); |
@@ -8,6 +8,7 | |||||
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
9 |
|
9 | |||
10 | class QChartAxis; |
|
10 | class QChartAxis; | |
|
11 | class ChartPresenter; | |||
11 |
|
12 | |||
12 | class AxisItem : public QObject, public ChartItem |
|
13 | class AxisItem : public QObject, public ChartItem | |
13 | { |
|
14 | { | |
@@ -15,7 +16,7 class AxisItem : public QObject, public ChartItem | |||||
15 | public: |
|
16 | public: | |
16 | enum AxisType{X_AXIS,Y_AXIS}; |
|
17 | enum AxisType{X_AXIS,Y_AXIS}; | |
17 |
|
18 | |||
18 | AxisItem(QChartAxis* axis,AxisType type = X_AXIS,QGraphicsItem* parent = 0); |
|
19 | AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS,QGraphicsItem* parent = 0); | |
19 | ~AxisItem(); |
|
20 | ~AxisItem(); | |
20 |
|
21 | |||
21 | //from QGraphicsItem |
|
22 | //from QGraphicsItem | |
@@ -50,6 +51,7 public: | |||||
50 | void setLabelsFont(const QFont& font); |
|
51 | void setLabelsFont(const QFont& font); | |
51 |
|
52 | |||
52 | inline QRectF geometry() const { return m_rect; } |
|
53 | inline QRectF geometry() const { return m_rect; } | |
|
54 | inline QVector<qreal> layout() { return m_layoutVector;}; | |||
53 | inline qreal zoomFactor() const { return m_zoomFactor;} |
|
55 | inline qreal zoomFactor() const { return m_zoomFactor;} | |
54 |
|
56 | |||
55 | public slots: |
|
57 | public slots: | |
@@ -59,19 +61,20 public slots: | |||||
59 | void handleTicksCountChanged(int count); |
|
61 | void handleTicksCountChanged(int count); | |
60 | void handleGeometryChanged(const QRectF& size); |
|
62 | void handleGeometryChanged(const QRectF& size); | |
61 |
|
63 | |||
62 | public: |
|
|||
63 | virtual void updateLayout(QVector<qreal>& layout); |
|
|||
64 | void setLayout(QVector<qreal>& layout); |
|
|||
65 | QVector<qreal> layout() { return m_layoutVector;}; |
|
|||
66 |
|
64 | |||
67 | private: |
|
65 | private: | |
68 | inline bool isEmpty(); |
|
66 | inline bool isEmpty(); | |
69 | void createItems(int count); |
|
67 | void createItems(int count); | |
70 | void deleteItems(int count); |
|
68 | void deleteItems(int count); | |
|
69 | ||||
71 | QVector<qreal> calculateLayout() const; |
|
70 | QVector<qreal> calculateLayout() const; | |
|
71 | void updateLayout(QVector<qreal>& layout); | |||
|
72 | void setLayout(QVector<qreal>& layout); | |||
|
73 | ||||
72 | QStringList createLabels(int ticks, qreal min, qreal max) const; |
|
74 | QStringList createLabels(int ticks, qreal min, qreal max) const; | |
73 |
|
75 | |||
74 | private: |
|
76 | private: | |
|
77 | ChartPresenter* m_presenter; | |||
75 | QChartAxis* m_chartAxis; |
|
78 | QChartAxis* m_chartAxis; | |
76 | AxisType m_type; |
|
79 | AxisType m_type; | |
77 | QRectF m_rect; |
|
80 | QRectF m_rect; | |
@@ -86,6 +89,8 private: | |||||
86 | int m_ticksCount; |
|
89 | int m_ticksCount; | |
87 | qreal m_zoomFactor; |
|
90 | qreal m_zoomFactor; | |
88 |
|
91 | |||
|
92 | friend class AxisAnimation; | |||
|
93 | ||||
89 | }; |
|
94 | }; | |
90 |
|
95 | |||
91 | QTCOMMERCIALCHART_END_NAMESPACE |
|
96 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -146,11 +146,9 void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const | |||||
146 | minY = qMin(minY, y); |
|
146 | minY = qMin(minY, y); | |
147 | maxX = qMax(maxX, x); |
|
147 | maxX = qMax(maxX, x); | |
148 | maxY = qMax(maxY, y); |
|
148 | maxY = qMax(maxY, y); | |
149 | domain->setMinX(qMin(domain->minX(),x)); |
|
|||
150 | domain->setMinY(qMin(domain->minY(),y)); |
|
|||
151 | domain->setMaxX(qMax(domain->maxX(),x)); |
|
|||
152 | domain->setMaxY(qMax(domain->maxY(),y)); |
|
|||
153 | } |
|
149 | } | |
|
150 | ||||
|
151 | domain->setRange(minX, maxX, minY, maxY); | |||
154 | break; |
|
152 | break; | |
155 | } |
|
153 | } | |
156 | case QSeries::SeriesTypeArea: { |
|
154 | case QSeries::SeriesTypeArea: { |
@@ -6,17 +6,26 | |||||
6 |
|
6 | |||
7 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
7 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
8 |
|
8 | |||
9 |
class ChartAnimat |
|
9 | class ChartAnimator; | |
10 |
|
10 | |||
11 | class ChartItem : public QGraphicsItem |
|
11 | class ChartItem : public QGraphicsItem | |
12 | { |
|
12 | { | |
13 | enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM}; |
|
13 | enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM}; | |
14 | public: |
|
14 | public: | |
15 |
ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent) |
|
15 | ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent), | |
|
16 | m_animator(0){}; | |||
16 | //TODO make pure |
|
17 | //TODO make pure | |
17 | virtual void handleGeometryChanged(const QRectF&){}; |
|
18 | virtual void handleGeometryChanged(const QRectF&){}; | |
18 | virtual void handleDomainChanged(const Domain& domain){}; |
|
19 | virtual void handleDomainChanged(const Domain& domain){}; | |
|
20 | ||||
|
21 | void setAnimator(ChartAnimator* animator){ | |||
|
22 | m_animator=animator; | |||
|
23 | } | |||
|
24 | ||||
19 | virtual ~ChartItem(){}; |
|
25 | virtual ~ChartItem(){}; | |
|
26 | ||||
|
27 | protected: | |||
|
28 | ChartAnimator* m_animator; | |||
20 | }; |
|
29 | }; | |
21 |
|
30 | |||
22 | QTCOMMERCIALCHART_END_NAMESPACE |
|
31 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -3,6 +3,7 | |||||
3 | #include "chartpresenter_p.h" |
|
3 | #include "chartpresenter_p.h" | |
4 | #include "chartdataset_p.h" |
|
4 | #include "chartdataset_p.h" | |
5 | #include "charttheme_p.h" |
|
5 | #include "charttheme_p.h" | |
|
6 | #include "chartanimator_p.h" | |||
6 | //series |
|
7 | //series | |
7 | #include "qbarseries.h" |
|
8 | #include "qbarseries.h" | |
8 | #include "qstackedbarseries.h" |
|
9 | #include "qstackedbarseries.h" | |
@@ -14,7 +15,6 | |||||
14 | #include "qsplineseries.h" |
|
15 | #include "qsplineseries.h" | |
15 | //items |
|
16 | //items | |
16 | #include "axisitem_p.h" |
|
17 | #include "axisitem_p.h" | |
17 | #include "axisanimationitem_p.h" |
|
|||
18 | #include "areachartitem_p.h" |
|
18 | #include "areachartitem_p.h" | |
19 | #include "barpresenter_p.h" |
|
19 | #include "barpresenter_p.h" | |
20 | #include "stackedbarpresenter_p.h" |
|
20 | #include "stackedbarpresenter_p.h" | |
@@ -28,6 +28,7 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
28 |
|
28 | |||
29 | ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart), |
|
29 | ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart), | |
30 | m_chart(chart), |
|
30 | m_chart(chart), | |
|
31 | m_animator(0), | |||
31 | m_dataset(dataset), |
|
32 | m_dataset(dataset), | |
32 | m_chartTheme(0), |
|
33 | m_chartTheme(0), | |
33 | m_zoomIndex(0), |
|
34 | m_zoomIndex(0), | |
@@ -96,15 +97,12 void ChartPresenter::setMargin(int margin) | |||||
96 |
|
97 | |||
97 | void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain) |
|
98 | void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain) | |
98 | { |
|
99 | { | |
|
100 | AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart); | |||
99 |
|
101 | |||
100 | AxisItem* item ; |
|
102 | if(m_options.testFlag(QChart::GridAxisAnimations)){ | |
101 |
|
103 | m_animator->addAnimation(item); | ||
102 | if(!m_options.testFlag(QChart::GridAxisAnimations)) |
|
|||
103 | { |
|
|||
104 | item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart); |
|
|||
105 | }else{ |
|
|||
106 | item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart); |
|
|||
107 | } |
|
104 | } | |
|
105 | ||||
108 | if(axis==m_dataset->axisX()){ |
|
106 | if(axis==m_dataset->axisX()){ | |
109 | QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal))); |
|
107 | QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal))); | |
110 | //initialize |
|
108 | //initialize | |
@@ -114,7 +112,6 void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain) | |||||
114 | QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal))); |
|
112 | QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal))); | |
115 | //initialize |
|
113 | //initialize | |
116 | item->handleRangeChanged(domain->minY(),domain->maxY()); |
|
114 | item->handleRangeChanged(domain->minY(),domain->maxY()); | |
117 |
|
||||
118 | } |
|
115 | } | |
119 |
|
116 | |||
120 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); |
|
117 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); | |
@@ -122,12 +119,14 void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain) | |||||
122 | item->handleGeometryChanged(m_rect); |
|
119 | item->handleGeometryChanged(m_rect); | |
123 | m_chartTheme->decorate(axis,item); |
|
120 | m_chartTheme->decorate(axis,item); | |
124 | m_axisItems.insert(axis,item); |
|
121 | m_axisItems.insert(axis,item); | |
|
122 | ||||
125 | } |
|
123 | } | |
126 |
|
124 | |||
127 | void ChartPresenter::handleAxisRemoved(QChartAxis* axis) |
|
125 | void ChartPresenter::handleAxisRemoved(QChartAxis* axis) | |
128 | { |
|
126 | { | |
129 | AxisItem* item = m_axisItems.take(axis); |
|
127 | AxisItem* item = m_axisItems.take(axis); | |
130 | Q_ASSERT(item); |
|
128 | Q_ASSERT(item); | |
|
129 | if(m_animator) m_animator->removeAnimation(item); | |||
131 | delete item; |
|
130 | delete item; | |
132 | } |
|
131 | } | |
133 |
|
132 | |||
@@ -139,11 +138,9 void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain) | |||||
139 | case QSeries::SeriesTypeLine: { |
|
138 | case QSeries::SeriesTypeLine: { | |
140 |
|
139 | |||
141 | QLineSeries* lineSeries = static_cast<QLineSeries*>(series); |
|
140 | QLineSeries* lineSeries = static_cast<QLineSeries*>(series); | |
142 | LineChartItem* item; |
|
141 | LineChartItem* item = new LineChartItem(lineSeries,m_chart); | |
143 | if(m_options.testFlag(QChart::SeriesAnimations)){ |
|
142 | if(m_options.testFlag(QChart::SeriesAnimations)){ | |
144 | item = new LineChartAnimationItem(lineSeries,m_chart); |
|
143 | m_animator->addAnimation(item); | |
145 | }else{ |
|
|||
146 | item = new LineChartItem(lineSeries,m_chart); |
|
|||
147 | } |
|
144 | } | |
148 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); |
|
145 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); | |
149 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); |
|
146 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); | |
@@ -159,12 +156,9 void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain) | |||||
159 | case QSeries::SeriesTypeArea: { |
|
156 | case QSeries::SeriesTypeArea: { | |
160 |
|
157 | |||
161 | QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series); |
|
158 | QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series); | |
162 | AreaChartItem* item; |
|
159 | AreaChartItem* item = new AreaChartItem(areaSeries,m_chart); | |
163 | if(m_options.testFlag(QChart::SeriesAnimations)) { |
|
160 | if(m_options.testFlag(QChart::SeriesAnimations)) { | |
164 | item = new AreaChartItem(areaSeries,m_chart); |
|
161 | // m_animator->addAnimation(item); | |
165 | } |
|
|||
166 | else { |
|
|||
167 | item = new AreaChartItem(areaSeries,m_chart); |
|
|||
168 | } |
|
162 | } | |
169 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); |
|
163 | QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&))); | |
170 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); |
|
164 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); | |
@@ -214,11 +208,9 void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain) | |||||
214 | } |
|
208 | } | |
215 | case QSeries::SeriesTypeScatter: { |
|
209 | case QSeries::SeriesTypeScatter: { | |
216 | QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series); |
|
210 | QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series); | |
217 | ScatterChartItem *item; |
|
211 | ScatterChartItem *item = new ScatterChartItem(scatterSeries, m_chart); | |
218 | if(m_options.testFlag(QChart::SeriesAnimations)) { |
|
212 | if(m_options.testFlag(QChart::SeriesAnimations)) { | |
219 | item = new ScatterChartAnimationItem(scatterSeries,m_chart); |
|
213 | m_animator->addAnimation(item); | |
220 | } else { |
|
|||
221 | item = new ScatterChartItem(scatterSeries, m_chart); |
|
|||
222 | } |
|
214 | } | |
223 | QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), |
|
215 | QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), | |
224 | item, SLOT(handleGeometryChanged(const QRectF&))); |
|
216 | item, SLOT(handleGeometryChanged(const QRectF&))); | |
@@ -262,11 +254,9 void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain) | |||||
262 | case QSeries::SeriesTypeSpline: { |
|
254 | case QSeries::SeriesTypeSpline: { | |
263 |
|
255 | |||
264 | QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series); |
|
256 | QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series); | |
265 | SplineChartItem* item; |
|
257 | SplineChartItem* item = new SplineChartItem(splineSeries, m_chart); | |
266 | if(m_options.testFlag(QChart::SeriesAnimations)) { |
|
258 | if(m_options.testFlag(QChart::SeriesAnimations)) { | |
267 | item = new SplineChartAnimationItem(splineSeries, m_chart); |
|
259 | m_animator->addAnimation(item); | |
268 | } else { |
|
|||
269 | item = new SplineChartItem(splineSeries, m_chart); |
|
|||
270 | } |
|
260 | } | |
271 | QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), item, SLOT(handleGeometryChanged(const QRectF&))); |
|
261 | QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), item, SLOT(handleGeometryChanged(const QRectF&))); | |
272 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); |
|
262 | QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal))); | |
@@ -290,6 +280,8 void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain) | |||||
290 | void ChartPresenter::handleSeriesRemoved(QSeries* series) |
|
280 | void ChartPresenter::handleSeriesRemoved(QSeries* series) | |
291 | { |
|
281 | { | |
292 | ChartItem* item = m_chartItems.take(series); |
|
282 | ChartItem* item = m_chartItems.take(series); | |
|
283 | Q_ASSERT(item); | |||
|
284 | if(m_animator) m_animator->removeAnimation(item); | |||
293 | delete item; |
|
285 | delete item; | |
294 | } |
|
286 | } | |
295 |
|
287 | |||
@@ -327,6 +319,10 void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options) | |||||
327 |
|
319 | |||
328 | m_options=options; |
|
320 | m_options=options; | |
329 |
|
321 | |||
|
322 | if(m_options!=QChart::NoAnimation && !m_animator) { | |||
|
323 | m_animator= new ChartAnimator(this); | |||
|
324 | } | |||
|
325 | ||||
330 | //recreate elements |
|
326 | //recreate elements | |
331 | QList<QChartAxis*> axisList = m_axisItems.uniqueKeys(); |
|
327 | QList<QChartAxis*> axisList = m_axisItems.uniqueKeys(); | |
332 | QList<QSeries*> seriesList = m_chartItems.uniqueKeys(); |
|
328 | QList<QSeries*> seriesList = m_chartItems.uniqueKeys(); | |
@@ -340,6 +336,7 void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options) | |||||
340 | handleSeriesAdded(series,m_dataset->domain(series)); |
|
336 | handleSeriesAdded(series,m_dataset->domain(series)); | |
341 | } |
|
337 | } | |
342 | } |
|
338 | } | |
|
339 | ||||
343 | } |
|
340 | } | |
344 |
|
341 | |||
345 | void ChartPresenter::zoomIn() |
|
342 | void ChartPresenter::zoomIn() |
@@ -11,10 +11,10 QTCOMMERCIALCHART_BEGIN_NAMESPACE | |||||
11 | class ChartItem; |
|
11 | class ChartItem; | |
12 | class QSeries; |
|
12 | class QSeries; | |
13 | class ChartDataSet; |
|
13 | class ChartDataSet; | |
14 | //class QChart; |
|
|||
15 | class Domain; |
|
14 | class Domain; | |
16 | class AxisItem; |
|
15 | class AxisItem; | |
17 | class ChartTheme; |
|
16 | class ChartTheme; | |
|
17 | class ChartAnimator; | |||
18 |
|
18 | |||
19 | class ChartPresenter: public QObject |
|
19 | class ChartPresenter: public QObject | |
20 | { |
|
20 | { | |
@@ -37,6 +37,7 public: | |||||
37 | int margin() const; |
|
37 | int margin() const; | |
38 |
|
38 | |||
39 | QRectF geometry() const; |
|
39 | QRectF geometry() const; | |
|
40 | ChartAnimator* animator() const {return m_animator;}; | |||
40 |
|
41 | |||
41 | void setChartTheme(QChart::ChartTheme theme); |
|
42 | void setChartTheme(QChart::ChartTheme theme); | |
42 | QChart::ChartTheme chartTheme(); |
|
43 | QChart::ChartTheme chartTheme(); | |
@@ -65,6 +66,7 signals: | |||||
65 |
|
66 | |||
66 | private: |
|
67 | private: | |
67 | QChart* m_chart; |
|
68 | QChart* m_chart; | |
|
69 | ChartAnimator* m_animator; | |||
68 | ChartDataSet* m_dataset; |
|
70 | ChartDataSet* m_dataset; | |
69 | ChartTheme *m_chartTheme; |
|
71 | ChartTheme *m_chartTheme; | |
70 | int m_zoomIndex; |
|
72 | int m_zoomIndex; |
@@ -3,12 +3,10 | |||||
3 |
|
3 | |||
4 | #include "qchartglobal.h" |
|
4 | #include "qchartglobal.h" | |
5 | #include "xychartitem_p.h" |
|
5 | #include "xychartitem_p.h" | |
6 | #include "xychartanimationitem_p.h" |
|
|||
7 | #include <QPen> |
|
6 | #include <QPen> | |
8 |
|
7 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
10 |
|
9 | |||
11 | class ChartPresenter; |
|
|||
12 | class QLineSeries; |
|
10 | class QLineSeries; | |
13 |
|
11 | |||
14 | class LineChartItem : public XYChartItem |
|
12 | class LineChartItem : public XYChartItem | |
@@ -43,12 +41,8 private: | |||||
43 | QRectF m_rect; |
|
41 | QRectF m_rect; | |
44 | QPen m_pen; |
|
42 | QPen m_pen; | |
45 |
|
43 | |||
46 | template<class,class> friend class XYChartAnimator; |
|
|||
47 |
|
||||
48 | }; |
|
44 | }; | |
49 |
|
45 | |||
50 | typedef XYChartAnimationItem<LineChartItem,QLineSeries> LineChartAnimationItem; |
|
|||
51 |
|
||||
52 | QTCOMMERCIALCHART_END_NAMESPACE |
|
46 | QTCOMMERCIALCHART_END_NAMESPACE | |
53 |
|
47 | |||
54 | #endif |
|
48 | #endif |
@@ -3,7 +3,6 | |||||
3 |
|
3 | |||
4 | #include "qchartglobal.h" |
|
4 | #include "qchartglobal.h" | |
5 | #include "xychartitem_p.h" |
|
5 | #include "xychartitem_p.h" | |
6 | #include "xychartanimationitem_p.h" |
|
|||
7 | #include <QGraphicsItem> |
|
6 | #include <QGraphicsItem> | |
8 | #include <QPen> |
|
7 | #include <QPen> | |
9 |
|
8 | |||
@@ -45,11 +44,8 private: | |||||
45 | int m_size; |
|
44 | int m_size; | |
46 | QRectF m_rect; |
|
45 | QRectF m_rect; | |
47 |
|
46 | |||
48 | template<class,class> friend class XYChartAnimator; |
|
|||
49 | }; |
|
47 | }; | |
50 |
|
48 | |||
51 | typedef XYChartAnimationItem<ScatterChartItem,QScatterSeries> ScatterChartAnimationItem; |
|
|||
52 |
|
||||
53 | QTCOMMERCIALCHART_END_NAMESPACE |
|
49 | QTCOMMERCIALCHART_END_NAMESPACE | |
54 |
|
50 | |||
55 | #endif // SCATTERPRESENTER_H |
|
51 | #endif // SCATTERPRESENTER_H |
@@ -3,7 +3,6 | |||||
3 |
|
3 | |||
4 | #include "qsplineseries.h" |
|
4 | #include "qsplineseries.h" | |
5 | #include "xychartitem_p.h" |
|
5 | #include "xychartitem_p.h" | |
6 | #include "xychartanimationitem_p.h" |
|
|||
7 | #include <QGraphicsItem> |
|
6 | #include <QGraphicsItem> | |
8 |
|
7 | |||
9 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
8 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | |
@@ -37,11 +36,8 private: | |||||
37 | QRectF m_rect; |
|
36 | QRectF m_rect; | |
38 | QPen m_pen; |
|
37 | QPen m_pen; | |
39 |
|
38 | |||
40 | template<class,class> friend class XYChartAnimator; |
|
|||
41 | }; |
|
39 | }; | |
42 |
|
40 | |||
43 | typedef XYChartAnimationItem<SplineChartItem,QSplineSeries> SplineChartAnimationItem; |
|
|||
44 |
|
||||
45 | QTCOMMERCIALCHART_END_NAMESPACE |
|
41 | QTCOMMERCIALCHART_END_NAMESPACE | |
46 |
|
42 | |||
47 | #endif // SPLINECHARTITEM_P_H |
|
43 | #endif // SPLINECHARTITEM_P_H |
@@ -28,6 +28,7 PUBLIC_HEADERS += \ | |||||
28 | qchartview.h \ |
|
28 | qchartview.h \ | |
29 | qlegend.h |
|
29 | qlegend.h | |
30 |
|
30 | |||
|
31 | include(animations/animations.pri) | |||
31 | include(axis/axis.pri) |
|
32 | include(axis/axis.pri) | |
32 | include(xychart/xychart.pri) |
|
33 | include(xychart/xychart.pri) | |
33 | include(linechart/linechart.pri) |
|
34 | include(linechart/linechart.pri) |
@@ -6,9 +6,8 SOURCES += \ | |||||
6 | $$PWD/qxyseries.cpp |
|
6 | $$PWD/qxyseries.cpp | |
7 |
|
7 | |||
8 | PRIVATE_HEADERS += \ |
|
8 | PRIVATE_HEADERS += \ | |
9 |
$$PWD/xychartitem_p.h |
|
9 | $$PWD/xychartitem_p.h | |
10 | $$PWD/xychartanimationitem_p.h \ |
|
10 | ||
11 | $$PWD/xychartanimator_p.h |
|
|||
12 |
|
11 | |||
13 | PUBLIC_HEADERS += \ |
|
12 | PUBLIC_HEADERS += \ | |
14 | $$PWD/qxyseries.h No newline at end of file |
|
13 | $$PWD/qxyseries.h |
@@ -1,6 +1,7 | |||||
1 | #include "xychartitem_p.h" |
|
1 | #include "xychartitem_p.h" | |
2 | #include "qxyseries.h" |
|
2 | #include "qxyseries.h" | |
3 | #include "chartpresenter_p.h" |
|
3 | #include "chartpresenter_p.h" | |
|
4 | #include "chartanimator_p.h" | |||
4 | #include <QPainter> |
|
5 | #include <QPainter> | |
5 |
|
6 | |||
6 |
|
7 | |||
@@ -57,7 +58,11 QVector<QPointF> XYChartItem::calculateGeometryPoints() const | |||||
57 |
|
58 | |||
58 | void XYChartItem::updatePoints(QVector<QPointF>& points) |
|
59 | void XYChartItem::updatePoints(QVector<QPointF>& points) | |
59 | { |
|
60 | { | |
60 | setGeometry(points); |
|
61 | if(m_animator){ | |
|
62 | m_animator->applyLayout(this,points); | |||
|
63 | } | |||
|
64 | else setGeometry(points); | |||
|
65 | ||||
61 | } |
|
66 | } | |
62 |
|
67 | |||
63 | void XYChartItem::updatePoint(QVector<QPointF>& points) |
|
68 | void XYChartItem::updatePoint(QVector<QPointF>& points) |
@@ -28,15 +28,14 public slots: | |||||
28 | void handleGeometryChanged(const QRectF& size); |
|
28 | void handleGeometryChanged(const QRectF& size); | |
29 |
|
29 | |||
30 | protected: |
|
30 | protected: | |
31 | virtual void updatePoints(QVector<QPointF>& points); |
|
|||
32 | virtual void updatePoint(QVector<QPointF>& points); |
|
|||
33 | virtual void setGeometry(QVector<QPointF>& points); |
|
31 | virtual void setGeometry(QVector<QPointF>& points); | |
34 |
|
||||
35 | QPointF calculateGeometryPoint(const QPointF& point) const; |
|
32 | QPointF calculateGeometryPoint(const QPointF& point) const; | |
36 | QPointF calculateGeometryPoint(int index) const; |
|
33 | QPointF calculateGeometryPoint(int index) const; | |
37 | QVector<QPointF> calculateGeometryPoints() const; |
|
34 | QVector<QPointF> calculateGeometryPoints() const; | |
38 |
|
35 | |||
39 | private: |
|
36 | private: | |
|
37 | void updatePoints(QVector<QPointF>& points); | |||
|
38 | void updatePoint(QVector<QPointF>& points); | |||
40 | inline bool isEmpty(); |
|
39 | inline bool isEmpty(); | |
41 |
|
40 | |||
42 | private: |
|
41 | private: | |
@@ -49,7 +48,7 private: | |||||
49 | QRectF m_clipRect; |
|
48 | QRectF m_clipRect; | |
50 | QVector<QPointF> m_points; |
|
49 | QVector<QPointF> m_points; | |
51 |
|
50 | |||
52 |
|
|
51 | friend class XYAnimation; | |
53 |
|
52 | |||
54 | }; |
|
53 | }; | |
55 |
|
54 |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
General Comments 0
You need to be logged in to leave comments.
Login now