@@ -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 |
@@ -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 |
@@ -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; |
@@ -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): |
|
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->set |
|
143 | m_item->setGeometryPoints(pair.first); | |
|
144 | m_item->setControlGeometryPoints(pair.second); | |||
|
145 | m_item->updateGeometry(); | |||
146 | } |
|
146 | } | |
147 | } |
|
147 | } | |
148 |
|
148 |
@@ -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 " |
|
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 |
|
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); |
@@ -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->set |
|
112 | m_item->setGeometryPoints(vector); | |
|
113 | m_item->updateGeometry(); | |||
107 | } |
|
114 | } | |
108 | } |
|
115 | } | |
109 |
|
116 |
@@ -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 |
@@ -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-> |
|
128 | painter->drawPoints(m_upper->geometryPoints()); | |
129 | if (m_lower) |
|
129 | if (m_lower) | |
130 |
painter->drawPoints(m_lower-> |
|
130 | painter->drawPoints(m_lower->geometryPoints()); | |
131 | } |
|
131 | } | |
132 | painter->restore(); |
|
132 | painter->restore(); | |
133 | } |
|
133 | } |
@@ -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:: |
|
82 | LineChartItem::updateGeometry(); | |
83 | m_item->updatePath(); |
|
83 | m_item->updatePath(); | |
84 | } |
|
84 | } | |
85 |
|
85 |
@@ -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 |
|
|
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; |
@@ -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 |
@@ -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 |
@@ -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 | } |
@@ -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( |
|
94 | painter->drawPoints(geometryPoints()); | |
99 | } |
|
95 | } | |
100 | painter->restore(); |
|
96 | painter->restore(); | |
101 | } |
|
97 | } |
@@ -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; |
@@ -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() |
|
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; |
@@ -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; |
@@ -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 |
@@ -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; |
@@ -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() |
|
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 | } |
@@ -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 |
set |
|
81 | setGeometryPoints(newPoints); | |
|
82 | setControlGeometryPoints(controlPoints); | |||
|
83 | updateGeometry(); | |||
65 | return; |
|
84 | return; | |
66 | } |
|
85 | } | |
67 |
|
86 | |||
68 |
if (animat |
|
87 | if (m_animation) { | |
69 |
animat |
|
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( |
|
150 | painter->drawPoints(geometryPoints()); | |
141 | } |
|
151 | } | |
142 | painter->restore(); |
|
152 | painter->restore(); | |
143 | } |
|
153 | } |
@@ -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 |
|
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 | }; |
@@ -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) |
@@ -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 |
|
|
37 | m_minX(0), | |
38 |
|
|
38 | m_maxX(0), | |
39 |
|
|
39 | m_minY(0), | |
40 |
|
|
40 | m_maxY(0), | |
41 |
|
|
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::update |
|
113 | void XYChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index) | |
99 | { |
|
114 | { | |
100 |
if (animat |
|
115 | if (m_animation) { | |
101 |
animat |
|
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 |
|
|
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 |
} |
|
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 |
|
|
165 | addedCount = mapCount; | |
143 |
int first = qMax(start, mapFirst); |
|
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); |
|
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 |
|
|
174 | for (int i = m_points.size() - 1; i >= mapCount; i--) | |
152 |
|
|
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 |
|
|
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 |
} |
|
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 |
|
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 |
} |
|
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 |
|
|
225 | points.remove(i - mapFirst); | |
196 |
set |
|
226 | setGeometryPoints(points); | |
197 | update(); |
|
227 | updateGeometry(); | |
198 | } |
|
228 | } | |
199 | if (mapCount != -1) { |
|
229 | if (mapCount != -1) { | |
200 |
int itemsAvailable; |
|
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 |
|
|
232 | itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size(); | |
203 | else |
|
233 | else | |
204 |
|
|
234 | itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size(); | |
205 |
int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size()); |
|
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 |
|
|
238 | for (int i = m_points.size(); i < currentSize + toBeAdded; i++) { | |
209 |
|
|
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(); |
@@ -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 |
Q |
|
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