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

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

Refactors animation handling for xyseries
Michal Klocek -
r1217:b0870dfe6522
parent child
Show More
Side by Side Unified
Context file:
r1217:b0870dfe6522 Loading diff...:
Show file before | Show file after | Hide comments
@@ -31,14 +31,7 const static int ChartAnimationDuration = 1000;
31 class ChartAnimation: public QVariantAnimation
31 class ChartAnimation: public QVariantAnimation
32 {
32 {
33 public:
33 public:
34 enum Animation { LineDrawAnimation, MoveDownAnimation, MoveUpAnimation };
34 ChartAnimation(QObject *parent = 0):QVariantAnimation(parent){};
35 ChartAnimation(QObject *parent = 0):QVariantAnimation(parent), m_type(MoveDownAnimation){}
36 void setAnimationType(Animation type){
37 m_type=type;
38 }
39 protected:
40 Animation m_type;
41
42 };
35 };
43
36
44 QTCOMMERCIALCHART_END_NAMESPACE
37 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -58,42 +58,6 void ChartAnimator::addAnimation(ChartAxis *item)
58 item->setAnimator(this);
58 item->setAnimator(this);
59 }
59 }
60
60
61 void ChartAnimator::addAnimation(SplineChartItem *item)
62 {
63 ChartAnimation *animation = m_animations.value(item);
64
65 if (!animation) {
66 animation = new SplineAnimation(item);
67 m_animations.insert(item, animation);
68 }
69
70 item->setAnimator(this);
71 }
72
73 void ChartAnimator::addAnimation(ScatterChartItem *item)
74 {
75 ChartAnimation *animation = m_animations.value(item);
76
77 if (!animation) {
78 animation = new XYAnimation(item);
79 m_animations.insert(item, animation);
80 }
81
82 item->setAnimator(this);
83 }
84
85 void ChartAnimator::addAnimation(LineChartItem *item)
86 {
87 ChartAnimation *animation = m_animations.value(item);
88
89 if (!animation) {
90 animation = new XYAnimation(item);
91 m_animations.insert(item, animation);
92 }
93
94 item->setAnimator(this);
95 }
96
97 void ChartAnimator::addAnimation(PieChartItem *item)
61 void ChartAnimator::addAnimation(PieChartItem *item)
98 {
62 {
99 ChartAnimation *animation = m_animations.value(item);
63 ChartAnimation *animation = m_animations.value(item);
@@ -194,61 +158,6 void ChartAnimator::updateLayout(ChartAxis *item , QVector<qreal> &newLayout)
194 QTimer::singleShot(0, animation, SLOT(start()));
158 QTimer::singleShot(0, animation, SLOT(start()));
195 }
159 }
196
160
197 void ChartAnimator::updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
198 {
199 SplineAnimation *animation = static_cast<SplineAnimation *>(m_animations.value(item));
200
201 Q_ASSERT(animation);
202
203 if (newPoints.count() < 2 || newControlPoints.count() < 2)
204 return;
205
206 bool empty = oldPoints.count() == 0;
207
208
209 if (animation->state() != QAbstractAnimation::Stopped)
210 animation->stop();
211
212 animation->setDuration(ChartAnimationDuration);
213 if (!empty)
214 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
215 else
216 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
217
218 animation->setEasingCurve(QEasingCurve::OutQuart);
219 animation->setValues(oldPoints, newPoints, oldControlPoints, newControlPoints, index);
220
221 QTimer::singleShot(0, animation, SLOT(start()));
222 }
223
224
225 void ChartAnimator::updateLayout(XYChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
226 {
227 XYAnimation *animation = static_cast<XYAnimation *>(m_animations.value(item));
228
229 Q_ASSERT(animation);
230
231 if (newPoints.count() == 0)
232 return;
233
234 bool empty = oldPoints.count() == 0;
235
236
237 if (animation->state() != QAbstractAnimation::Stopped)
238 animation->stop();
239
240 animation->setDuration(ChartAnimationDuration);
241 if (!empty)
242 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
243 else
244 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
245
246 animation->setEasingCurve(QEasingCurve::OutQuart);
247 animation->setValues(oldPoints, newPoints, index);
248
249 QTimer::singleShot(0, animation, SLOT(start()));
250 }
251
252 void ChartAnimator::addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
161 void ChartAnimator::addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
253 {
162 {
254 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
163 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
@@ -287,6 +196,16 void ChartAnimator::setState(State state, const QPointF &point)
287 m_point = point;
196 m_point = point;
288 }
197 }
289
198
199 void ChartAnimator::startAnimation(XYAnimation* animation)
200 {
201 Q_ASSERT(animation);
202 if (animation->state() != QAbstractAnimation::Stopped)
203 animation->stop();
204 animation->setDuration(ChartAnimationDuration);
205 animation->setEasingCurve(QEasingCurve::OutQuart);
206 QTimer::singleShot(0, animation, SLOT(start()));
207 }
208
290 #include "moc_chartanimator_p.cpp"
209 #include "moc_chartanimator_p.cpp"
291
210
292 QTCOMMERCIALCHART_END_NAMESPACE
211 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -36,6 +36,7 class SplineChartItem;
36 class ScatterChartItem;
36 class ScatterChartItem;
37 class LineChartItem;
37 class LineChartItem;
38 class XYChartItem;
38 class XYChartItem;
39 class XYAnimation;
39
40
40 class ChartAnimator : public QObject
41 class ChartAnimator : public QObject
41 {
42 {
@@ -48,15 +49,10 public:
48
49
49 void addAnimation(ChartAxis *item);
50 void addAnimation(ChartAxis *item);
50 void addAnimation(PieChartItem *item);
51 void addAnimation(PieChartItem *item);
51 void addAnimation(ScatterChartItem *item);
52 void addAnimation(LineChartItem *item);
53 void addAnimation(SplineChartItem *item);
54 void addAnimation(BarChartItem *item);
52 void addAnimation(BarChartItem *item);
55 void removeAnimation(Chart *item);
53 void removeAnimation(Chart *item);
56
54
57 void animationStarted();
55 void animationStarted();
58 void updateLayout(XYChartItem *item, QVector<QPointF> &oldLayout, QVector<QPointF> &newLayout, int index);
59 void updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newContorlPoints, int index);
60 void updateLayout(ChartAxis *item, QVector<qreal> &layout);
56 void updateLayout(ChartAxis *item, QVector<qreal> &layout);
61
57
62 void addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty);
58 void addAnimation(PieChartItem *item, PieSliceItem *sliceItem, const PieSliceData &sliceData, bool isEmpty);
@@ -67,6 +63,8 public:
67
63
68 void setState(State state,const QPointF &point = QPointF());
64 void setState(State state,const QPointF &point = QPointF());
69
65
66 void startAnimation(XYAnimation* animation);
67
70 private:
68 private:
71 QMap<Chart *, ChartAnimation *> m_animations;
69 QMap<Chart *, ChartAnimation *> m_animations;
72 State m_state;
70 State m_state;
Show file before | Show file after | Hide comments
@@ -27,7 +27,7 Q_DECLARE_METATYPE(SplineVector)
27
27
28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29
29
30 SplineAnimation::SplineAnimation(SplineChartItem* item):ChartAnimation(item),
30 SplineAnimation::SplineAnimation(SplineChartItem* item):XYAnimation(item),
31 m_item(item),
31 m_item(item),
32 m_dirty(true)
32 m_dirty(true)
33 {
33 {
@@ -82,7 +82,6 void SplineAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &n
82 newPair.second=newControlPoints;
82 newPair.second=newControlPoints;
83 setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
83 setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
84 setKeyValueAt(1.0, qVariantFromValue(newPair));
84 setKeyValueAt(1.0, qVariantFromValue(newPair));
85
86 }
85 }
87 }
86 }
88
87
@@ -93,8 +92,7 QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &en
93 SplineVector endPair = qVariantValue< SplineVector >(end);
92 SplineVector endPair = qVariantValue< SplineVector >(end);
94 SplineVector result;
93 SplineVector result;
95
94
96
95 switch (animationType()) {
97 switch (m_type) {
98
96
99 case MoveDownAnimation: {
97 case MoveDownAnimation: {
100 if (startPair.first.count() != endPair.first.count())
98 if (startPair.first.count() != endPair.first.count())
@@ -130,7 +128,7 QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &en
130 }
128 }
131 break;
129 break;
132 default:
130 default:
133 qWarning() << "Unknow type of animation";
131 qWarning() << "Unknown type of animation";
134 break;
132 break;
135 }
133 }
136
134
@@ -142,7 +140,9 void SplineAnimation::updateCurrentValue (const QVariant &value )
142 if (state() != QAbstractAnimation::Stopped) { //workaround
140 if (state() != QAbstractAnimation::Stopped) { //workaround
143 m_dirty = true;
141 m_dirty = true;
144 QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
142 QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
145 m_item->setLayout(pair.first, pair.second);
143 m_item->setGeometryPoints(pair.first);
144 m_item->setControlGeometryPoints(pair.second);
145 m_item->updateGeometry();
146 }
146 }
147 }
147 }
148
148
Show file before | Show file after | Hide comments
@@ -20,7 +20,7
20
20
21 #ifndef SPLINEANIMATION_P_H
21 #ifndef SPLINEANIMATION_P_H
22 #define SPLINEANIMATION_P_H
22 #define SPLINEANIMATION_P_H
23 #include "chartanimation_p.h"
23 #include "xyanimation_p.h"
24 #include <QPointF>
24 #include <QPointF>
25
25
26 typedef QPair<QVector<QPointF >, QVector<QPointF > > SplineVector;
26 typedef QPair<QVector<QPointF >, QVector<QPointF > > SplineVector;
@@ -29,10 +29,9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29
29
30 class SplineChartItem;
30 class SplineChartItem;
31
31
32 class SplineAnimation : public ChartAnimation
32 class SplineAnimation : public XYAnimation
33 {
33 {
34 public:
34 public:
35
36 SplineAnimation(SplineChartItem *item);
35 SplineAnimation(SplineChartItem *item);
37 ~SplineAnimation();
36 ~SplineAnimation();
38 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldContorlPoints, QVector<QPointF> &newControlPoints, int index);
37 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldContorlPoints, QVector<QPointF> &newControlPoints, int index);
Show file before | Show file after | Hide comments
@@ -28,7 +28,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
28
28
29 XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
29 XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
30 m_item(item),
30 m_item(item),
31 m_dirty(false)
31 m_dirty(false),
32 m_type(MoveDownAnimation)
32 {
33 {
33 }
34 }
34
35
@@ -36,6 +37,11 XYAnimation::~XYAnimation()
36 {
37 {
37 }
38 }
38
39
40 void XYAnimation::setAnimationType(Animation type)
41 {
42 m_type=type;
43 }
44
39 void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
45 void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
40 {
46 {
41 int x = oldPoints.count();
47 int x = oldPoints.count();
@@ -103,7 +109,8 void XYAnimation::updateCurrentValue (const QVariant &value)
103 if(state()!=QAbstractAnimation::Stopped){ //workaround
109 if(state()!=QAbstractAnimation::Stopped){ //workaround
104 m_dirty = true;
110 m_dirty = true;
105 QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
111 QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
106 m_item->setLayout(vector);
112 m_item->setGeometryPoints(vector);
113 m_item->updateGeometry();
107 }
114 }
108 }
115 }
109
116
Show file before | Show file after | Hide comments
@@ -35,6 +35,8 public:
35 XYAnimation(XYChartItem *item);
35 XYAnimation(XYChartItem *item);
36 ~XYAnimation();
36 ~XYAnimation();
37 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
37 void setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
38 void setAnimationType(Animation type);
39 Animation animationType() const { return m_type; };
38
40
39 protected:
41 protected:
40 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress ) const;
42 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress ) const;
@@ -44,6 +46,7 private:
44 XYChartItem *m_item;
46 XYChartItem *m_item;
45 QVector<QPointF> m_oldPoints;
47 QVector<QPointF> m_oldPoints;
46 bool m_dirty;
48 bool m_dirty;
49 Animation m_type;
47 };
50 };
48
51
49 QTCOMMERCIALCHART_END_NAMESPACE
52 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -43,8 +43,8 AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
43 if (m_series->lowerSeries())
43 if (m_series->lowerSeries())
44 m_lower = new AreaBoundItem(this,m_series->lowerSeries());
44 m_lower = new AreaBoundItem(this,m_series->lowerSeries());
45
45
46 connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
46 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
47 connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
47 QObject::connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
48
48
49 handleUpdated();
49 handleUpdated();
50 }
50 }
@@ -125,9 +125,9 void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
125 painter->drawPath(m_path);
125 painter->drawPath(m_path);
126 if (m_pointsVisible) {
126 if (m_pointsVisible) {
127 painter->setPen(m_pointPen);
127 painter->setPen(m_pointPen);
128 painter->drawPoints(m_upper->points());
128 painter->drawPoints(m_upper->geometryPoints());
129 if (m_lower)
129 if (m_lower)
130 painter->drawPoints(m_lower->points());
130 painter->drawPoints(m_lower->geometryPoints());
131 }
131 }
132 painter->restore();
132 painter->restore();
133 }
133 }
Show file before | Show file after | Hide comments
@@ -78,8 +78,8 public:
78 AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries) : LineChartItem(lineSeries, 0), m_item(item) {}
78 AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries) : LineChartItem(lineSeries, 0), m_item(item) {}
79 ~AreaBoundItem() {}
79 ~AreaBoundItem() {}
80
80
81 void setLayout(QVector<QPointF> &points) {
81 void updateGeometry() {
82 LineChartItem::setLayout(points);
82 LineChartItem::updateGeometry();
83 m_item->updatePath();
83 m_item->updatePath();
84 }
84 }
85
85
Show file before | Show file after | Hide comments
@@ -284,8 +284,12 Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
284
284
285 AreaChartItem* area = new AreaChartItem(q,presenter);
285 AreaChartItem* area = new AreaChartItem(q,presenter);
286 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
286 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
287 presenter->animator()->addAnimation(area->upperLineItem());
287 area->upperLineItem()->setAnimator(presenter->animator());
288 if(q->lowerSeries()) presenter->animator()->addAnimation(area->lowerLineItem());
288 area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
289 if(q->lowerSeries()) {
290 area->lowerLineItem()->setAnimator(presenter->animator());
291 area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
292 }
289 }
293 }
290 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
294 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
291 return area;
295 return area;
Show file before | Show file after | Hide comments
@@ -20,14 +20,14
20
20
21 #include "chart_p.h"
21 #include "chart_p.h"
22 #include "chartpresenter_p.h"
22 #include "chartpresenter_p.h"
23 #include <QDebug>
23 #include "domain_p.h"
24
24
25 QTCOMMERCIALCHART_BEGIN_NAMESPACE
25 QTCOMMERCIALCHART_BEGIN_NAMESPACE
26
26
27
28 Chart::Chart(ChartPresenter *presenter):QObject(presenter),
27 Chart::Chart(ChartPresenter *presenter):QObject(presenter),
29 m_animator(0),
28 m_animator(0),
30 m_presenter(presenter)
29 m_presenter(presenter),
30 m_domain(0)
31 {
31 {
32 }
32 }
33
33
@@ -41,11 +41,27 ChartAnimator* Chart::animator() const
41 return m_animator;
41 return m_animator;
42 }
42 }
43
43
44
45 void Chart::setPresenter(ChartPresenter *presenter)
46 {
47 m_presenter=presenter;
48 }
49
44 ChartPresenter* Chart::presenter() const
50 ChartPresenter* Chart::presenter() const
45 {
51 {
46 return m_presenter;
52 return m_presenter;
47 }
53 }
48
54
55 void Chart::setDomain(Domain *domain)
56 {
57 m_domain=domain;
58 }
59
60 Domain* Chart::domain() const
61 {
62 return m_domain;
63 }
64
49 void Chart::handleGeometryChanged(const QRectF& rect)
65 void Chart::handleGeometryChanged(const QRectF& rect)
50 {
66 {
51 Q_UNUSED(rect);
67 Q_UNUSED(rect);
@@ -61,22 +77,6 void Chart::handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY)
61 qWarning()<<"Slot not implemented";
77 qWarning()<<"Slot not implemented";
62 }
78 }
63
79
64 void Chart::rangeXChanged(qreal min, qreal max, int tickXCount)
65 {
66 Q_UNUSED(min);
67 Q_UNUSED(max);
68 Q_UNUSED(tickXCount);
69 qWarning()<<"Slot not implemented";
70 }
71
72 void Chart::rangeYChanged(qreal min, qreal max, int tickYCount)
73 {
74 Q_UNUSED(min);
75 Q_UNUSED(max);
76 Q_UNUSED(tickYCount);
77 qWarning()<<"Slot not implemented";
78 }
79
80 #include "moc_chart_p.cpp"
80 #include "moc_chart_p.cpp"
81
81
82 QTCOMMERCIALCHART_END_NAMESPACE
82 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -29,6 +29,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29
29
30 class ChartAnimator;
30 class ChartAnimator;
31 class ChartPresenter;
31 class ChartPresenter;
32 class ChartAnimation;
33 class Domain;
32
34
33 class Chart: public QObject
35 class Chart: public QObject
34 {
36 {
@@ -39,16 +41,19 public:
39 public Q_SLOTS:
41 public Q_SLOTS:
40 virtual void handleGeometryChanged(const QRectF& rect);
42 virtual void handleGeometryChanged(const QRectF& rect);
41 virtual void handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY);
43 virtual void handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY);
42 virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
43 virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
44
44
45 void setAnimator(ChartAnimator* animator);
45 void setAnimator(ChartAnimator* animator);
46 ChartAnimator* animator() const;
46 ChartAnimator* animator() const;
47 void setPresenter(ChartPresenter *presenter);
47 ChartPresenter* presenter() const;
48 ChartPresenter* presenter() const;
49 void setDomain(Domain *domain);
50 Domain* domain() const;
51 virtual ChartAnimation* animation() const { return 0; };
48
52
49 private:
53 private:
50 ChartAnimator* m_animator;
54 ChartAnimator* m_animator;
51 ChartPresenter* m_presenter;
55 ChartPresenter* m_presenter;
56 Domain* m_domain;
52 };
57 };
53
58
54 QTCOMMERCIALCHART_END_NAMESPACE
59 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -134,7 +134,7 void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
134
134
135 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
135 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
136 //initialize
136 //initialize
137 item->handleGeometryChanged(m_chartRect);
137 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
138 m_axisItems.insert(axis, item);
138 m_axisItems.insert(axis, item);
139 }
139 }
140
140
@@ -384,7 +384,7 void ChartPresenter::updateLayout()
384
384
385 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
385 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
386
386
387 if(m_chartRect!=chartRect){
387 if(m_chartRect!=chartRect && chartRect.isValid()){
388 m_chartRect=chartRect;
388 m_chartRect=chartRect;
389 emit geometryChanged(m_chartRect);
389 emit geometryChanged(m_chartRect);
390 }
390 }
Show file before | Show file after | Hide comments
@@ -48,17 +48,16 QPainterPath LineChartItem::shape() const
48 return m_path;
48 return m_path;
49 }
49 }
50
50
51 void LineChartItem::setLayout(QVector<QPointF>& points)
51 void LineChartItem::updateGeometry()
52 {
52 {
53 const QVector<QPointF>& points = geometryPoints();
54
53 if(points.size()==0)
55 if(points.size()==0)
54 {
56 {
55 m_path = QPainterPath();
57 m_path = QPainterPath();
56 XYChartItem::setLayout(points);
57 return;
58 return;
58 }
59 }
59
60
60 QList<QGraphicsItem*> items = m_items.childItems();
61
62 QPainterPath linePath(points.at(0));
61 QPainterPath linePath(points.at(0));
63
62
64 for(int i=1; i< points.size();i++) {
63 for(int i=1; i< points.size();i++) {
@@ -68,9 +67,6 void LineChartItem::setLayout(QVector<QPointF>& points)
68 prepareGeometryChange();
67 prepareGeometryChange();
69 m_path = linePath;
68 m_path = linePath;
70 m_rect = linePath.boundingRect();
69 m_rect = linePath.boundingRect();
71
72 XYChartItem::setLayout(points);
73
74 }
70 }
75
71
76 void LineChartItem::handleUpdated()
72 void LineChartItem::handleUpdated()
@@ -95,7 +91,7 void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
95 painter->drawPath(m_path);
91 painter->drawPath(m_path);
96 if(m_pointsVisible){
92 if(m_pointsVisible){
97 painter->setPen(m_pointPen);
93 painter->setPen(m_pointPen);
98 painter->drawPoints(points());
94 painter->drawPoints(geometryPoints());
99 }
95 }
100 painter->restore();
96 painter->restore();
101 }
97 }
Show file before | Show file after | Hide comments
@@ -44,13 +44,11 public:
44
44
45 public Q_SLOTS:
45 public Q_SLOTS:
46 void handleUpdated();
46 void handleUpdated();
47
48 protected:
47 protected:
49 void setLayout(QVector<QPointF>& points);
48 void updateGeometry();
50
49
51 private:
50 private:
52 QLineSeries* m_series;
51 QLineSeries* m_series;
53 QGraphicsItemGroup m_items;
54 QPainterPath m_path;
52 QPainterPath m_path;
55 QRectF m_rect;
53 QRectF m_rect;
56 QPen m_linePen;
54 QPen m_linePen;
Show file before | Show file after | Hide comments
@@ -111,7 +111,8 Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
111 Q_Q(QLineSeries);
111 Q_Q(QLineSeries);
112 LineChartItem* line = new LineChartItem(q,presenter);
112 LineChartItem* line = new LineChartItem(q,presenter);
113 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
113 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
114 presenter->animator()->addAnimation(line);
114 line->setAnimator(presenter->animator());
115 line->setAnimation(new XYAnimation(line));
115 }
116 }
116 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
117 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
117 return line;
118 return line;
Show file before | Show file after | Hide comments
@@ -140,7 +140,8 Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
140 Q_Q(QScatterSeries);
140 Q_Q(QScatterSeries);
141 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
141 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
142 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
142 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
143 presenter->animator()->addAnimation(scatter);
143 scatter->setAnimator(presenter->animator());
144 scatter->setAnimation(new XYAnimation(scatter));
144 }
145 }
145 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
146 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
146 return scatter;
147 return scatter;
Show file before | Show file after | Hide comments
@@ -101,12 +101,14 void ScatterChartItem::markerSelected(Marker *marker)
101 emit XYChartItem::clicked(marker->point());
101 emit XYChartItem::clicked(marker->point());
102 }
102 }
103
103
104 void ScatterChartItem::setLayout(QVector<QPointF>& points)
104 void ScatterChartItem::updateGeometry()
105 {
105 {
106
107 const QVector<QPointF>& points = geometryPoints();
108
106 if(points.size()==0)
109 if(points.size()==0)
107 {
110 {
108 deletePoints(m_items.childItems().count());
111 deletePoints(m_items.childItems().count());
109 XYChartItem::setLayout(points);
110 return;
112 return;
111 }
113 }
112
114
@@ -139,7 +141,6 void ScatterChartItem::setLayout(QVector<QPointF>& points)
139
141
140 prepareGeometryChange();
142 prepareGeometryChange();
141 m_rect = clipRect();
143 m_rect = clipRect();
142 XYChartItem::setLayout(points);
143 }
144 }
144
145
145
146
Show file before | Show file after | Hide comments
@@ -55,7 +55,7 private:
55 void deletePoints(int count);
55 void deletePoints(int count);
56
56
57 protected:
57 protected:
58 void setLayout(QVector<QPointF> &points);
58 void updateGeometry();
59
59
60 private:
60 private:
61 QScatterSeries *m_series;
61 QScatterSeries *m_series;
Show file before | Show file after | Hide comments
@@ -254,8 +254,10 Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
254 Q_Q(QSplineSeries);
254 Q_Q(QSplineSeries);
255 SplineChartItem* spline = new SplineChartItem(q,presenter);
255 SplineChartItem* spline = new SplineChartItem(q,presenter);
256 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
256 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
257 presenter->animator()->addAnimation(spline);
257 spline->setAnimator(presenter->animator());
258 spline->setAnimation(new SplineAnimation(spline));
258 }
259 }
260
259 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
261 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
260 return spline;
262 return spline;
261 }
263 }
Show file before | Show file after | Hide comments
@@ -30,7 +30,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
30 SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
30 SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
31 XYChartItem(series, presenter),
31 XYChartItem(series, presenter),
32 m_series(series),
32 m_series(series),
33 m_pointsVisible(false)
33 m_pointsVisible(false),
34 m_animation(0)
34 {
35 {
35 setZValue(ChartPresenter::LineChartZValue);
36 setZValue(ChartPresenter::LineChartZValue);
36 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
37 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
@@ -47,11 +48,27 QPainterPath SplineChartItem::shape() const
47 return m_path;
48 return m_path;
48 }
49 }
49
50
50 void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
51 void SplineChartItem::setAnimation(SplineAnimation* animation)
52 {
53 m_animation=animation;
54 XYChartItem::setAnimation(animation);
55 }
56
57 void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
58 {
59 m_controlPoints=points;
60 }
61
62 QVector<QPointF> SplineChartItem::controlGeometryPoints() const
63 {
64 return m_controlPoints;
65 }
66
67 void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
51 {
68 {
52 QVector<QPointF> controlPoints;
69 QVector<QPointF> controlPoints;
53
70
54 if(newPoints.count()>=2){
71 if(newPoints.count()>=2) {
55 controlPoints.resize(newPoints.count()*2-2);
72 controlPoints.resize(newPoints.count()*2-2);
56 }
73 }
57
74
@@ -61,38 +78,35 void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF>
61 }
78 }
62
79
63 if (controlPoints.count()<2) {
80 if (controlPoints.count()<2) {
64 setLayout(newPoints,controlPoints);
81 setGeometryPoints(newPoints);
82 setControlGeometryPoints(controlPoints);
83 updateGeometry();
65 return;
84 return;
66 }
85 }
67
86
68 if (animator()) {
87 if (m_animation) {
69 animator()->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
88 m_animation->setValues(oldPoints,newPoints,m_controlPoints,controlPoints,index);
70 } else {
89 animator()->startAnimation(m_animation);
71 setLayout(newPoints,controlPoints);
90 }
91 else {
92 setGeometryPoints(newPoints);
93 setControlGeometryPoints(controlPoints);
94 updateGeometry();
72 }
95 }
73 }
96 }
74
97
75 QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
98 QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
76 {
99 {
77 // return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
78 return XYChartItem::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
100 return XYChartItem::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
79 }
101 }
80
102
81 void SplineChartItem::setLayout(QVector<QPointF> &points)
103 void SplineChartItem::updateGeometry()
82 {
104 {
83 // Dummy implementation because of a bug in Clang compiler
105 const QVector<QPointF> &points = geometryPoints();
84 if (points.size() < 2) {
106 const QVector<QPointF> &controlPoints = controlGeometryPoints();
85 m_path = QPainterPath();
86 }
87 XYChartItem::setLayout(points);
88 }
89
107
90 void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &controlPoints)
91 {
92 if ((points.size()<2) || (controlPoints.size()<2)) {
108 if ((points.size()<2) || (controlPoints.size()<2)) {
93 m_path = QPainterPath();
109 m_path = QPainterPath();
94 XYChartItem::setLayout(points);
95 m_controlPoints=controlPoints;
96 return;
110 return;
97 }
111 }
98
112
@@ -108,9 +122,6 void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &cont
108 prepareGeometryChange();
122 prepareGeometryChange();
109 m_path = splinePath;
123 m_path = splinePath;
110 m_rect = splinePath.boundingRect();
124 m_rect = splinePath.boundingRect();
111 XYChartItem::setLayout(points);
112 m_controlPoints=controlPoints;
113
114 }
125 }
115
126
116 //handlers
127 //handlers
@@ -130,14 +141,13 void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *o
130 {
141 {
131 Q_UNUSED(widget)
142 Q_UNUSED(widget)
132 Q_UNUSED(option)
143 Q_UNUSED(option)
133 qDebug()<<__FUNCTION__;
134 painter->save();
144 painter->save();
135 painter->setClipRect(clipRect());
145 painter->setClipRect(clipRect());
136 painter->setPen(m_linePen);
146 painter->setPen(m_linePen);
137 painter->drawPath(m_path);
147 painter->drawPath(m_path);
138 if (m_pointsVisible) {
148 if (m_pointsVisible) {
139 painter->setPen(m_pointPen);
149 painter->setPen(m_pointPen);
140 painter->drawPoints(points());
150 painter->drawPoints(geometryPoints());
141 }
151 }
142 painter->restore();
152 painter->restore();
143 }
153 }
Show file before | Show file after | Hide comments
@@ -23,6 +23,7
23
23
24 #include "qsplineseries.h"
24 #include "qsplineseries.h"
25 #include "xychartitem_p.h"
25 #include "xychartitem_p.h"
26 #include "splineanimation_p.h"
26
27
27 QTCOMMERCIALCHART_BEGIN_NAMESPACE
28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
28
29
@@ -37,13 +38,18 public:
37 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
38 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
38 QPainterPath shape() const;
39 QPainterPath shape() const;
39
40
41 void setControlGeometryPoints(QVector<QPointF>& points);
42 QVector<QPointF> controlGeometryPoints() const;
43
44 void setAnimation(SplineAnimation* animation);
45 ChartAnimation* animation() const { return m_animation; }
46
40 public Q_SLOTS:
47 public Q_SLOTS:
41 void handleUpdated();
48 void handleUpdated();
42
49
43 protected:
50 protected:
44 void setLayout(QVector<QPointF> &points);
51 void updateGeometry();
45 void setLayout(QVector<QPointF> &points,QVector<QPointF> &controlPoints);
52 void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index);
46 void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index);
47
53
48 private:
54 private:
49 QPointF calculateGeometryControlPoint(int index) const;
55 QPointF calculateGeometryControlPoint(int index) const;
@@ -56,6 +62,7 private:
56 QPen m_pointPen;
62 QPen m_pointPen;
57 bool m_pointsVisible;
63 bool m_pointsVisible;
58 QVector<QPointF> m_controlPoints;
64 QVector<QPointF> m_controlPoints;
65 SplineAnimation* m_animation;
59
66
60 friend class SplineAnimation;
67 friend class SplineAnimation;
61 };
68 };
Show file before | Show file after | Hide comments
@@ -407,6 +407,7 void QXYSeriesPrivate::scaleDomain(Domain& domain)
407
407
408 const QList<QPointF>& points = q->points();
408 const QList<QPointF>& points = q->points();
409
409
410
410 if(points.isEmpty()){
411 if(points.isEmpty()){
411 minX=0.0;
412 minX=0.0;
412 minY=0.0;
413 minY=0.0;
@@ -425,18 +426,6 void QXYSeriesPrivate::scaleDomain(Domain& domain)
425 }
426 }
426
427
427 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
428 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
428
429 if (!points.isEmpty()) {
430 for (int i = 0; i < points.count(); i++) {
431 qreal x = points[i].x();
432 qreal y = points[i].y();
433 minX = qMin(minX, x);
434 minY = qMin(minY, y);
435 maxX = qMax(maxX, x);
436 maxY = qMax(maxY, y);
437 }
438 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
439 }
440 }
429 }
441
430
442 QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
431 QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
Show file before | Show file after | Hide comments
@@ -1,22 +1,22
1 /****************************************************************************
1 /****************************************************************************
2 **
2 **
3 ** Copyright (C) 2012 Digia Plc
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
8 **
9 ** $QT_BEGIN_LICENSE$
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
13 ** a written agreement between you and Digia.
14 **
14 **
15 ** If you have questions regarding the use of this file, please use
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
17 ** $QT_END_LICENSE$
18 **
18 **
19 ****************************************************************************/
19 ****************************************************************************/
20
20
21 #include "xychartitem_p.h"
21 #include "xychartitem_p.h"
22 #include "qxyseries.h"
22 #include "qxyseries.h"
@@ -27,26 +27,42
27 #include <QGraphicsSceneMouseEvent>
27 #include <QGraphicsSceneMouseEvent>
28 #include <QAbstractItemModel>
28 #include <QAbstractItemModel>
29 #include "qxymodelmapper.h"
29 #include "qxymodelmapper.h"
30
30 #include <QDebug>
31
31
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
33
34 //TODO: optimize : remove points which are not visible
34 //TODO: optimize : remove points which are not visible
35
35
36 XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
36 XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
37 m_minX(0),
37 m_minX(0),
38 m_maxX(0),
38 m_maxX(0),
39 m_minY(0),
39 m_minY(0),
40 m_maxY(0),
40 m_maxY(0),
41 m_series(series)
41 m_series(series),
42 m_animation(0)
43 {
44 QObject::connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
45 QObject::connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
46 QObject::connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
47 QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
48 QObject::connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
49 QObject::connect(series->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
50 QObject::connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
51 }
52
53 void XYChartItem::setGeometryPoints(QVector<QPointF>& points)
54 {
55 m_points = points;
56 }
57
58 void XYChartItem::setClipRect(const QRectF &rect)
59 {
60 m_clipRect = rect;
61 }
62
63 void XYChartItem::setAnimation(XYAnimation* animation)
42 {
64 {
43 connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
65 m_animation=animation;
44 connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
45 connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
46 connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
47 connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
48 connect(series->d_func(),SIGNAL(reinitialized()),this,SLOT(handleReinitialized()));
49 connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
50 }
66 }
51
67
52 QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
68 QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
@@ -58,7 +74,6 QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
58 return QPointF(x,y);
74 return QPointF(x,y);
59 }
75 }
60
76
61
62 QPointF XYChartItem::calculateGeometryPoint(int index) const
77 QPointF XYChartItem::calculateGeometryPoint(int index) const
63 {
78 {
64 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
79 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
@@ -95,21 +110,22 QPointF XYChartItem::calculateDomainPoint(const QPointF &point) const
95 return QPointF(x,y);
110 return QPointF(x,y);
96 }
111 }
97
112
98 void XYChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
113 void XYChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
99 {
114 {
100 if (animator()) {
115 if (m_animation) {
101 animator()->updateLayout(this,oldPoints,newPoints,index);
116 m_animation->setValues(oldPoints, newPoints, index);
102 } else {
117 animator()->startAnimation(m_animation);
103 setLayout(newPoints);
118 }
119 else {
120 setGeometryPoints(newPoints);
121 updateGeometry();
104 }
122 }
105 }
123 }
106
124
107 void XYChartItem::setLayout(QVector<QPointF> &points)
125 void XYChartItem::updateGeometry()
108 {
126 {
109 m_points = points;
110 update();
127 update();
111 }
128 }
112
113 //handlers
129 //handlers
114
130
115 void XYChartItem::handlePointAdded(int index)
131 void XYChartItem::handlePointAdded(int index)
@@ -118,38 +134,45 void XYChartItem::handlePointAdded(int index)
118 Q_ASSERT(index<m_series->count());
134 Q_ASSERT(index<m_series->count());
119 Q_ASSERT(index>=0);
135 Q_ASSERT(index>=0);
120 }
136 }
137
121 QVector<QPointF> points = m_points;
138 QVector<QPointF> points = m_points;
122 QPointF point;
139 QPointF point;
123 point = calculateGeometryPoint(index);
140 point = calculateGeometryPoint(index);
124 points.insert(index, point);
141 points.insert(index, point);
125 updateLayout(m_points, points, index);
142
126 update();
143 if(m_animation) {
144 m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
145 }
146
147 updateChart(m_points,points,index);
127 }
148 }
128
149
129 void XYChartItem::handlePointsAdded(int start, int end)
150 void XYChartItem::handlePointsAdded(int start, int end)
130 {
151 {
131 if (m_series->model() == 0) {
152 if (m_series->model() == 0) {
132 for (int i = start; i <= end; i++)
153 for (int i = start; i <= end; i++)
133 handlePointAdded(i);
154 handlePointAdded(i);
134 } else {
155 }
156 else {
135 int mapFirst = m_series->modelMapper()->first();
157 int mapFirst = m_series->modelMapper()->first();
136 int mapCount = m_series->modelMapper()->count();
158 int mapCount = m_series->modelMapper()->count();
137 if (mapCount != -1 && start >= mapFirst + mapCount) {
159 if (mapCount != -1 && start >= mapFirst + mapCount) {
138 return;
160 return;
139 } else {
161 }
162 else {
140 int addedCount = end - start + 1;
163 int addedCount = end - start + 1;
141 if (mapCount != -1 && addedCount > mapCount)
164 if (mapCount != -1 && addedCount > mapCount)
142 addedCount = mapCount;
165 addedCount = mapCount;
143 int first = qMax(start, mapFirst); // get the index of the first item that will be added
166 int first = qMax(start, mapFirst); // get the index of the first item that will be added
144 int last = qMin(first + addedCount - 1, mapCount + mapFirst - 1); // get the index of the last item that will be added
167 int last = qMin(first + addedCount - 1, mapCount + mapFirst - 1);// get the index of the last item that will be added
145 for (int i = first; i <= last; i++) {
168 for (int i = first; i <= last; i++) {
146 handlePointAdded(i - mapFirst);
169 handlePointAdded(i - mapFirst);
147 }
170 }
148 // the map is limited therefore the items that are now outside the map
171 // the map is limited therefore the items that are now outside the map
149 // need to be removed from the drawn points
172 // need to be removed from the drawn points
150 if (mapCount != -1 && m_points.size() > mapCount)
173 if (mapCount != -1 && m_points.size() > mapCount)
151 for (int i = m_points.size() - 1; i >= mapCount; i--)
174 for (int i = m_points.size() - 1; i >= mapCount; i--)
152 handlePointRemoved(i);
175 handlePointRemoved(i);
153 }
176 }
154 }
177 }
155 }
178 }
@@ -162,8 +185,12 void XYChartItem::handlePointRemoved(int index)
162 }
185 }
163 QVector<QPointF> points = m_points;
186 QVector<QPointF> points = m_points;
164 points.remove(index);
187 points.remove(index);
165 updateLayout(m_points, points, index);
188
166 update();
189 if(m_animation) {
190 m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
191 }
192
193 updateChart(m_points,points,index);
167 }
194 }
168
195
169 void XYChartItem::handlePointsRemoved(int start, int end)
196 void XYChartItem::handlePointsRemoved(int start, int end)
@@ -172,42 +199,45 void XYChartItem::handlePointsRemoved(int start, int end)
172 Q_UNUSED(end)
199 Q_UNUSED(end)
173 if (m_series->model() == 0) {
200 if (m_series->model() == 0) {
174 for (int i = end; i >= start; i--)
201 for (int i = end; i >= start; i--)
175 handlePointRemoved(i);
202 handlePointRemoved(i);
176 } else {
203 }
204 else {
177 // series uses model as a data source
205 // series uses model as a data source
178 int mapFirst = m_series->modelMapper()->first();
206 int mapFirst = m_series->modelMapper()->first();
179 int mapCount = m_series->modelMapper()->count();
207 int mapCount = m_series->modelMapper()->count();
180 int removedCount = end - start + 1;
208 int removedCount = end - start + 1;
181 if (mapCount != -1 && start >= mapFirst + mapCount) {
209 if (mapCount != -1 && start >= mapFirst + mapCount) {
182 return;
210 return;
183 } else {
211 }
184 int toRemove = qMin(m_points.size(), removedCount); // first find how many items can actually be removed
212 else {
185 int first = qMax(start, mapFirst); // get the index of the first item that will be removed.
213 int toRemove = qMin(m_points.size(), removedCount); // first find how many items can actually be removed
186 int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1); // get the index of the last item that will be removed.
214 int first = qMax(start, mapFirst);// get the index of the first item that will be removed.
215 int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1);// get the index of the last item that will be removed.
187 if (last - first == 0) {
216 if (last - first == 0) {
188 for (int i = last; i >= first; i--) {
217 for (int i = last; i >= first; i--) {
189 handlePointRemoved(i - mapFirst);
218 handlePointRemoved(i - mapFirst);
190
219
191 }
220 }
192 } else {
221 }
222 else {
193 QVector<QPointF> points = m_points;
223 QVector<QPointF> points = m_points;
194 for (int i = last; i >= first; i--)
224 for (int i = last; i >= first; i--)
195 points.remove(i - mapFirst);
225 points.remove(i - mapFirst);
196 setLayout(points);
226 setGeometryPoints(points);
197 update();
227 updateGeometry();
198 }
228 }
199 if (mapCount != -1) {
229 if (mapCount != -1) {
200 int itemsAvailable; // check how many are available to be added
230 int itemsAvailable; // check how many are available to be added
201 if (m_series->modelMapper()->orientation() == Qt::Vertical)
231 if (m_series->modelMapper()->orientation() == Qt::Vertical)
202 itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
232 itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
203 else
233 else
204 itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
234 itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
205 int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size()); // add not more items than there is space left to be filled.
235 int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size());// add not more items than there is space left to be filled.
206 int currentSize = m_points.size();
236 int currentSize = m_points.size();
207 if (toBeAdded > 0)
237 if (toBeAdded > 0)
208 for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
238 for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
209 handlePointAdded(i);
239 handlePointAdded(i);
210 }
240 }
211 }
241 }
212 }
242 }
213 }
243 }
@@ -221,18 +251,23 void XYChartItem::handlePointReplaced(int index)
221 QPointF point = calculateGeometryPoint(index);
251 QPointF point = calculateGeometryPoint(index);
222 QVector<QPointF> points = m_points;
252 QVector<QPointF> points = m_points;
223 points.replace(index,point);
253 points.replace(index,point);
224 updateLayout(m_points,points,index);
254
225 update();
255 if(m_animation) {
256 m_animation->setAnimationType(XYAnimation::MoveDownAnimation);
257 }
258
259 updateChart(m_points,points,index);
226 }
260 }
227
261
228 void XYChartItem::handleReinitialized()
262 void XYChartItem::handleReinitialized()
229 {
263 {
230 QVector<QPointF> points = calculateGeometryPoints();
264 QVector<QPointF> points = calculateGeometryPoints();
231 if (points.isEmpty())
265
232 setLayout(points);
266 if(m_animation) {
233 else
267 m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
234 updateLayout(m_points,points);
268 }
235 update();
269
270 updateChart(m_points,points);
236 }
271 }
237
272
238 void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
273 void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
@@ -243,8 +278,11 void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal
243 m_maxY=maxY;
278 m_maxY=maxY;
244 if (isEmpty()) return;
279 if (isEmpty()) return;
245 QVector<QPointF> points = calculateGeometryPoints();
280 QVector<QPointF> points = calculateGeometryPoints();
246 updateLayout(m_points,points);
281
247 update();
282 if(m_animation) {
283 m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
284 }
285 updateChart(m_points,points);
248 }
286 }
249
287
250 void XYChartItem::handleGeometryChanged(const QRectF &rect)
288 void XYChartItem::handleGeometryChanged(const QRectF &rect)
@@ -256,11 +294,12 void XYChartItem::handleGeometryChanged(const QRectF &rect)
256
294
257 if (isEmpty()) return;
295 if (isEmpty()) return;
258 QVector<QPointF> points = calculateGeometryPoints();
296 QVector<QPointF> points = calculateGeometryPoints();
259 updateLayout(m_points,points);
297 if(m_animation) {
260 update();
298 m_animation->setAnimationType(XYAnimation::LineDrawAnimation);
299 }
300 updateChart(m_points,points);
261 }
301 }
262
302
263
264 bool XYChartItem::isEmpty()
303 bool XYChartItem::isEmpty()
265 {
304 {
266 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
305 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
Show file before | Show file after | Hide comments
@@ -23,6 +23,7
23
23
24 #include "qchartglobal.h"
24 #include "qchartglobal.h"
25 #include "chartitem_p.h"
25 #include "chartitem_p.h"
26 #include "xyanimation_p.h"
26 #include <QPen>
27 #include <QPen>
27
28
28 QTCOMMERCIALCHART_BEGIN_NAMESPACE
29 QTCOMMERCIALCHART_BEGIN_NAMESPACE
@@ -37,9 +38,15 public:
37 explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
38 explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
38 ~XYChartItem(){};
39 ~XYChartItem(){};
39
40
40 QVector<QPointF> points() const {return m_points;}
41 void setGeometryPoints(QVector<QPointF>& points);
41 QRectF clipRect() const { return m_clipRect;}
42 QVector<QPointF> geometryPoints() const { return m_points; }
42
43
44 void setClipRect(const QRectF &rect);
45 QRectF clipRect() const { return m_clipRect; }
46
47 void setAnimation(XYAnimation* animation);
48 ChartAnimation* animation() const { return m_animation; }
49 virtual void updateGeometry();
43
50
44 public Q_SLOTS:
51 public Q_SLOTS:
45 void handlePointAdded(int index);
52 void handlePointAdded(int index);
@@ -55,10 +62,7 Q_SIGNALS:
55 void clicked(const QPointF& point);
62 void clicked(const QPointF& point);
56
63
57 protected:
64 protected:
58
65 virtual void updateChart(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
59 virtual void setLayout(QVector<QPointF> &points);
60 virtual void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
61
62 QPointF calculateGeometryPoint(const QPointF &point) const;
66 QPointF calculateGeometryPoint(const QPointF &point) const;
63 QPointF calculateGeometryPoint(int index) const;
67 QPointF calculateGeometryPoint(int index) const;
64 QPointF calculateDomainPoint(const QPointF &point) const;
68 QPointF calculateDomainPoint(const QPointF &point) const;
@@ -77,8 +81,8 private:
77 QSizeF m_size;
81 QSizeF m_size;
78 QRectF m_clipRect;
82 QRectF m_clipRect;
79 QVector<QPointF> m_points;
83 QVector<QPointF> m_points;
84 XYAnimation* m_animation;
80
85
81 friend class XYAnimation;
82 friend class AreaChartItem;
86 friend class AreaChartItem;
83
87
84 };
88 };
General Comments 0
You need to be logged in to leave comments. Login now