##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » qtcharts
RSS

Clone from http://code.qt.io/qt/qtcharts.git

Animation folder formating: white spaces, brackets, etc fixed
Marek Rosa -
r738:ce991d3dee26
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,45 +1,45
1 1 #include "axisanimation_p.h"
2 2 #include <QTimer>
3 3
4 4 Q_DECLARE_METATYPE(QVector<qreal>)
5 5
6 6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
7 7
8 8
9 9 AxisAnimation::AxisAnimation(Axis *axis): ChartAnimation(axis),
10 10 m_axis(axis)
11 11 {
12 12 }
13 13
14 14 AxisAnimation::~AxisAnimation()
15 15 {
16 16 }
17 17
18 QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
18 QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
19 19 {
20 20 QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
21 21 QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
22 22 QVector<qreal> result;
23 23
24 24 Q_ASSERT(startVector.count() == endVecotr.count()) ;
25 25
26 for(int i =0 ;i< startVector.count();i++){
26 for(int i = 0; i < startVector.count(); i++){
27 27 qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
28 28 result << value;
29 29 }
30 30 return qVariantFromValue(result);
31 31 }
32 32
33 33
34 void AxisAnimation::updateCurrentValue (const QVariant & value )
34 void AxisAnimation::updateCurrentValue (const QVariant &value )
35 35 {
36 if(state()!=QAbstractAnimation::Stopped)//workaround
36 if (state() != QAbstractAnimation::Stopped)//workaround
37 37 {
38 38 QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
39 Q_ASSERT(vector.count()!=0);
39 Q_ASSERT(vector.count() != 0);
40 40 m_axis->setLayout(vector);
41 41 }
42 42
43 43 }
44 44
45 45 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,26 +1,26
1 1 #ifndef AXISANIMATIONITEM_H_
2 2 #define AXISANIMATIONITEM_H_
3 3
4 4 #include "axisitem_p.h"
5 5 #include "chartanimation_p.h"
6 6
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class AxisAnimation: public ChartAnimation
11 11 {
12 12 public:
13 13 AxisAnimation(Axis *axis);
14 14 ~AxisAnimation();
15 15 protected:
16 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
17 virtual void updateCurrentValue (const QVariant & value );
16 virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress ) const;
17 virtual void updateCurrentValue(const QVariant &value );
18 18 private:
19 Axis* m_axis;
19 Axis *m_axis;
20 20 };
21 21
22 22 QTCOMMERCIALCHART_END_NAMESPACE
23 23
24 24
25 25
26 26 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,52 +1,52
1 1 #include "baranimation_p.h"
2 2 #include "barchartitem_p.h"
3 3 #include <QParallelAnimationGroup>
4 4 #include <QTimer>
5 5
6 6 Q_DECLARE_METATYPE(QVector<QRectF>)
7 7 //Q_DECLARE_METATYPE(BarLayout) // TODO?
8 8
9 9
10 10 QTCOMMERCIALCHART_BEGIN_NAMESPACE
11 11
12 12 BarAnimation::BarAnimation(BarChartItem *item)
13 13 :ChartAnimation(item),
14 14 m_item(item)
15 15 {
16 16 }
17 17
18 18 BarAnimation::~BarAnimation()
19 19 {
20 20 }
21 21
22 22 QVariant BarAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
23 23 {
24 QVector<QRectF> startVector = qVariantValue<QVector<QRectF> > (from);
25 QVector<QRectF> endVector = qVariantValue<QVector<QRectF> > (to);
24 QVector<QRectF> startVector = qVariantValue<QVector<QRectF> >(from);
25 QVector<QRectF> endVector = qVariantValue<QVector<QRectF> >(to);
26 26 QVector<QRectF> result;
27 27
28 28 Q_ASSERT(startVector.count() == endVector.count()) ;
29 29
30 for(int i =0 ;i< startVector.count();i++){
30 for(int i = 0; i < startVector.count(); i++) {
31 31 qreal w = endVector[i].width();
32 32 qreal h = startVector[i].height() + ((endVector[i].height() - startVector[i].height()) * progress);
33 33 qreal x = endVector[i].topLeft().x();
34 34 qreal y = endVector[i].topLeft().y() + endVector[i].height() - h;
35 35
36 36 QPointF topLeft(x,y);
37 37 QSizeF size(w,h);
38 38 QRectF value(topLeft,size);
39 39 result << value;
40 40 }
41 41 return qVariantFromValue(result);
42 42 }
43 43
44 44 void BarAnimation::updateCurrentValue(const QVariant &value)
45 45 {
46 46 QVector<QRectF> layout = qVariantValue<QVector<QRectF> >(value);
47 47 m_item->setLayout(layout);
48 48 }
49 49
50 50 #include "moc_baranimation_p.cpp"
51 51
52 52 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,34 +1,34
1 1 #ifndef BARANIMATION_P_H_
2 2 #define BARANIMATION_P_H_
3 3
4 4 #include "chartanimation_p.h"
5 5 #include "barchartitem_p.h"
6 6
7 7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 8
9 9 class BarChartItem;
10 10 class QBarSet;
11 11 class BarSetAnimation;
12 12
13 13 class BarAnimation : public ChartAnimation
14 14 {
15 15 Q_OBJECT
16 16
17 17 public:
18 18 BarAnimation(BarChartItem *item);
19 19 ~BarAnimation();
20 20
21 21 public: // from QVariantAnimation
22 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
23 virtual void updateCurrentValue (const QVariant & value );
22 virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
23 virtual void updateCurrentValue(const QVariant &value);
24 24
25 25 public Q_SLOTS:
26 26
27 27 private:
28 28 BarChartItem *m_item;
29 QHash<QBarSet*, BarSetAnimation*> m_animations;
29 QHash<QBarSet *, BarSetAnimation *> m_animations;
30 30 };
31 31
32 32 QTCOMMERCIALCHART_END_NAMESPACE
33 33
34 34 #endif
Show file before | Show file after | Hide comments
@@ -1,26 +1,26
1 1 #ifndef CHARTANIMATION_H_
2 2 #define CHARTANIMATION_H_
3 3
4 4 #include "qchartglobal.h"
5 5 #include <QVariantAnimation>
6 6
7 7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 8
9 9 class ChartAnimation: public QVariantAnimation
10 10 {
11 11 public:
12 12 enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
13 ChartAnimation(QObject* parent=0):QVariantAnimation(parent),m_type(MoveDownAnimation){};
13 ChartAnimation(QObject* parent=0):QVariantAnimation(parent), m_type(MoveDownAnimation){}
14 14 void setAnimationType(Animation type){
15 15 m_type=type;
16 16 }
17 17 protected:
18 18 Animation m_type;
19 19
20 20 };
21 21
22 22 QTCOMMERCIALCHART_END_NAMESPACE
23 23
24 24
25 25
26 26 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,288 +1,279
1 1 #include "chartanimator_p.h"
2 2 #include "axisanimation_p.h"
3 3 #include "xyanimation_p.h"
4 4 #include "splineanimation_p.h"
5 5 #include "xychartitem_p.h"
6 6 #include "pieanimation_p.h"
7 7 #include "baranimation_p.h"
8 8 #include "barchartitem_p.h"
9 9 #include "areachartitem_p.h"
10 10 #include "splinechartitem_p.h"
11 11 #include "scatterchartitem_p.h"
12 12 #include <QTimer>
13 13
14 14 Q_DECLARE_METATYPE(QVector<QPointF>)
15 15 Q_DECLARE_METATYPE(QVector<qreal>)
16 16 Q_DECLARE_METATYPE(QVector<QRectF>)
17 17
18 18 QTCOMMERCIALCHART_BEGIN_NAMESPACE
19 19
20 20 const static int duration = 1000;
21 21
22 ChartAnimator::ChartAnimator(QObject *parent):QObject(parent),m_state(ShowState)
22 ChartAnimator::ChartAnimator(QObject *parent):QObject(parent),
23 m_state(ShowState)
23 24 {
24 25 }
25 26
26 27 ChartAnimator::~ChartAnimator()
27 28 {
28 29 }
29 30
30 void ChartAnimator::addAnimation(Axis* item)
31 void ChartAnimator::addAnimation(Axis *item)
31 32 {
32 ChartAnimation* animation = m_animations.value(item);
33 ChartAnimation *animation = m_animations.value(item);
33 34
34 if(!animation) {
35 if (!animation) {
35 36 animation = new AxisAnimation(item);
36 m_animations.insert(item,animation);
37 m_animations.insert(item, animation);
37 38 }
38 39
39 40 item->setAnimator(this);
40 41 }
41 42
42 void ChartAnimator::addAnimation(SplineChartItem* item)
43 void ChartAnimator::addAnimation(SplineChartItem *item)
43 44 {
44 ChartAnimation* animation = m_animations.value(item);
45 ChartAnimation *animation = m_animations.value(item);
45 46
46 if(!animation) {
47 if (!animation) {
47 48 animation = new SplineAnimation(item);
48 m_animations.insert(item,animation);
49 m_animations.insert(item, animation);
49 50 }
50 51
51 52 item->setAnimator(this);
52 53 }
53 54
54 void ChartAnimator::addAnimation(ScatterChartItem* item)
55 void ChartAnimator::addAnimation(ScatterChartItem *item)
55 56 {
56 ChartAnimation* animation = m_animations.value(item);
57 ChartAnimation *animation = m_animations.value(item);
57 58
58 if(!animation) {
59 if (!animation) {
59 60 animation = new XYAnimation(item);
60 m_animations.insert(item,animation);
61 m_animations.insert(item, animation);
61 62 }
62 63
63 64 item->setAnimator(this);
64 65 }
65 66
66 void ChartAnimator::addAnimation(LineChartItem* item)
67 void ChartAnimator::addAnimation(LineChartItem *item)
67 68 {
68 ChartAnimation* animation = m_animations.value(item);
69 ChartAnimation *animation = m_animations.value(item);
69 70
70 if(!animation) {
71 if (!animation) {
71 72 animation = new XYAnimation(item);
72 m_animations.insert(item,animation);
73 m_animations.insert(item, animation);
73 74 }
74 75
75 76 item->setAnimator(this);
76 77 }
77 78
78 void ChartAnimator::addAnimation(PieChartItem* item)
79 void ChartAnimator::addAnimation(PieChartItem *item)
79 80 {
80 ChartAnimation* animation = m_animations.value(item);
81 ChartAnimation *animation = m_animations.value(item);
81 82
82 if(!animation) {
83 if (!animation) {
83 84 animation = new PieAnimation(item);
84 m_animations.insert(item,animation);
85 m_animations.insert(item, animation);
85 86 }
86 87
87 88 item->setAnimator(this);
88 89 }
89 90
90 void ChartAnimator::addAnimation(BarChartItem* item)
91 void ChartAnimator::addAnimation(BarChartItem *item)
91 92 {
92 ChartAnimation* animation = m_animations.value(item);
93 ChartAnimation *animation = m_animations.value(item);
93 94
94 if(!animation) {
95 if (!animation) {
95 96 animation = new BarAnimation(item);
96 m_animations.insert(item,animation);
97 m_animations.insert(item, animation);
97 98 }
98 99
99 100 item->setAnimator(this);
100 101 }
101 102
102 103
103 void ChartAnimator::removeAnimation(Chart* item)
104 void ChartAnimator::removeAnimation(Chart *item)
104 105 {
105 106 item->setAnimator(0);
106 107 m_animations.remove(item);
107 108 }
108 109
109 void ChartAnimator::updateLayout(Axis* item , QVector<qreal>& newLayout)
110 void ChartAnimator::updateLayout(Axis *item , QVector<qreal> &newLayout)
110 111 {
111 AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
112 AxisAnimation *animation = static_cast<AxisAnimation*>(m_animations.value(item));
112 113
113 114 Q_ASSERT(animation);
114 115
115 116 QVector<qreal> oldLayout = item->layout();
116 117
117 if(newLayout.count()==0) return;
118
119 switch(m_state)
120 {
121 case ZoomOutState: {
122 QRectF rect = item->geometry();
123 oldLayout.resize(newLayout.count());
124
125 for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
126 {
127 oldLayout[i]= item->axisType()==Axis::X_AXIS?rect.left():rect.bottom();
128 oldLayout[j]= item->axisType()==Axis::X_AXIS?rect.right():rect.top();
129 }
130 }
131 break;
132 case ZoomInState: {
133 int index = qMin(oldLayout.count()*(item->axisType()==Axis::X_AXIS?m_point.x():(1 -m_point.y())),newLayout.count()-1.0);
134 oldLayout.resize(newLayout.count());
135
136 for(int i=0;i<oldLayout.count();i++)
137 {
138 oldLayout[i]= oldLayout[index];
139 }
140 }
141 break;
142 case ScrollDownState:
143 case ScrollRightState: {
144 oldLayout.resize(newLayout.count());
145
146 for(int i=0, j=i+1;i<oldLayout.count()-1;i++,j++)
147 {
148 oldLayout[i]= oldLayout[j];
149 }
150 }
151 break;
152 case ScrollUpState:
153 case ScrollLeftState: {
154 oldLayout.resize(newLayout.count());
155
156 for(int i=oldLayout.count()-1, j=i-1;i>0;i--,j--)
157 {
158 oldLayout[i]= oldLayout[j];
159 }
160 }
161 break;
162 default: {
163 oldLayout.resize(newLayout.count());
164 QRectF rect = item->geometry();
165 for(int i=0, j=oldLayout.count()-1;i<oldLayout.count();i++,j--)
166 {
167 oldLayout[i]= item->axisType()==Axis::X_AXIS?rect.left():rect.top();
168 }
169 }
170 break;
171 }
172
173
174 if(animation->state()!=QAbstractAnimation::Stopped) {
175 animation->stop();
118 if (newLayout.count() == 0)
119 return;
120
121 switch (m_state) {
122 case ZoomOutState: {
123 QRectF rect = item->geometry();
124 oldLayout.resize(newLayout.count());
125
126 for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; i++, j--) {
127 oldLayout[i] = item->axisType() == Axis::X_AXIS ? rect.left() : rect.bottom();
128 oldLayout[j] = item->axisType() == Axis::X_AXIS ? rect.right() : rect.top();
129 }
130 }
131 break;
132 case ZoomInState: {
133 int index = qMin(oldLayout.count() * (item->axisType() == Axis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - 1.0);
134 oldLayout.resize(newLayout.count());
135
136 for(int i = 0; i < oldLayout.count(); i++)
137 oldLayout[i]= oldLayout[index];
176 138 }
139 break;
140 case ScrollDownState:
141 case ScrollRightState: {
142 oldLayout.resize(newLayout.count());
143
144 for(int i = 0, j = i + 1; i < oldLayout.count() - 1; i++, j++)
145 oldLayout[i]= oldLayout[j];
146 }
147 break;
148 case ScrollUpState:
149 case ScrollLeftState: {
150 oldLayout.resize(newLayout.count());
151
152 for(int i = oldLayout.count() - 1, j = i - 1; i > 0; i--, j--)
153 oldLayout[i]= oldLayout[j];
154 }
155 break;
156 default: {
157 oldLayout.resize(newLayout.count());
158 QRectF rect = item->geometry();
159 for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); i++, j--)
160 oldLayout[i] = item->axisType() == Axis::X_AXIS ? rect.left() : rect.top();
161 }
162 break;
163 }
164
165
166 if (animation->state() != QAbstractAnimation::Stopped)
167 animation->stop();
177 168
178 169 animation->setDuration(duration);
179 170 animation->setEasingCurve(QEasingCurve::OutQuart);
180 171 QVariantAnimation::KeyValues value;
181 172 animation->setKeyValues(value); //workaround for wrong interpolation call
182 173 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
183 174 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
184 175
185 QTimer::singleShot(0,animation,SLOT(start()));
176 QTimer::singleShot(0, animation, SLOT(start()));
186 177 }
187 178
188 void ChartAnimator::updateLayout(SplineChartItem* item, QVector<QPointF>& oldPoints ,QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newControlPoints,int index)
179 void ChartAnimator::updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
189 180 {
190 SplineAnimation* animation = static_cast<SplineAnimation*>(m_animations.value(item));
181 SplineAnimation *animation = static_cast<SplineAnimation *>(m_animations.value(item));
191 182
192 183 Q_ASSERT(animation);
193 184
194 if(newPoints.count()<2 || newControlPoints.count()<2) return;
185 if (newPoints.count() < 2 || newControlPoints.count() < 2)
186 return;
195 187
196 bool empty = oldPoints.count()==0;
188 bool empty = oldPoints.count() == 0;
197 189
198 190
199 if(animation->state()!=QAbstractAnimation::Stopped) {
200 animation->stop();
201 }
191 if (animation->state() != QAbstractAnimation::Stopped)
192 animation->stop();
202 193
203 194 animation->setDuration(duration);
204 if(!empty)
205 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
195 if (!empty)
196 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
206 197 else
207 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
198 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
208 199
209 200 animation->setEasingCurve(QEasingCurve::OutQuart);
210 animation->setValues(oldPoints,newPoints,oldControlPoints,newControlPoints,index);
201 animation->setValues(oldPoints, newPoints, oldControlPoints, newControlPoints, index);
211 202
212 QTimer::singleShot(0,animation,SLOT(start()));
203 QTimer::singleShot(0, animation, SLOT(start()));
213 204 }
214 205
215 206
216 void ChartAnimator::updateLayout(XYChartItem* item, QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, int index)
207 void ChartAnimator::updateLayout(XYChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
217 208 {
218 XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
209 XYAnimation *animation = static_cast<XYAnimation *>(m_animations.value(item));
219 210
220 211 Q_ASSERT(animation);
221 212
222 if(newPoints.count()==0) return;
213 if (newPoints.count() == 0)
214 return;
223 215
224 bool empty = oldPoints.count()==0;
216 bool empty = oldPoints.count() == 0;
225 217
226 218
227 if(animation->state()!=QAbstractAnimation::Stopped) {
219 if (animation->state() != QAbstractAnimation::Stopped)
228 220 animation->stop();
229 }
230 221
231 222 animation->setDuration(duration);
232 if(!empty)
233 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
223 if (!empty)
224 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
234 225 else
235 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
226 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
236 227
237 228 animation->setEasingCurve(QEasingCurve::OutQuart);
238 animation->setValues(oldPoints,newPoints,index);
229 animation->setValues(oldPoints, newPoints, index);
239 230
240 QTimer::singleShot(0,animation,SLOT(start()));
231 QTimer::singleShot(0, animation, SLOT(start()));
241 232 }
242 233
243 void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
234 void ChartAnimator::addAnimation(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
244 235 {
245 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
236 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
246 237 Q_ASSERT(animation);
247 238 animation->addSlice(slice, sliceData, isEmpty);
248 239 }
249 240
250 void ChartAnimator::removeAnimation(PieChartItem* item, QPieSlice *slice)
241 void ChartAnimator::removeAnimation(PieChartItem *item, QPieSlice *slice)
251 242 {
252 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
243 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
253 244 Q_ASSERT(animation);
254 245 animation->removeSlice(slice);
255 246 }
256 247
257 void ChartAnimator::updateLayout(PieChartItem* item, const PieLayout &layout)
248 void ChartAnimator::updateLayout(PieChartItem *item, const PieLayout &layout)
258 249 {
259 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
250 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
260 251 Q_ASSERT(animation);
261 252 animation->updateValues(layout);
262 253 }
263 254
264 void ChartAnimator::updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData)
255 void ChartAnimator::updateLayout(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData)
265 256 {
266 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
257 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
267 258 Q_ASSERT(animation);
268 259 animation->updateValue(slice, sliceData);
269 260 }
270 261
271 void ChartAnimator::updateLayout(BarChartItem* item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
262 void ChartAnimator::updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
272 263 {
273 BarAnimation* animation = static_cast<BarAnimation*>(m_animations.value(item));
264 BarAnimation *animation = static_cast<BarAnimation *>(m_animations.value(item));
274 265 Q_ASSERT(animation);
275 266 animation->setDuration(duration);
276 267 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
277 268 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
278 QTimer::singleShot(0,animation,SLOT(start()));
269 QTimer::singleShot(0, animation, SLOT(start()));
279 270 }
280 271
281 272
282 void ChartAnimator::setState(State state,const QPointF& point)
273 void ChartAnimator::setState(State state, const QPointF &point)
283 274 {
284 m_state=state;
285 m_point=point;
275 m_state = state;
276 m_point = point;
286 277 }
287 278
288 279 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,57 +1,57
1 1 #ifndef CHARTANIMATOR_P_H_
2 2 #define CHARTANIMATOR_P_H_
3 3 #include "qchartglobal.h"
4 4 #include "chartanimation_p.h"
5 5 #include "piechartitem_p.h"
6 6 #include "barchartitem_p.h"
7 7 #include <QPointF>
8 8
9 9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10 10
11 11 class ChartItem;
12 12 class Axis;
13 13 class AreaChartItem;
14 14 class SplineChartItem;
15 15 class ScatterChartItem;
16 16 class LineChartItem;
17 17 class XYChartItem;
18 18
19 19 class ChartAnimator : public QObject {
20 20
21 21 public:
22 enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState,ScrollRightState,ZoomInState,ZoomOutState};
22 enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState, ScrollRightState, ZoomInState, ZoomOutState};
23 23
24 24 ChartAnimator(QObject *parent = 0);
25 25 virtual ~ChartAnimator();
26 26
27 void addAnimation(Axis* item);
28 void addAnimation(PieChartItem* item);
29 void addAnimation(ScatterChartItem* item);
30 void addAnimation(LineChartItem* item);
31 void addAnimation(SplineChartItem* item);
32 void addAnimation(BarChartItem* item);
33 void removeAnimation(Chart* item);
27 void addAnimation(Axis *item);
28 void addAnimation(PieChartItem *item);
29 void addAnimation(ScatterChartItem *item);
30 void addAnimation(LineChartItem *item);
31 void addAnimation(SplineChartItem *item);
32 void addAnimation(BarChartItem *item);
33 void removeAnimation(Chart *item);
34 34
35 35 void animationStarted();
36 void updateLayout(XYChartItem* item, QVector<QPointF>& oldLayout,QVector<QPointF>& newLayout,int index);
37 void updateLayout(SplineChartItem* item, QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newContorlPoints,int index);
38 void updateLayout(Axis* item, QVector<qreal>& layout);
36 void updateLayout(XYChartItem *item, QVector<QPointF> &oldLayout, QVector<QPointF> &newLayout, int index);
37 void updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newContorlPoints, int index);
38 void updateLayout(Axis *item, QVector<qreal> &layout);
39 39
40 void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
41 void removeAnimation(PieChartItem* item, QPieSlice *slice);
42 void updateLayout(PieChartItem* item, const PieLayout &layout);
43 void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceData &sliceData);
40 void addAnimation(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
41 void removeAnimation(PieChartItem *item, QPieSlice *slice);
42 void updateLayout(PieChartItem *item, const PieLayout &layout);
43 void updateLayout(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData);
44 44
45 void updateLayout(BarChartItem* item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
45 void updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
46 46
47 void setState(State state,const QPointF& point = QPointF());
47 void setState(State state,const QPointF &point = QPointF());
48 48
49 49 private:
50 QMap<Chart*,ChartAnimation*> m_animations;
50 QMap<Chart *, ChartAnimation *> m_animations;
51 51 State m_state;
52 52 QPointF m_point;
53 53 };
54 54
55 55 QTCOMMERCIALCHART_END_NAMESPACE
56 56
57 57 #endif
Show file before | Show file after | Hide comments
@@ -1,92 +1,92
1 1 #include "pieanimation_p.h"
2 2 #include "piesliceanimation_p.h"
3 3 #include "piechartitem_p.h"
4 4 #include <QParallelAnimationGroup>
5 5 #include <QTimer>
6 6
7 7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 8
9 9 PieAnimation::PieAnimation(PieChartItem *item)
10 10 :ChartAnimation(item),
11 11 m_item(item)
12 12 {
13 13 }
14 14
15 15 PieAnimation::~PieAnimation()
16 16 {
17 17 }
18 18
19 19 void PieAnimation::updateValues(const PieLayout &newValues)
20 20 {
21 foreach (QPieSlice* s, newValues.keys())
21 foreach (QPieSlice *s, newValues.keys())
22 22 updateValue(s, newValues.value(s));
23 23 }
24 24
25 25 void PieAnimation::updateValue(QPieSlice *slice, const PieSliceData &sliceData)
26 26 {
27 27 PieSliceAnimation *animation = m_animations.value(slice);
28 28 Q_ASSERT(animation);
29 29 animation->stop();
30 30
31 31 animation->updateValue(sliceData);
32 32 animation->setDuration(1000);
33 33 animation->setEasingCurve(QEasingCurve::OutQuart);
34 34
35 35 QTimer::singleShot(0, animation, SLOT(start()));
36 36 }
37 37
38 38 void PieAnimation::addSlice(QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
39 39 {
40 40 PieSliceAnimation *animation = new PieSliceAnimation(m_item, slice);
41 41 m_animations.insert(slice, animation);
42 42
43 43 PieSliceData startValue = sliceData;
44 44 startValue.m_radius = 0;
45 45 if (isEmpty)
46 46 startValue.m_startAngle = 0;
47 47 else
48 startValue.m_startAngle = sliceData.m_startAngle + (sliceData.m_angleSpan/2);
48 startValue.m_startAngle = sliceData.m_startAngle + (sliceData.m_angleSpan / 2);
49 49 startValue.m_angleSpan = 0;
50 50 animation->setValue(startValue, sliceData);
51 51
52 52 animation->setDuration(1000);
53 53 animation->setEasingCurve(QEasingCurve::OutQuart);
54 54 QTimer::singleShot(0, animation, SLOT(start()));
55 55 }
56 56
57 57 void PieAnimation::removeSlice(QPieSlice *slice)
58 58 {
59 59 PieSliceAnimation *animation = m_animations.value(slice);
60 60 Q_ASSERT(animation);
61 61 animation->stop();
62 62
63 63 PieSliceData endValue = animation->currentSliceValue();
64 64 endValue.m_radius = 0;
65 65 // TODO: find the actual angle where this slice disappears
66 66 endValue.m_startAngle = endValue.m_startAngle + endValue.m_angleSpan;
67 67 endValue.m_angleSpan = 0;
68 68
69 69 animation->updateValue(endValue);
70 70 animation->setDuration(1000);
71 71 animation->setEasingCurve(QEasingCurve::OutQuart);
72 72
73 73 connect(animation, SIGNAL(finished()), this, SLOT(destroySliceAnimationComplete()));
74 74 QTimer::singleShot(0, animation, SLOT(start()));
75 75 }
76 76
77 77 void PieAnimation::updateCurrentValue(const QVariant &)
78 78 {
79 79 // nothing to do...
80 80 }
81 81
82 82 void PieAnimation::destroySliceAnimationComplete()
83 83 {
84 PieSliceAnimation *animation = static_cast<PieSliceAnimation*>(sender());
84 PieSliceAnimation *animation = static_cast<PieSliceAnimation *>(sender());
85 85 QPieSlice *slice = m_animations.key(animation);
86 86 m_item->destroySlice(slice);
87 87 delete m_animations.take(slice);
88 88 }
89 89
90 90 #include "moc_pieanimation_p.cpp"
91 91
92 92 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,37 +1,37
1 1 #ifndef PIEANIMATION_P_H_
2 2 #define PIEANIMATION_P_H_
3 3
4 4 #include "chartanimation_p.h"
5 5 #include "piechartitem_p.h"
6 6 #include "piesliceanimation_p.h"
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class PieChartItem;
11 11
12 12 class PieAnimation : public ChartAnimation
13 13 {
14 14 Q_OBJECT
15 15
16 16 public:
17 17 PieAnimation(PieChartItem *item);
18 18 ~PieAnimation();
19 19 void updateValues(const PieLayout &newValues);
20 20 void updateValue(QPieSlice *slice, const PieSliceData &newValue);
21 21 void addSlice(QPieSlice *slice, const PieSliceData &endValue, bool isEmpty);
22 22 void removeSlice(QPieSlice *slice);
23 23
24 24 public: // from QVariantAnimation
25 25 void updateCurrentValue(const QVariant &value);
26 26
27 27 public Q_SLOTS:
28 28 void destroySliceAnimationComplete();
29 29
30 30 private:
31 31 PieChartItem *m_item;
32 QHash<QPieSlice*, PieSliceAnimation*> m_animations;
32 QHash<QPieSlice *, PieSliceAnimation *> m_animations;
33 33 };
34 34
35 35 QTCOMMERCIALCHART_END_NAMESPACE
36 36
37 37 #endif
Show file before | Show file after | Hide comments
@@ -1,127 +1,129
1 1 #include "splineanimation_p.h"
2 2 #include "splinechartitem_p.h"
3 3
4 4 Q_DECLARE_METATYPE(QVector<QPointF>)
5 5 Q_DECLARE_METATYPE(SplineVector)
6 6
7 7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 8
9 9 SplineAnimation::SplineAnimation(SplineChartItem* item):ChartAnimation(item),
10 m_item(item),
11 m_dirty(true)
10 m_item(item),
11 m_dirty(true)
12 12 {
13 13 }
14 14
15 15 SplineAnimation::~SplineAnimation()
16 16 {
17 17 }
18 18
19 void SplineAnimation::setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,QVector<QPointF>& oldControlPoints,QVector<QPointF>& newControlPoints,int index)
19 void SplineAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
20 20 {
21 21 int x = oldPoints.count();
22 22 int y = newPoints.count();
23 23
24 Q_ASSERT(newPoints.count()*2-2 == newControlPoints.count());
24 Q_ASSERT(newPoints.count() * 2 - 2 == newControlPoints.count());
25 25
26 if(x!=y && abs(x-y)!=1) {
27 m_oldSpline.first= newPoints;
28 m_oldSpline.second= newControlPoints;
26 if (x != y && abs(x - y) != 1) {
27 m_oldSpline.first = newPoints;
28 m_oldSpline.second = newControlPoints;
29 29 oldPoints.resize(newPoints.size());
30 30 oldControlPoints.resize(newControlPoints.size());
31 31 SplineVector oldPair;
32 oldPair.first=oldPoints;
33 oldPair.second=oldControlPoints;
32 oldPair.first = oldPoints;
33 oldPair.second = oldControlPoints;
34 34 SplineVector newPair;
35 newPair.first=newPoints;
36 newPair.second=newControlPoints;
35 newPair.first = newPoints;
36 newPair.second = newControlPoints;
37 37 setKeyValueAt(0.0, qVariantFromValue(oldPair));
38 38 setKeyValueAt(1.0, qVariantFromValue(newPair));
39 m_dirty=false;
39 m_dirty = false;
40 40 }
41 41 else {
42 42 if(m_dirty) {
43 43 m_oldSpline.first = oldPoints;
44 44 m_oldSpline.second = oldControlPoints;
45 m_dirty=false;
45 m_dirty = false;
46 46 }
47 47 oldPoints = newPoints;
48 48 oldControlPoints = newControlPoints;
49 if (y<x) {
49 if (y < x) {
50 50 m_oldSpline.first.remove(index); //remove
51 m_oldSpline.second.remove(index*2);
52 m_oldSpline.second.remove(index*2);
51 m_oldSpline.second.remove(index * 2);
52 m_oldSpline.second.remove(index * 2);
53 53 }
54 if (y>x) {
55 m_oldSpline.first.insert(index,x>0?m_oldSpline.first[index-1]:newPoints[index]); //add
56 m_oldSpline.second.insert((index-1)*2,x>1?m_oldSpline.second[(index-2)*2]:newControlPoints[(index-1)*2]); //add
57 m_oldSpline.second.insert((index-1)*2+1,x>1?m_oldSpline.second[(index-2)*2+1]:newControlPoints[(index-1)*2+1]); //add
54 if (y > x) {
55 m_oldSpline.first.insert(index, x > 0 ? m_oldSpline.first[index-1] : newPoints[index]); //add
56 m_oldSpline.second.insert((index - 1) * 2, x > 1 ? m_oldSpline.second[(index-2)*2] : newControlPoints[(index - 1) * 2]); //add
57 m_oldSpline.second.insert((index - 1) * 2 + 1, x > 1 ? m_oldSpline.second[(index - 2) * 2 + 1] : newControlPoints[(index - 1) * 2 + 1]); //add
58 58 }
59 59 SplineVector newPair;
60 60 newPair.first=newPoints;
61 61 newPair.second=newControlPoints;
62 62 setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
63 63 setKeyValueAt(1.0, qVariantFromValue(newPair));
64 64
65 65 }
66 66 }
67 67
68 QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
68 QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
69 69 {
70 70
71 71 SplineVector startPair = qVariantValue< SplineVector >(start);
72 72 SplineVector endPair = qVariantValue< SplineVector >(end);
73 73 SplineVector result;
74 74
75 75
76 switch(m_type) {
77
78 case MoveDownAnimation: {
76 switch (m_type) {
79 77
80 if(startPair.first.count() != endPair.first.count()) break;
81 Q_ASSERT(startPair.first.count()*2-2 == startPair.second.count());
82 Q_ASSERT(endPair.first.count()*2-2 == endPair.second.count());
83 for(int i =0;i< endPair.first.count();i++) {
84 qreal x = startPair.first[i].x() + ((endPair.first[i].x()- startPair.first[i].x()) * progress);
85 qreal y = startPair.first[i].y() + ((endPair.first[i].y()- startPair.first[i].y()) * progress);
86 result.first << QPointF(x,y);
87 if(i +1 >= endPair.first.count()) continue;
88 x = startPair.second[i*2].x() + ((endPair.second[i*2].x()- startPair.second[i*2].x()) * progress);
89 y = startPair.second[i*2].y() + ((endPair.second[i*2].y()- startPair.second[i*2].y()) * progress);
90 result.second << QPoint(x,y);
91 x = startPair.second[i*2+1].x() + ((endPair.second[i*2+1].x()- startPair.second[i*2+1].x()) * progress);
92 y = startPair.second[i*2+1].y() + ((endPair.second[i*2+1].y()- startPair.second[i*2+1].y()) * progress);
93 result.second << QPoint(x,y);
94 }
95
96 }
78 case MoveDownAnimation: {
79 if (startPair.first.count() != endPair.first.count())
97 80 break;
98 case LineDrawAnimation:{
99 Q_ASSERT(endPair.first.count()*2-2 == endPair.second.count());
100 int count = endPair.first.count()* qBound(0.0, progress, 1.0);
101 for(int i =0;i<count;i++) {
102 result.first << endPair.first[i];
103 if(i+1==count) break;
104 result.second << endPair.second[2*i];
105 result.second << endPair.second[2*i+1];
106 }
81 Q_ASSERT(startPair.first.count() * 2 - 2 == startPair.second.count());
82 Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
83 for(int i = 0; i < endPair.first.count(); i++) {
84 qreal x = startPair.first[i].x() + ((endPair.first[i].x() - startPair.first[i].x()) * progress);
85 qreal y = startPair.first[i].y() + ((endPair.first[i].y() - startPair.first[i].y()) * progress);
86 result.first << QPointF(x,y);
87 if (i + 1 >= endPair.first.count())
88 continue;
89 x = startPair.second[i * 2].x() + ((endPair.second[i * 2].x() - startPair.second[i * 2].x()) * progress);
90 y = startPair.second[i * 2].y() + ((endPair.second[i * 2].y() - startPair.second[i * 2].y()) * progress);
91 result.second << QPoint(x,y);
92 x = startPair.second[i * 2 + 1].x() + ((endPair.second[i * 2 + 1].x() - startPair.second[i * 2 + 1].x()) * progress);
93 y = startPair.second[i * 2 + 1].y() + ((endPair.second[i * 2 + 1].y() - startPair.second[i * 2 + 1].y()) * progress);
94 result.second << QPoint(x,y);
107 95 }
108 break;
109 default:
110 qWarning()<<"Unknow type of animation";
111 break;
96
97 }
98 break;
99 case LineDrawAnimation:{
100 Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
101 int count = endPair.first.count()* qBound(0.0, progress, 1.0);
102 for(int i = 0; i < count; i++) {
103 result.first << endPair.first[i];
104 if(i + 1 == count)
105 break;
106 result.second << endPair.second[2 * i];
107 result.second << endPair.second[2 * i + 1];
108 }
109 }
110 break;
111 default:
112 qWarning() << "Unknow type of animation";
113 break;
112 114 }
113 115
114 116 return qVariantFromValue(result);
115 117 }
116 118
117 void SplineAnimation::updateCurrentValue (const QVariant & value )
119 void SplineAnimation::updateCurrentValue (const QVariant &value )
118 120 {
119 if(state()!=QAbstractAnimation::Stopped){ //workaround
120 m_dirty=true;
121 if (state() != QAbstractAnimation::Stopped) { //workaround
122 m_dirty = true;
121 123 QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
122 m_item->setLayout(pair.first,pair.second);
124 m_item->setLayout(pair.first, pair.second);
123 125 }
124 126 }
125 127
126 128
127 129 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,33 +1,32
1 1 #ifndef SPLINEANIMATION_P_H_
2 2 #define SPLINEANIMATION_P_H_
3 3 #include "chartanimation_p.h"
4 4 #include <QPointF>
5 5
6 6 typedef QPair<QVector<QPointF >, QVector<QPointF > > SplineVector;
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10
11 10 class SplineChartItem;
12 11
13 12 class SplineAnimation : public ChartAnimation
14 13 {
15 14 public:
16 15
17 16 SplineAnimation(SplineChartItem* item);
18 17 ~SplineAnimation();
19 void setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,QVector<QPointF>& oldContorlPoints,QVector<QPointF>& newControlPoints,int index);
18 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldContorlPoints, QVector<QPointF> &newControlPoints, int index);
20 19
21 20 protected:
22 QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
23 void updateCurrentValue (const QVariant & value );
21 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress) const;
22 void updateCurrentValue(const QVariant &value);
24 23
25 24 private:
26 25 SplineVector m_oldSpline;
27 SplineChartItem* m_item;
26 SplineChartItem *m_item;
28 27 bool m_dirty;
29 28 };
30 29
31 30 QTCOMMERCIALCHART_END_NAMESPACE
32 31
33 32 #endif
Show file before | Show file after | Hide comments
@@ -1,88 +1,89
1 1 #include "xyanimation_p.h"
2 2 #include "xychartitem_p.h"
3 3
4 4 Q_DECLARE_METATYPE(QVector<QPointF>)
5 5
6 6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
7 7
8 8 XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
9 9 m_item(item),
10 10 m_dirty(false)
11 11 {
12 12 }
13 13
14 14 XYAnimation::~XYAnimation()
15 15 {
16 16 }
17 17
18 void XYAnimation::setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index)
18 void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
19 19 {
20
21 20 int x = oldPoints.count();
22 21 int y = newPoints.count();
23 22
24 if(x!=y && abs(x-y)!=1) {
23 if (x != y && abs(x - y) != 1) {
25 24 m_oldPoints = newPoints;
26 25 oldPoints.resize(newPoints.size());
27 26 setKeyValueAt(0.0, qVariantFromValue(oldPoints));
28 27 setKeyValueAt(1.0, qVariantFromValue(newPoints));
29 m_dirty=false;
28 m_dirty = false;
30 29 }
31 30 else {
32 if(m_dirty) {
31 if (m_dirty) {
33 32 m_oldPoints = oldPoints;
34 m_dirty=false;
33 m_dirty = false;
35 34 }
36 35 oldPoints = newPoints;
37 if (y<x) (m_oldPoints.remove(index)); //remove
38 if (y>x) (m_oldPoints.insert(index,x>0?m_oldPoints[index-1]:newPoints[index])); //add
36 if (y < x)
37 m_oldPoints.remove(index); //remove
38 if (y > x)
39 m_oldPoints.insert(index, x > 0 ? m_oldPoints[index-1] : newPoints[index]); //add
39 40 setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
40 41 setKeyValueAt(1.0, qVariantFromValue(newPoints));
41 42 Q_ASSERT(m_oldPoints.count() == newPoints.count());
42 43 }
43 44 }
44 45
45 QVariant XYAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
46 QVariant XYAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
46 47 {
47 48 QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
48 49 QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
49 50 QVector<QPointF> result;
50 51
51 switch(m_type) {
52
53 case MoveDownAnimation: {
54
55 if(startVector.count() != endVector.count()) break;
52 switch (m_type) {
56 53
57 for(int i =0;i< startVector.count();i++) {
58 qreal x = startVector[i].x() + ((endVector[i].x()- startVector[i].x()) * progress);
59 qreal y = startVector[i].y() + ((endVector[i].y()- startVector[i].y()) * progress);
60 result << QPointF(x,y);
61 }
54 case MoveDownAnimation: {
62 55
63 }
56 if (startVector.count() != endVector.count())
64 57 break;
65 case LineDrawAnimation:{
66 for(int i =0;i< endVector.count()* qBound(0.0, progress, 1.0);i++) {
67 result << endVector[i];
68 }
58
59 for(int i = 0; i < startVector.count(); i++) {
60 qreal x = startVector[i].x() + ((endVector[i].x() - startVector[i].x()) * progress);
61 qreal y = startVector[i].y() + ((endVector[i].y() - startVector[i].y()) * progress);
62 result << QPointF(x, y);
69 63 }
70 break;
71 default:
72 qWarning()<<"Unknown type of animation";
73 break;
64
65 }
66 break;
67 case LineDrawAnimation: {
68 for(int i = 0; i < endVector.count() * qBound(0.0, progress, 1.0); i++)
69 result << endVector[i];
70 }
71 break;
72 default:
73 qWarning() << "Unknown type of animation";
74 break;
74 75 }
75 76
76 77 return qVariantFromValue(result);
77 78 }
78 79
79 void XYAnimation::updateCurrentValue (const QVariant & value )
80 void XYAnimation::updateCurrentValue (const QVariant &value)
80 81 {
81 82 if(state()!=QAbstractAnimation::Stopped){ //workaround
82 m_dirty=true;
83 m_dirty = true;
83 84 QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
84 85 m_item->setLayout(vector);
85 86 }
86 87 }
87 88
88 89 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,30 +1,30
1 1 #ifndef XYCHARTANIMATION_P_H_
2 2 #define XYCHARTANIMATION_P_H_
3 3 #include "chartanimation_p.h"
4 4 #include <QPointF>
5 5
6 6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
7 7
8 8 class XYChartItem;
9 9
10 10 class XYAnimation : public ChartAnimation
11 11 {
12 12 public:
13 enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
13 enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
14 14 XYAnimation(XYChartItem *item);
15 15 ~XYAnimation();
16 void setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index);
16 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
17 17
18 18 protected:
19 QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
20 void updateCurrentValue (const QVariant & value );
19 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress ) const;
20 void updateCurrentValue (const QVariant &value );
21 21
22 22 private:
23 23 XYChartItem *m_item;
24 24 QVector<QPointF> m_oldPoints;
25 25 bool m_dirty;
26 26 };
27 27
28 28 QTCOMMERCIALCHART_END_NAMESPACE
29 29
30 30 #endif
General Comments 0
You need to be logged in to leave comments. Login now