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

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

Rewrite animation hadnling in line series...
Michal Klocek -
r389:7b90ec69ce9a
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,44 +1,44
1 1 #ifndef AXISANIMATIONITEM_H_
2 2 #define AXISANIMATIONITEM_H_
3 3
4 4 #include "domain_p.h"
5 5 #include "axisitem_p.h"
6 6 #include <QGraphicsItem>
7 7 #include <QVariantAnimation>
8 8
9 9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10 10
11 11 class QChartAxis;
12 12
13 13 class AxisAnimationItem : public AxisItem
14 14 {
15 15 Q_OBJECT
16 16
17 17 public:
18 18 AxisAnimationItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
19 19 ~AxisAnimationItem();
20 20
21 21 void setLabelsAngle(int angle);
22 22
23 23 protected:
24 24 void updateItems(QVector<qreal>& vector);
25 25
26 26 };
27 27
28 28 class AxisAnimator: public QVariantAnimation
29 29 {
30 30 public:
31 31 AxisAnimator(AxisItem *axis,QObject *parent = 0);
32 virtual ~AxisAnimator();
32 ~AxisAnimator();
33 33 protected:
34 34 virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
35 35 virtual void updateCurrentValue (const QVariant & value );
36 36 private:
37 37 AxisItem* m_axis;
38 38 };
39 39
40 40 QTCOMMERCIALCHART_END_NAMESPACE
41 41
42 42
43 43
44 44 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,335 +1,332
1 1 #include "axisitem_p.h"
2 2 #include "qchartaxis.h"
3 3 #include "chartpresenter_p.h"
4 4 #include <QPainter>
5 5 #include <QDebug>
6 6
7 7 static int label_padding = 5;
8 8
9 9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10 10
11 11 AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
12 12 ChartItem(parent),
13 13 m_type(type),
14 14 m_labelsAngle(0),
15 15 m_grid(parent),
16 16 m_shades(parent),
17 17 m_labels(parent),
18 18 m_axis(parent)
19 19 {
20 20 //initial initialization
21 21 m_axis.setZValue(ChartPresenter::AxisZValue);
22 22 m_shades.setZValue(ChartPresenter::ShadesZValue);
23 23 m_grid.setZValue(ChartPresenter::GridZValue);
24 24 setFlags(QGraphicsItem::ItemHasNoContents);
25 25 }
26 26
27 27 AxisItem::~AxisItem()
28 28 {
29 29 }
30 30
31 31 QRectF AxisItem::boundingRect() const
32 32 {
33 33 return QRectF();
34 34 }
35 35
36 36 void AxisItem::createItems(int count)
37 37 {
38 38 if(m_axis.children().size()==0)
39 39 m_axis.addToGroup(new QGraphicsLineItem());
40 40 for (int i = 0; i < count; ++i) {
41 41 m_grid.addToGroup(new QGraphicsLineItem());
42 42 m_labels.addToGroup(new QGraphicsSimpleTextItem());
43 43 if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
44 44 m_axis.addToGroup(new QGraphicsLineItem());
45 45 }
46 46 }
47 47
48 48 void AxisItem::clear(int count)
49 49 {
50 50 QList<QGraphicsItem *> lines = m_grid.childItems();
51 51 QList<QGraphicsItem *> labels = m_labels.childItems();
52 52 QList<QGraphicsItem *> shades = m_shades.childItems();
53 53 QList<QGraphicsItem *> axis = m_axis.childItems();
54 54
55 55 for (int i = 0; i < count; ++i) {
56 56 delete(lines.takeLast());
57 57 delete(labels.takeLast());
58 58 if(lines.size()%2) delete(shades.takeLast());
59 59 delete(axis.takeLast());
60 60 }
61
62 m_thicksList.clear();
63
64 61 }
65 62
66 63 void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
67 64 {
68 65 Q_UNUSED(painter);
69 66 Q_UNUSED(option);
70 67 Q_UNUSED(widget);
71 68 }
72 69
73 70 void AxisItem::updateItems(QVector<qreal>& vector)
74 71 {
75 72 calculateLayout(vector);
76 73 if(vector.count()==0) return;
77 74 applyLayout(vector);
78 75 }
79 76
80 77 void AxisItem::handleAxisUpdate(QChartAxis* axis)
81 78 {
82 79 if(m_layoutVector.count()==0) return;
83 80
84 81 if(axis->isAxisVisible()) {
85 82 setAxisOpacity(100);
86 83 }
87 84 else {
88 85 setAxisOpacity(0);
89 86 }
90 87
91 88 if(axis->isGridVisible()) {
92 89 setGridOpacity(100);
93 90 }
94 91 else {
95 92 setGridOpacity(0);
96 93 }
97 94
98 95 if(axis->labelsVisible())
99 96 {
100 97 setLabelsOpacity(100);
101 98 }
102 99 else {
103 100 setLabelsOpacity(0);
104 101 }
105 102
106 103 if(axis->shadesVisible()) {
107 104 setShadesOpacity(axis->shadesOpacity());
108 105 }
109 106 else {
110 107 setShadesOpacity(0);
111 108 }
112 109
113 110 setLabelsAngle(axis->labelsAngle());
114 111 setAxisPen(axis->axisPen());
115 112 setLabelsPen(axis->labelsPen());
116 113 setLabelsBrush(axis->labelsBrush());
117 114 setLabelsFont(axis->labelsFont());
118 115 setGridPen(axis->gridPen());
119 116 setShadesPen(axis->shadesPen());
120 117 setShadesBrush(axis->shadesBrush());
121 118 }
122 119
123 120 void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
124 121 {
125 122 int diff = m_thicksList.size() - labels.size();
126 123
127 124 if(diff>0){
128 125 clear(diff);
129 126 }else if(diff<0){
130 127 createItems(-diff);
131 128 }
132 129 m_thicksList=labels;
133 130 m_layoutVector.resize(m_thicksList.size());
134 131 updateItems(m_layoutVector);
135 132 if(diff!=0) handleAxisUpdate(axis);
136 133 }
137 134
138 135 void AxisItem::handleGeometryChanged(const QRectF& rect)
139 136 {
140 137 m_rect = rect;
141 138 updateItems(m_layoutVector);
142 139 }
143 140
144 141 void AxisItem::setAxisOpacity(qreal opacity)
145 142 {
146 143 m_axis.setOpacity(opacity);
147 144 }
148 145
149 146 qreal AxisItem::axisOpacity() const
150 147 {
151 148 return m_axis.opacity();
152 149 }
153 150
154 151 void AxisItem::setGridOpacity(qreal opacity)
155 152 {
156 153 m_grid.setOpacity(opacity);
157 154 }
158 155
159 156 qreal AxisItem::gridOpacity() const
160 157 {
161 158 return m_grid.opacity();
162 159 }
163 160
164 161 void AxisItem::setLabelsOpacity(qreal opacity)
165 162 {
166 163 m_labels.setOpacity(opacity);
167 164 }
168 165
169 166 qreal AxisItem::labelsOpacity() const
170 167 {
171 168 return m_labels.opacity();
172 169 }
173 170
174 171 void AxisItem::setShadesOpacity(qreal opacity)
175 172 {
176 173 m_shades.setOpacity(opacity);
177 174 }
178 175
179 176 qreal AxisItem::shadesOpacity() const
180 177 {
181 178 return m_shades.opacity();
182 179 }
183 180
184 181 void AxisItem::setLabelsAngle(int angle)
185 182 {
186 183 foreach(QGraphicsItem* item , m_labels.childItems()) {
187 184 QPointF center = item->boundingRect().center();
188 185 item->setRotation(angle);
189 186 }
190 187
191 188 m_labelsAngle=angle;
192 189 }
193 190
194 191 void AxisItem::setLabelsPen(const QPen& pen)
195 192 {
196 193 foreach(QGraphicsItem* item , m_labels.childItems()) {
197 194 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
198 195 }
199 196 }
200 197
201 198 void AxisItem::setLabelsBrush(const QBrush& brush)
202 199 {
203 200 foreach(QGraphicsItem* item , m_labels.childItems()) {
204 201 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
205 202 }
206 203 }
207 204
208 205 void AxisItem::setLabelsFont(const QFont& font)
209 206 {
210 207 foreach(QGraphicsItem* item , m_labels.childItems()) {
211 208 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
212 209 }
213 210 }
214 211
215 212 void AxisItem::setShadesBrush(const QBrush& brush)
216 213 {
217 214 foreach(QGraphicsItem* item , m_shades.childItems()) {
218 215 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
219 216 }
220 217 }
221 218
222 219 void AxisItem::setShadesPen(const QPen& pen)
223 220 {
224 221 foreach(QGraphicsItem* item , m_shades.childItems()) {
225 222 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
226 223 }
227 224 }
228 225
229 226 void AxisItem::setAxisPen(const QPen& pen)
230 227 {
231 228 foreach(QGraphicsItem* item , m_axis.childItems()) {
232 229 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
233 230 }
234 231 }
235 232
236 233 void AxisItem::setGridPen(const QPen& pen)
237 234 {
238 235 foreach(QGraphicsItem* item , m_grid.childItems()) {
239 236 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
240 237 }
241 238 }
242 239
243 240 void AxisItem::calculateLayout(QVector<qreal>& points)
244 241 {
245 242 switch (m_type)
246 243 {
247 244 case X_AXIS:
248 245 {
249 246 const qreal deltaX = m_rect.width()/(m_thicksList.size()-1);
250 247 for (int i = 0; i < m_thicksList.size(); ++i) {
251 248 int x = i * deltaX + m_rect.left();
252 249 points[i]=x;
253 250 }
254 251 }
255 252 break;
256 253 case Y_AXIS:
257 254 {
258 255 const qreal deltaY = m_rect.height()/(m_thicksList.size()-1);
259 256 for (int i = 0; i < m_thicksList.size(); ++i) {
260 257 int y = i * -deltaY + m_rect.bottom();
261 258 points[i]=y;
262 259 }
263 260 }
264 261 break;
265 262 }
266 263 }
267 264
268 265 void AxisItem::applyLayout(const QVector<qreal>& points)
269 266 {
270 267 Q_ASSERT(points.size() == m_thicksList.size());
271 268
272 269 QList<QGraphicsItem *> lines = m_grid.childItems();
273 270 QList<QGraphicsItem *> labels = m_labels.childItems();
274 271 QList<QGraphicsItem *> shades = m_shades.childItems();
275 272 QList<QGraphicsItem *> axis = m_axis.childItems();
276 273
277 274 Q_ASSERT(labels.size() == m_thicksList.size());
278 275
279 276 switch (m_type)
280 277 {
281 278 case X_AXIS:
282 279 {
283 280 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
284 281 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
285 282
286 283 for (int i = 0; i < points.size(); ++i) {
287 284 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
288 285 lineItem->setLine(points[i], m_rect.top(), points[i], m_rect.bottom());
289 286 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
290 287 labelItem->setText(m_thicksList.at(i));
291 288 QPointF center = labelItem->boundingRect().center();
292 289 labelItem->setTransformOriginPoint(center.x(), center.y());
293 290 labelItem->setPos(points[i] - center.x(), m_rect.bottom() + label_padding);
294 291 if(i%2){
295 292 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
296 293 rectItem->setRect(points[i],m_rect.top(),points[i+1]-points[i],m_rect.height());
297 294 }
298 295 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
299 296 lineItem->setLine(points[i],m_rect.bottom(),points[i],m_rect.bottom()+5);
300 297 }
301 298 }
302 299 break;
303 300
304 301 case Y_AXIS:
305 302 {
306 303 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
307 304 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
308 305
309 306 for (int i = 0; i < points.size(); ++i) {
310 307 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
311 308 lineItem->setLine(m_rect.left() , points[i], m_rect.right(), points[i]);
312 309 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
313 310 labelItem->setText(m_thicksList.at(i));
314 311 QPointF center = labelItem->boundingRect().center();
315 312 labelItem->setTransformOriginPoint(center.x(), center.y());
316 313 labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , points[i]-center.y());
317 314 if(i%2){
318 315 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
319 316 rectItem->setRect(m_rect.left(),points[i],m_rect.width(),points[i]-points[i+1]);
320 317 }
321 318 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
322 319 lineItem->setLine(m_rect.left()-5,points[i],m_rect.left(),points[i]);
323 320 }
324 321 }
325 322 break;
326 323 default:
327 324 qDebug()<<"Unknown axis type";
328 325 break;
329 326 }
330 327 }
331 328
332 329 //TODO "nice numbers algorithm"
333 330 #include "moc_axisitem_p.cpp"
334 331
335 332 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,72 +1,72
1 1 #ifndef BARPRESENTERBASE_H
2 2 #define BARPRESENTERBASE_H
3 3
4 4 #include "chartitem_p.h"
5 5 #include "qbarseries.h"
6 6 #include <QPen>
7 7 #include <QBrush>
8 8 #include <QGraphicsItem>
9 9
10 10 QTCOMMERCIALCHART_BEGIN_NAMESPACE
11 11
12 12 class Bar;
13 13 class BarLabel;
14 14 class Separator;
15 15 class BarValue;
16 16
17 17 // Common implemantation of different presenters. Not to be instantiated.
18 18 // TODO: combine this with BarPresenter and derive other presenters from it?
19 19 class BarPresenterBase : public QObject, public ChartItem
20 20 {
21 21 Q_OBJECT
22 22 public:
23 23 BarPresenterBase(QBarSeries *series, QGraphicsItem *parent = 0);
24 24 ~BarPresenterBase();
25 25
26 26 public:
27 27 // From QGraphicsItem
28 28 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
29 29 QRectF boundingRect() const;
30 30
31 31 // TODO: these may change with layout awarness.
32 32 void setBarWidth( int w );
33 33
34 34 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
35 35 virtual void dataChanged(); // data of series has changed -> need to recalculate bar sizes
36 36 virtual void layoutChanged() = 0; // layout has changed -> need to recalculate bar sizes
37 37
38 protected slots:
38 public slots:
39 39 void handleModelChanged(int index);
40 40 void handleDomainChanged(const Domain& domain);
41 41 void handleGeometryChanged(const QRectF& size);
42 42
43 43 // Internal slots
44 44 void showToolTip(QPoint pos, QString tip); // shows tooltip (if enabled)
45 45 void enableSeparators(bool enabled);
46 46
47 47 protected:
48 48
49 49 // TODO: consider these.
50 50 int mHeight; // Layout spesific
51 51 int mWidth;
52 52 int mBarDefaultWidth;
53 53
54 54 bool mLayoutSet; // True, if component has been laid out.
55 55 bool mLayoutDirty;
56 56
57 57 bool mSeparatorsEnabled;
58 58
59 59 // Owned
60 60 QBarSeries* mSeries;
61 61
62 62 // Not owned.
63 63 QList<Bar*> mBars;
64 64 QList<BarLabel*> mLabels;
65 65 QList<Separator*> mSeparators;
66 66 QList<BarValue*> mFloatingValues;
67 67
68 68 };
69 69
70 70 QTCOMMERCIALCHART_END_NAMESPACE
71 71
72 72 #endif // BARPRESENTERBASE_H
Show file before | Show file after | Hide comments
@@ -1,359 +1,358
1 1 #include "chartdataset_p.h"
2 2 #include "qchartaxis.h"
3 3 //series
4 4 #include "qlineseries.h"
5 5 #include "qbarseries.h"
6 6 #include "qstackedbarseries.h"
7 7 #include "qpercentbarseries.h"
8 8 #include "qpieseries.h"
9 9 #include "qscatterseries.h"
10 10
11 11 QTCOMMERCIALCHART_BEGIN_NAMESPACE
12 12
13 13 ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
14 14 m_axisX(new QChartAxis(this)),
15 15 m_axisY(new QChartAxis(this)),
16 16 m_domainIndex(0),
17 17 m_axisXInitialized(false)
18 18 {
19 19 }
20 20
21 21 ChartDataSet::~ChartDataSet()
22 22 {
23 23 // TODO Auto-generated destructor stub
24 24 }
25 25
26 26 const Domain ChartDataSet::domain(QChartAxis *axisY) const
27 27 {
28 28 int i = m_domainMap.count(axisY);
29 29 if(i == 0){
30 30 return Domain();
31 31 }
32 32 i = i - m_domainIndex -1;
33 33 return m_domainMap.values(axisY).at(i);
34 34 }
35 35
36 36 void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
37 37 {
38 38 // TODO: we should check the series not already added
39 39
40 40 series->setParent(this); // take ownership
41 41 clearDomains();
42 42
43 43 if(axisY==0) axisY = m_axisY;
44 44 axisY->setParent(this); // take ownership
45 45
46 46 QList<QSeries*> seriesList = m_seriesMap.values(axisY);
47 47
48 48 QList<Domain> domainList = m_domainMap.values(axisY);
49 49
50 50 Q_ASSERT(domainList.size()<=1);
51 51
52 52 Domain domain;
53 53
54 54 if(domainList.size()>0) domain = domainList.at(0);
55 55
56 56 switch(series->type())
57 57 {
58 58 case QSeries::SeriesTypeLine: {
59 59
60 60 QLineSeries* xyseries = static_cast<QLineSeries*>(series);
61 61
62 62 for (int i = 0; i < xyseries->count(); i++)
63 63 {
64 64 qreal x = xyseries->x(i);
65 65 qreal y = xyseries->y(i);
66 66 domain.m_minX = qMin(domain.m_minX,x);
67 67 domain.m_minY = qMin(domain.m_minY,y);
68 68 domain.m_maxX = qMax(domain.m_maxX,x);
69 69 domain.m_maxY = qMax(domain.m_maxY,y);
70 70 }
71 71 break;
72 72 }
73 73 case QSeries::SeriesTypeBar: {
74 74 qDebug() << "QChartSeries::SeriesTypeBar";
75 75 QBarSeries* barSeries = static_cast<QBarSeries*>(series);
76 76 qreal x = barSeries->categoryCount();
77 77 qreal y = barSeries->max();
78 78 domain.m_minX = qMin(domain.m_minX,x);
79 79 domain.m_minY = qMin(domain.m_minY,y);
80 80 domain.m_maxX = qMax(domain.m_maxX,x);
81 81 domain.m_maxY = qMax(domain.m_maxY,y);
82 82 break;
83 83 }
84 84 case QSeries::SeriesTypeStackedBar: {
85 85 qDebug() << "QChartSeries::SeriesTypeStackedBar";
86 86
87 87 QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
88 88 qreal x = stackedBarSeries->categoryCount();
89 89 qreal y = stackedBarSeries->maxCategorySum();
90 90 domain.m_minX = qMin(domain.m_minX,x);
91 91 domain.m_minY = qMin(domain.m_minY,y);
92 92 domain.m_maxX = qMax(domain.m_maxX,x);
93 93 domain.m_maxY = qMax(domain.m_maxY,y);
94 94 break;
95 95 }
96 96 case QSeries::SeriesTypePercentBar: {
97 97 qDebug() << "QChartSeries::SeriesTypePercentBar";
98 98
99 99 QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
100 100 qreal x = percentBarSeries->categoryCount();
101 101 domain.m_minX = qMin(domain.m_minX,x);
102 102 domain.m_minY = 0;
103 103 domain.m_maxX = qMax(domain.m_maxX,x);
104 104 domain.m_maxY = 100;
105 105 break;
106 106 }
107 107
108 108 case QSeries::SeriesTypePie: {
109 109 QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
110 110 // TODO: domain stuff
111 111 break;
112 112 }
113 113
114 114 case QSeries::SeriesTypeScatter: {
115 115 QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
116 116 Q_ASSERT(scatterSeries);
117 117 foreach (QPointF point, scatterSeries->data()) {
118 118 domain.m_minX = qMin(domain.m_minX, point.x());
119 119 domain.m_maxX = qMax(domain.m_maxX, point.x());
120 120 domain.m_minY = qMin(domain.m_minY, point.y());
121 121 domain.m_maxY = qMax(domain.m_maxY, point.y());
122 122 }
123 123 break;
124 124 }
125 125
126 126 default: {
127 127 qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
128 128 return;
129 129 break;
130 130 }
131 131
132 132 }
133 133
134 134 if(!m_domainMap.contains(axisY))
135 135 {
136 136 emit axisAdded(axisY);
137 137 QObject::connect(axisY,SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
138 138 QObject::connect(axisY,SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
139 139 QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
140 140 }
141 141 m_domainMap.replace(axisY,domain);
142 142 m_seriesMap.insert(axisY,series);
143 143
144 144 if(!m_axisXInitialized)
145 145 {
146 146 emit axisAdded(axisX());
147 147 QObject::connect(axisX(),SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
148 148 QObject::connect(axisX(),SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
149 149 QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
150 150 m_axisXInitialized=true;
151 151 }
152 152
153
154 emit seriesAdded(series);
155 153 QStringList ylabels = createLabels(axisY,domain.m_minY,domain.m_maxY);
156 154 QStringList xlabels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
157 155 emit axisLabelsChanged(axisY,ylabels);
158 156 emit axisLabelsChanged(axisX(),xlabels);
157 emit seriesAdded(series);
159 158 emit seriesDomainChanged(series,domain);
160 159
161 160 }
162 161
163 162 void ChartDataSet::removeSeries(QSeries* series)
164 163 {
165 164 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
166 165 foreach(QChartAxis* axis , keys) {
167 166 if(m_seriesMap.contains(axis,series)){
168 167 emit seriesRemoved(series);
169 168 m_seriesMap.remove(axis,series);
170 169 //remove axis if no longer there
171 170 if(!m_seriesMap.contains(axis)){
172 171 emit axisRemoved(axis);
173 172 m_domainMap.remove(axis);
174 173 if(axis != m_axisY)
175 174 delete axis;
176 175 }
177 176 series->setParent(0);
178 177 break;
179 178 }
180 179 }
181 180 }
182 181
183 182 void ChartDataSet::removeAllSeries()
184 183 {
185 184 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
186 185 foreach(QChartAxis* axis , keys) {
187 186 QList<QSeries*> seriesList = m_seriesMap.values(axis);
188 187 for(int i =0 ; i < seriesList.size();i++ )
189 188 {
190 189 emit seriesRemoved(seriesList.at(i));
191 190 delete(seriesList.at(i));
192 191 }
193 192 m_seriesMap.remove(axis);
194 193 m_domainMap.remove(axis);
195 194 emit axisRemoved(axis);
196 195 if(axis != m_axisY) delete axis;
197 196 }
198 197 m_domainIndex=0;
199 198 }
200 199
201 200 bool ChartDataSet::nextDomain()
202 201 {
203 202 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
204 203
205 204 if (m_domainIndex < limit) {
206 205 m_domainIndex++;
207 206 setDomain(m_domainIndex);
208 207 return true;
209 208 }
210 209 else {
211 210 return false;
212 211 }
213 212 }
214 213
215 214 bool ChartDataSet::previousDomain()
216 215 {
217 216 if (m_domainIndex > 0) {
218 217 m_domainIndex--;
219 218 setDomain(m_domainIndex);
220 219 return true;
221 220 }
222 221 else {
223 222 return false;
224 223 }
225 224 }
226 225
227 226 void ChartDataSet::setDomain(int index)
228 227 {
229 228 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
230 229
231 230 if(domainList.count()==0) return;
232 231
233 232 Domain domain;
234 233
235 234 foreach (QChartAxis* axis , domainList) {
236 235 int i = m_domainMap.count(axis) - index -1;
237 236 Q_ASSERT(i>=0);
238 237 domain = m_domainMap.values(axis).at(i);
239 238 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
240 239 QList<QSeries*> seriesList = m_seriesMap.values(axis);
241 240 foreach(QSeries* series, seriesList) {
242 241 emit seriesDomainChanged(series,domain);
243 242 }
244 243 emit axisLabelsChanged(axis,labels);
245 244 }
246 245
247 246 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
248 247 emit axisLabelsChanged(axisX(),labels);
249 248 }
250 249
251 250 void ChartDataSet::clearDomains(int toIndex)
252 251 {
253 252 Q_ASSERT(toIndex>=0);
254 253
255 254 m_domainIndex = toIndex;
256 255
257 256 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
258 257
259 258 foreach (QChartAxis* key , keys)
260 259 {
261 260 QList<Domain> domains = m_domainMap.values(key);
262 261 m_domainMap.remove(key);
263 262 int i = domains.size() - toIndex - 1;
264 263 while(i--){
265 264 domains.removeFirst();
266 265 }
267 266 for(int j=domains.size()-1; j>=0 ;j--)
268 267 m_domainMap.insert(key,domains.at(j));
269 268 }
270 269 }
271 270
272 271 void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
273 272 {
274 273 Q_ASSERT(rect.isValid());
275 274 Q_ASSERT(viewport.isValid());
276 275
277 276 clearDomains(m_domainIndex);
278 277
279 278 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
280 279
281 280 Domain domain;
282 281
283 282 foreach (QChartAxis* axis , domainList){
284 283 domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
285 284 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
286 285 QList<QSeries*> seriesList = m_seriesMap.values(axis);
287 286 foreach(QSeries* series, seriesList){
288 287 emit seriesDomainChanged(series,domain);
289 288 }
290 289 emit axisLabelsChanged(axis,labels);
291 290 m_domainMap.insert(axis,domain);
292 291 }
293 292
294 293 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
295 294 emit axisLabelsChanged(axisX(),labels);
296 295
297 296 m_domainIndex++;
298 297 }
299 298
300 299 QChartAxis* ChartDataSet::axisY(QSeries* series) const
301 300 {
302 301 if(series == 0) return m_axisY;
303 302
304 303 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
305 304
306 305 foreach(QChartAxis* axis , keys) {
307 306 if(m_seriesMap.contains(axis,series)){
308 307 return axis;
309 308 }
310 309 }
311 310 return 0;
312 311 }
313 312
314 313 QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
315 314 {
316 315 Q_ASSERT(max>=min);
317 316
318 317 QStringList labels;
319 318
320 319 int ticks = axis->ticksCount()-1;
321 320
322 321 for(int i=0; i<= ticks; i++){
323 322 qreal value = min + (i * (max - min)/ ticks);
324 323 QString label = axis->axisTickLabel(value);
325 324 if(label.isEmpty()){
326 325 labels << QString::number(value);
327 326 }else{
328 327 labels << label;
329 328 }
330 329 }
331 330 return labels;
332 331 }
333 332
334 333
335 334 void ChartDataSet::handleMinChanged(qreal min)
336 335 {
337 336
338 337 }
339 338
340 339 void ChartDataSet::handleMaxChanged(qreal max)
341 340 {
342 341
343 342 }
344 343
345 344 void ChartDataSet::handleTickChanged(QChartAxis* axis)
346 345 {
347 346 Domain domain = m_domainMap.value(axisY());
348 347 if(axis==axisX()){
349 348 QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
350 349 emit axisLabelsChanged(axis,labels);
351 350 }else{
352 351 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
353 352 emit axisLabelsChanged(axis,labels);
354 353 }
355 354 }
356 355
357 356 #include "moc_chartdataset_p.cpp"
358 357
359 358 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,283 +1,284
1 1 #include "qchart.h"
2 2 #include "qchartaxis.h"
3 3 #include "chartpresenter_p.h"
4 4 #include "chartdataset_p.h"
5 5 #include "charttheme_p.h"
6 6 //series
7 7 #include "qbarseries.h"
8 8 #include "qstackedbarseries.h"
9 9 #include "qpercentbarseries.h"
10 10 #include "qlineseries.h"
11 11 #include "qpieseries.h"
12 12 #include "qscatterseries.h"
13 13 //items
14 14 #include "axisitem_p.h"
15 15 #include "axisanimationitem_p.h"
16 16 #include "barpresenter_p.h"
17 17 #include "stackedbarpresenter_p.h"
18 18 #include "percentbarpresenter_p.h"
19 19 #include "linechartitem_p.h"
20 20 #include "linechartanimationitem_p.h"
21 21 #include "piepresenter_p.h"
22 22 #include "scatterpresenter_p.h"
23 23
24 24 QTCOMMERCIALCHART_BEGIN_NAMESPACE
25 25
26 26 ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
27 27 m_chart(chart),
28 28 m_dataset(dataset),
29 29 m_chartTheme(0),
30 30 m_marginSize(0),
31 31 m_rect(QRectF(QPoint(0,0),m_chart->size())),
32 32 m_options(0)
33 33 {
34 34 createConnections();
35 35 setChartTheme(QChart::ChartThemeDefault);
36 36
37 37 }
38 38
39 39 ChartPresenter::~ChartPresenter()
40 40 {
41 41 }
42 42
43 43 void ChartPresenter::createConnections()
44 44 {
45 45 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
46 46 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*)),this,SLOT(handleSeriesAdded(QSeries*)));
47 47 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
48 48 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
49 49 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
50 50 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
51 51 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
52 52 }
53 53
54 54
55 55 QRectF ChartPresenter::geometry() const
56 56 {
57 57 return m_rect;
58 58 }
59 59
60 60 void ChartPresenter::handleGeometryChanged()
61 61 {
62 62 m_rect = QRectF(QPoint(0,0),m_chart->size());
63 63 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
64 64 Q_ASSERT(m_rect.isValid());
65 65 emit geometryChanged(m_rect);
66 66 }
67 67
68 68 int ChartPresenter::margin() const
69 69 {
70 70 return m_marginSize;
71 71 }
72 72
73 73 void ChartPresenter::setMargin(int margin)
74 74 {
75 75 m_marginSize = margin;
76 76 }
77 77
78 78 void ChartPresenter::handleAxisAdded(QChartAxis* axis)
79 79 {
80 80
81 81 AxisItem* item ;
82 82
83 83 if(!m_options.testFlag(QChart::GridAxisAnimations))
84 84 {
85 85 item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
86 86 }else{
87 87 item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
88 88 }
89 89
90 90 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
91 91 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
92 92
93 93 item->handleAxisUpdate(axis);
94 94 item->handleGeometryChanged(m_rect);
95 95 m_chartTheme->decorate(axis,item);
96 96 m_axisItems.insert(axis,item);
97 97 }
98 98
99 99 void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
100 100 {
101 101 AxisItem* item = m_axisItems.take(axis);
102 102 Q_ASSERT(item);
103 103 delete item;
104 104 }
105 105
106 106
107 107 void ChartPresenter::handleSeriesAdded(QSeries* series)
108 108 {
109 109 switch(series->type())
110 110 {
111 111 case QSeries::SeriesTypeLine: {
112 112 QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
113 113 LineChartItem* item;
114 114 if(m_options.testFlag(QChart::SeriesAnimations)){
115 115 item = new LineChartAnimationItem(this,lineSeries,m_chart);
116 116 }else{
117 117 item = new LineChartItem(this,lineSeries,m_chart);
118 118 }
119 119 m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
120 120 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
121 QObject::connect(lineSeries,SIGNAL(pointChanged(int)),item,SLOT(handleModelChanged(int)));
121 QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
122 QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
123 QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
122 124 m_chartItems.insert(series,item);
125 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
123 126 break;
124 127 }
125 128
126 129 case QSeries::SeriesTypeBar: {
127 130 QBarSeries* barSeries = static_cast<QBarSeries*>(series);
128 131 BarPresenter* item = new BarPresenter(barSeries,m_chart);
129 132 m_chartTheme->decorate(item,barSeries,m_chartItems.count());
130 133 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
131 134 QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
132 135 m_chartItems.insert(series,item);
133 136 // m_axisXItem->setVisible(false);
137 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
134 138 break;
135 139 }
136 140
137 141 case QSeries::SeriesTypeStackedBar: {
138 142
139 143 QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
140 144 StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
141 145 m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
142 146 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
143 147 QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
144 148 m_chartItems.insert(series,item);
149 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
145 150 break;
146 151 }
147 152
148 153 case QSeries::SeriesTypePercentBar: {
149 154
150 155 QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
151 156 PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
152 157 m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
153 158 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
154 159 QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
155 160 m_chartItems.insert(series,item);
161 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
156 162 break;
157 163 }
158 164 case QSeries::SeriesTypeScatter: {
159 165 QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
160 166 ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
161 167 QObject::connect(scatterPresenter, SIGNAL(clicked()), scatterSeries, SIGNAL(clicked()));
162 168 QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
163 169 scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
164 170 m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
165 171 m_chartItems.insert(scatterSeries, scatterPresenter);
172 if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
166 173 break;
167 174 }
168 175 case QSeries::SeriesTypePie: {
169 176 QPieSeries *s = qobject_cast<QPieSeries *>(series);
170 177 PiePresenter* pie = new PiePresenter(m_chart, s);
171 178 m_chartTheme->decorate(pie, s, m_chartItems.count());
172 179 QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
173 180
174 181 // Hide all from background when there is only piechart
175 182 // TODO: refactor this ugly code... should be one setting for this
176 183 if (m_chartItems.count() == 0) {
177 184 m_chart->axisX()->setAxisVisible(false);
178 185 m_chart->axisY()->setAxisVisible(false);
179 186 m_chart->axisX()->setGridVisible(false);
180 187 m_chart->axisY()->setGridVisible(false);
181 188 m_chart->axisX()->setLabelsVisible(false);
182 189 m_chart->axisY()->setLabelsVisible(false);
183 190 m_chart->axisX()->setShadesVisible(false);
184 191 m_chart->axisY()->setShadesVisible(false);
185 192 m_chart->setChartBackgroundBrush(Qt::transparent);
186 193 }
187 194
188 195 m_chartItems.insert(series, pie);
196 pie->handleGeometryChanged(m_rect);
189 197 break;
190 198 }
191 199 default: {
192 200 qDebug()<< "Series type" << series->type() << "not implemented.";
193 201 break;
194 202 }
195 203 }
196
197 if(m_rect.isValid()) emit geometryChanged(m_rect);
198 204 }
199 205
200 206 void ChartPresenter::handleSeriesRemoved(QSeries* series)
201 207 {
202 208 ChartItem* item = m_chartItems.take(series);
203 209 delete item;
204 210 }
205 211
206 void ChartPresenter::handleSeriesChanged(QSeries* series)
207 {
208 //TODO:
209 }
210
211 212 void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
212 213 {
213 214 m_chartItems.value(series)->handleDomainChanged(domain);
214 215 }
215 216
216 217 void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
217 218 {
218 219 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
219 220 }
220 221
221 222 void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
222 223 {
223 224 delete m_chartTheme;
224 225
225 226 m_chartTheme = ChartTheme::createTheme(theme);
226 227
227 228 m_chartTheme->decorate(m_chart);
228 229 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
229 230
230 231 int index=0;
231 232 while (i.hasNext()) {
232 233 i.next();
233 234 m_chartTheme->decorate(i.value(),i.key(),index);
234 235 index++;
235 236 }
236 237
237 238 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
238 239 while (j.hasNext()) {
239 240 j.next();
240 241 m_chartTheme->decorate(j.key(),j.value());
241 242 }
242 243 }
243 244
244 245 QChart::ChartTheme ChartPresenter::chartTheme()
245 246 {
246 247 return m_chartTheme->id();
247 248 }
248 249
249 250 void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
250 251 {
251 252 if(m_options!=options) {
252 253
253 254 m_options=options;
254 255
255 256 //recreate elements
256 257
257 258 QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
258 259 QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
259 260
260 261 foreach(QChartAxis* axis, axisList) {
261 262 handleAxisRemoved(axis);
262 263 handleAxisAdded(axis);
263 264 }
264 265 foreach(QSeries* series, seriesList) {
265 266 handleSeriesRemoved(series);
266 267 handleSeriesAdded(series);
267 268 }
268 269
269 270 //now reintialize view data
270 271 //TODO: make it more nice
271 272 m_dataset->setDomain(m_dataset->domainIndex());
272 273 }
273 274 }
274 275
275 276 QChart::AnimationOptions ChartPresenter::animationOptions() const
276 277 {
277 278 return m_options;
278 279 }
279 280
280 281
281 282 #include "moc_chartpresenter_p.cpp"
282 283
283 284 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,74 +1,73
1 1 #ifndef CHARTPRESENTER_H_
2 2 #define CHARTPRESENTER_H_
3 3
4 4 #include "qchartglobal.h"
5 5 #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
6 6 #include "qchartaxis.h"
7 7 #include <QRectF>
8 8
9 9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10 10
11 11 class ChartItem;
12 12 class QSeries;
13 13 class ChartDataSet;
14 14 //class QChart;
15 15 class Domain;
16 16 class AxisItem;
17 17 class ChartTheme;
18 18
19 19 class ChartPresenter: public QObject
20 20 {
21 21 Q_OBJECT
22 22 public:
23 23 enum ZValues {
24 24 BackgroundZValue = -1,
25 25 ShadesZValue,
26 26 GridZValue,
27 27 AxisZValue,
28 28 LineChartZValue,
29 29 ScatterSeriesZValue
30 30 };
31 31
32 32 ChartPresenter(QChart* chart,ChartDataSet *dataset);
33 33 virtual ~ChartPresenter();
34 34
35 35 void setMargin(int margin);
36 36 int margin() const;
37 37
38 38 QRectF geometry() const;
39 39
40 40 void setChartTheme(QChart::ChartTheme theme);
41 41 QChart::ChartTheme chartTheme();
42 42
43 43 void setAnimationOptions(QChart::AnimationOptions options);
44 44 QChart::AnimationOptions animationOptions() const;
45 45
46 46 private:
47 47 void createConnections();
48 48
49 49 public slots:
50 50 void handleSeriesAdded(QSeries* series);
51 51 void handleSeriesRemoved(QSeries* series);
52 52 void handleAxisAdded(QChartAxis* axis);
53 53 void handleAxisRemoved(QChartAxis* axis);
54 54 void handleSeriesDomainChanged(QSeries* series, const Domain& domain);
55 55 void handleAxisLabelsChanged(QChartAxis* axis, const QStringList& labels);
56 void handleSeriesChanged(QSeries* series);
57 56 void handleGeometryChanged();
58 57 signals:
59 58 void geometryChanged(const QRectF& rect);
60 59 private:
61 60 QMap<QSeries*,ChartItem*> m_chartItems;
62 61 QMap<QChartAxis*,AxisItem*> m_axisItems;
63 62 QChart* m_chart;
64 63 ChartDataSet* m_dataset;
65 64 ChartTheme *m_chartTheme;
66 65 int m_marginSize;
67 66 QRectF m_rect;
68 67 QChart::AnimationOptions m_options;
69 68
70 69 };
71 70
72 71 QTCOMMERCIALCHART_END_NAMESPACE
73 72
74 73 #endif /* CHARTPRESENTER_H_ */
Show file before | Show file after | Hide comments
@@ -1,63 +1,105
1 1 #include "linechartanimationitem_p.h"
2 2 #include "linechartitem_p.h"
3 3 #include <QPropertyAnimation>
4 4
5 5 QTCOMMERCIALCHART_BEGIN_NAMESPACE
6 6
7 7 const static int duration = 500;
8 8
9 9
10 10 LineChartAnimationItem::LineChartAnimationItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):
11 11 LineChartItem(presenter,series,parent)
12 12 {
13 13
14 14 }
15 15
16 16 LineChartAnimationItem::~LineChartAnimationItem()
17 17 {
18 18 }
19 19
20 20 void LineChartAnimationItem::addPoints(const QVector<QPointF>& points)
21 21 {
22 m_data=points;
23 clearView();
22 QVector<qreal> vector0 = vector1;
23 calculateLayout(vector1);
24 if(vector1.count()==0) return;
25 vector0.resize(vector1.size());
26
27
28 LineChartAnimatator *animation = new LineChartAnimatator(this,this);
29 animation->setDuration(duration);
30 animation->setEasingCurve(QEasingCurve::InOutBack);
31 animation->setKeyValueAt(0.0, qVariantFromValue(vector0));
32 animation->setKeyValueAt(1.0, qVariantFromValue(vector1));
33 animation->start(QAbstractAnimation::DeleteWhenStopped);
34
24 35 QPropertyAnimation *animation = new QPropertyAnimation(this, "a_addPoints", parent());
25 36 animation->setDuration(duration);
26 37 //animation->setEasingCurve(QEasingCurve::InOutBack);
27 38 animation->setKeyValueAt(0.0, 0);
28 39 animation->setKeyValueAt(1.0, m_data.size());
29 40 animation->start(QAbstractAnimation::DeleteWhenStopped);
30 41 }
31 42
32 void LineChartAnimationItem::setPoint(int index,const QPointF& point)
43 void LineChartAnimationItem::replacePoint(int index,const QPointF& point)
33 44 {
34 45 AnimationHelper* helper = new AnimationHelper(this,index);
35 46 QPropertyAnimation *animation = new QPropertyAnimation(helper, "point", parent());
36 47 animation->setDuration(duration);
37 48 //animation->setEasingCurve(QEasingCurve::InOutBack);
38 49 animation->setKeyValueAt(0.0, points().value(index));
39 50 animation->setKeyValueAt(1.0, point);
40 51 animation->start(QAbstractAnimation::DeleteWhenStopped);
41 52 }
42 53
43 54 void LineChartAnimationItem::aw_addPoints(int points)
44 55 {
45 56 int index = count();
46 57 for(int i = index;i< points ;i++){
47 58 LineChartItem::addPoint(m_data.at(i));
48 59 }
49 60 updateGeometry();
50 61 update();
51 62 }
52 63
53 64 void LineChartAnimationItem::aw_setPoint(int index,const QPointF& point)
54 65 {
55 LineChartItem::setPoint(index,point);
66 LineChartItem::replacePoint(index,point);
56 67 updateGeometry();
57 68 update();
58 69 }
59 70
71 LineChartAnimatator::LineChartAnimatator(LineChartItem *item, int index , QObject *parent = 0 ):QVariantAnimation(parent),
72 m_item(item),
73 m_index(index)
74 {
75 };
76
77 LineChartAnimatator::~LineChartAnimatator()
78 {
79 }
80
81 QVariant LineChartAnimatator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
82 {
83 QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
84 QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
85 QVector<qreal> result;
86 Q_ASSERT(startVector.count() == endVecotr.count());
87
88 for(int i =0 ;i< startVector.count();i++){
89 qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
90 result << value;
91 }
92 return qVariantFromValue(result);
93 }
94
95
96 void LineChartAnimatator::updateCurrentValue (const QVariant & value )
97 {
98 QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
99 m_axis->applyLayout(vector);
100 }
101
60 102
61 103 #include "moc_linechartanimationitem_p.cpp"
62 104
63 105 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,55 +1,42
1 1 #ifndef LINECHARTANIMATIONITEM_P_H_
2 2 #define LINECHARTANIMATIONITEM_P_H_
3 3
4 4 #include "qchartglobal.h"
5 5 #include "linechartitem_p.h"
6 6 #include "domain_p.h"
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class LineChartItem;
11 11
12 12 class LineChartAnimationItem : public LineChartItem {
13 Q_OBJECT
14 Q_PROPERTY(int a_addPoints READ ar_addPoints WRITE aw_addPoints);
15 // Q_PROPERTY(QPointF a_setPoint READ ar_setPoint WRITE aw_setPoint);
13
16 14 public:
17 15 LineChartAnimationItem(ChartPresenter* presenter, QLineSeries *series, QGraphicsItem *parent = 0);
18 16 virtual ~LineChartAnimationItem();
19 17
20 18 void addPoints(const QVector<QPointF>& points);
21 void setPoint(int index,const QPointF& point);
22 //void removePoint(const QPointF& point){};
23 //void setPoint(const QPointF& oldPoint, const QPointF& newPoint){};
24
25 int ar_addPoints() const { return m_addPoints;}
26 void aw_addPoints(int points);
27 const QPointF& ar_setPoint() const { return m_setPoint;}
28 void aw_setPoint(int index,const QPointF& point);
19 void replacePoint(int index,const QPointF& point);
29 20
30 21 private:
31 22 QVector<QPointF> m_data;
32 23 Domain m_domain;
33 24 int m_addPoints;
34 25 QPointF m_setPoint;
35 26 int m_setPoint_index;
36 27 };
37 28
38 class AnimationHelper: public QObject
29 class LineChartAnimatator: public QVariantAnimation
39 30 {
40 Q_OBJECT
41 Q_PROPERTY(QPointF point READ point WRITE setPoint);
31
42 32 public:
43 AnimationHelper(LineChartAnimationItem* item,int index):m_item(item),m_index(index){};
44 void setPoint(const QPointF& point){
45 m_item->aw_setPoint(m_index,point);
46 }
47 QPointF point(){return m_point;}
33 LineChartAnimatator(LineChartItem *item, int index , QObject *parent = 0 ):m_item(item),m_index(index){};
34
48 35 QPointF m_point;
49 36 LineChartAnimationItem* m_item;
50 37 int m_index;
51 38 };
52 39
53 40 QTCOMMERCIALCHART_END_NAMESPACE
54 41
55 42 #endif
Show file before | Show file after | Hide comments
@@ -1,210 +1,244
1 1 #include "linechartitem_p.h"
2 2 #include "qlineseries.h"
3 3 #include "chartpresenter_p.h"
4 4 #include <QPainter>
5 5
6 6
7 7 QTCOMMERCIALCHART_BEGIN_NAMESPACE
8 8
9 9 //TODO: optimazie : remove points which are not visible
10 10
11 11 LineChartItem::LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
12 12 m_presenter(presenter),
13 m_series(series),
14 m_dirtyData(false),
15 m_dirtyGeometry(false),
16 m_dirtyDomain(false)
13 m_series(series)
17 14 {
18 15 setZValue(ChartPresenter::LineChartZValue);
19 16 }
20 17
21 18 QRectF LineChartItem::boundingRect() const
22 19 {
23 20 return m_rect;
24 21 }
25 22
26 23 QPainterPath LineChartItem::shape() const
27 24 {
28 25 return m_path;
29 26 }
30 27
31
32 void LineChartItem::addPoints(const QVector<QPointF>& points)
28 void LineChartItem::createPoints(int count)
33 29 {
34 m_data = points;
35 for(int i=0; i<m_data.size();i++){
36 const QPointF& point =m_data[i];
37 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
38 item->setPos(point.x()-1,point.y()-1);;
39 if(!m_clipRect.contains(point) || !m_series->pointsVisible()) item->setVisible(false);
40 m_points << item;
30 for (int i = 0; i < count; ++i) {
31 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
32 m_items.addToGroup(item);
41 33 }
42 34 }
43 35
44 void LineChartItem::addPoint(const QPointF& point)
36 void LineChartItem::clearPoints(int count)
45 37 {
46 m_data << point;
47 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
48 m_clipRect.contains(point);
49 item->setPos(point.x()-1,point.y()-1);
50 if(!m_clipRect.contains(point) || !m_series->pointsVisible()) item->setVisible(false);
51 m_points << item;
52 }
53
54 void LineChartItem::removePoint(const QPointF& point)
55 {
56 Q_ASSERT(m_data.count() == m_points.count());
57 int index = m_data.lastIndexOf(point,0);
58 m_data.remove(index);
59 delete(m_points.takeAt(index));
60 }
38 QList<QGraphicsItem *> items = m_items.childItems();
61 39
62 void LineChartItem::setPoint(const QPointF& oldPoint,const QPointF& newPoint)
63 {
64 Q_ASSERT(m_data.count() == m_points.count());
65 int index = m_data.lastIndexOf(oldPoint,0);
66
67 if(index > -1){
68 m_data.replace(index,newPoint);
69 QGraphicsItem* item = m_points.at(index);
70 item->setPos(newPoint.x()-1,newPoint.y()-1);
40 for (int i = 0; i < count; ++i) {
41 delete(items.takeLast());
71 42 }
72 43 }
73 44
74 void LineChartItem::setPoint(int index,const QPointF& point)
75 {
76 Q_ASSERT(m_data.count() == m_points.count());
77 Q_ASSERT(index>=0);
78
79 m_data.replace(index,point);
80 QGraphicsItem* item = m_points.at(index);
81 item->setPos(point.x()-1,point.y()-1);
82 }
83
84 void LineChartItem::clear()
85 {
86 qDeleteAll(m_points);
87 m_points.clear();
88 m_hash.clear();
89 m_path = QPainterPath();
90 m_rect = QRect();
91 m_data.clear();
92 }
93
94 void LineChartItem::clearView()
95 {
96 qDeleteAll(m_points);
97 m_points.clear();
98 m_path = QPainterPath();
99 m_rect = QRect();
100 m_data.clear();
101 }
102
103 45 void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
104 46 {
105 47 Q_UNUSED(widget);
106 48 Q_UNUSED(option);
107 49 painter->save();
108 50 painter->setPen(m_pen);
109 51 painter->setClipRect(m_clipRect);
110 52 painter->drawPath(m_path);
111 53 painter->restore();
112 54 }
113 55
114 void LineChartItem::calculatePoint(QPointF& point, int index, const QLineSeries* series,const QSizeF& size, const Domain& domain) const
56 QPointF LineChartItem::calculatePoint(int index) const
115 57 {
116 const qreal deltaX = size.width()/domain.spanX();
117 const qreal deltaY = size.height()/domain.spanY();
118 qreal x = (series->x(index) - domain.m_minX)* deltaX;
119 qreal y = (series->y(index) - domain.m_minY)*-deltaY + size.height();
120 point.setX(x);
121 point.setY(y);
58 const qreal deltaX = m_size.width()/m_domain.spanX();
59 const qreal deltaY = m_size.height()/m_domain.spanY();
60 qreal x = (m_series->x(index) - m_domain.m_minX)* deltaX;
61 qreal y = (m_series->y(index) - m_domain.m_minY)*-deltaY + m_size.height();
62 return QPointF(x,y);
122 63 }
123 64
124 65
125 void LineChartItem::calculatePoints(QVector<QPointF>& points, QHash<int,int>& hash,const QLineSeries* series,const QSizeF& size, const Domain& domain) const
66 void LineChartItem::calculatePoints(QVector<QPointF>& points, QVector<int>& map) const
126 67 {
127 const qreal deltaX = size.width()/domain.spanX();
128 const qreal deltaY = size.height()/domain.spanY();
68 const qreal deltaX = m_size.width()/m_domain.spanX();
69 const qreal deltaY = m_size.height()/m_domain.spanY();
129 70
130 for (int i = 0; i < series->count(); ++i) {
131 qreal x = (series->x(i) - domain.m_minX)* deltaX;
132 qreal y = (series->y(i) - domain.m_minY)*-deltaY + size.height();
133 hash[i] = points.size();
71 for (int i = 0; i < m_series->count(); ++i) {
72 qreal x = (m_series->x(i) - m_domain.m_minX)* deltaX;
73 qreal y = (m_series->y(i) - m_domain.m_minY)*-deltaY + m_size.height();
74 map << i;
134 75 points << QPointF(x,y);
135 76 }
136 77 }
137 78
138 void LineChartItem::updateDomain()
79 void LineChartItem::updateItem(QVector<QPointF>& points,QVector<int>& map)
139 80 {
140 clear();
141 prepareGeometryChange();
142 calculatePoints(m_data,m_hash,m_series,m_size, m_domain);
143 addPoints(m_data);
144 }
81 int diff = m_points.size() - points.size();
145 82
146 void LineChartItem::updateData()
147 {
148 //for now the same
149 updateDomain();
83 if(diff>0) {
84 clearPoints(diff);
85 }
86 else if(diff<0) {
87 createPoints(-diff);
88 }
89
90 applyGeometry(points);
91 m_points=points;
92 m_map=map;
150 93 }
151 94
152 void LineChartItem::updateGeometry()
95 void LineChartItem::applyGeometry(QVector<QPointF>& points)
153 96 {
97 if(points.size()==0) return;
154 98
155 if(m_data.size()==0) return;
99 QList<QGraphicsItem*> items = m_items.childItems();
156 100
157 prepareGeometryChange();
158 101 QPainterPath path;
159 const QPointF& point = m_data.at(0);
102 const QPointF& point = points.at(0);
160 103 path.moveTo(point);
161
162 foreach( const QPointF& point , m_data) {
104 QGraphicsItem* item = items.at(0);
105 item->setPos(point.x()-1,point.y()-1);
106
107 for(int i=1 ; i< points.size();i++) {
108 QGraphicsItem* item = items.at(i);
109 const QPointF& point = points.at(i);
110 item->setPos(point.x()-1,point.y()-1);
111 if(!m_clipRect.contains(point)) item->setVisible(false);
163 112 path.lineTo(point);
164 113 }
165 114
115 prepareGeometryChange();
166 116 m_path = path;
167 117 m_rect = path.boundingRect();
168 118 }
169 119
170 120 void LineChartItem::setPen(const QPen& pen)
171 121 {
172 122 m_pen = pen;
173 123 }
174 124
175 125 //handlers
176 126
177 void LineChartItem::handleModelChanged(int index)
127 void LineChartItem::handlePointAdded(int index)
178 128 {
179 129 Q_ASSERT(index<m_series->count());
180 if(m_hash.contains(index)){
181 int i = m_hash.value(index);
182 QPointF point;
183 calculatePoint(point,index,m_series,m_size,m_domain);
184 setPoint(i,point);
130 Q_ASSERT(index>=0);
131
132 if(m_map.contains(index)){
133
134 int i = m_map.indexOf(index);
135
136 QPointF point = calculatePoint(index);
137
138 if(point.isNull()) return;
139
140 QVector<QPointF> points = m_points;
141 points.insert(i,point);
142
143 for(int j=i;j<m_map.count();j++)
144 m_map[j]-=1;
145
146 updateItem(points,m_map);
147
148 }else{
149 //ignore
150 return;
151 }
152 update();
153 }
154 void LineChartItem::handlePointRemoved(int index)
155 {
156 Q_ASSERT(index<m_series->count());
157 Q_ASSERT(index>=0);
158
159 if(m_map.contains(index)){
160
161 int i = m_map.value(index);
162
163 QVector<QPointF> points = m_points;
164 points.remove(i);
165
166 for(int j=i;j<m_map.count();j++)
167 m_map[j]+=1;
168
169 m_map<<
170
171 updateItem(points,m_map);
172
173 }else{
174 //ignore
175 return;
176 }
177 update();
178 }
179
180 void LineChartItem::handlePointReplaced(int index)
181 {
182 Q_ASSERT(index<m_series->count());
183 Q_ASSERT(index>=0);
184
185 if(m_map.contains(index)){
186
187 int i = m_map.indexOf(index);
188
189 QPointF point = calculatePoint(index);
190
191 QVector<QPointF> points = m_points;
192 points.replace(i,point);
193
194 updateItem(points,m_map);
195
196 }else{
197 //ignore
198 return;
185 199 }
186 200 update();
187 201 }
188 202
189 203 void LineChartItem::handleDomainChanged(const Domain& domain)
190 204 {
191 205 m_domain = domain;
192 updateDomain();
206 if(m_domain.isEmpty()) return;
207
208 QVector<QPointF> points;
209 QVector<int> map;
210 calculatePoints(points,map);
211 updateItem(points,map);
193 212 update();
194 213 }
195 214
196 215 void LineChartItem::handleGeometryChanged(const QRectF& rect)
197 216 {
198 217 Q_ASSERT(rect.isValid());
199 218 m_size=rect.size();
200 219 m_clipRect=rect.translated(-rect.topLeft());
201 updateDomain();
202 updateGeometry();
203 220 setPos(rect.topLeft());
221
222 if(m_domain.isEmpty()) return;
223 if(m_points.isEmpty()) return;
224
225 QVector<QPointF> points;
226 QVector<int> map;
227 calculatePoints(points,map);
228 updateItem(points,map);
229 update();
230 }
231
232 void LineChartItem::handleSeriesUpdated()
233 {
234 if(m_points.count()==0) return;
235
236 m_items.setVisible(m_series->pointsVisible());
237 setPen(m_series->pen());
204 238 update();
205 239 }
206 240
207 241
208 242 #include "moc_linechartitem_p.cpp"
209 243
210 244 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,74 +1,66
1 1 #ifndef LINECHARTITEM_H
2 2 #define LINECHARTITEM_H
3 3
4 4 #include "qchartglobal.h"
5 5 #include "chartitem_p.h"
6 6 #include <QPen>
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class ChartPresenter;
11 11 class QLineSeries;
12 class LineChartAnimationItem;
13 12
14 13 class LineChartItem : public QObject , public ChartItem
15 14 {
16 15 Q_OBJECT
17 16 public:
18 17 LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent = 0);
19 18 ~ LineChartItem(){};
20 19
21 20 //from QGraphicsItem
22 21 QRectF boundingRect() const;
23 22 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
24 23 QPainterPath shape() const;
25 24
26 25 void setPen(const QPen& pen);
27 const Domain& domain() const { return m_domain;}
26 void setPointsVisible(bool visible);
27
28 public slots:
29 void handlePointAdded(int index);
30 void handlePointRemoved(int index);
31 void handlePointReplaced(int index);
32 void handleDomainChanged(const Domain& domain);
33 void handleGeometryChanged(const QRectF& size);
28 34
35 protected:
29 36 virtual void addPoint(const QPointF& );
30 37 virtual void addPoints(const QVector<QPointF>& points);
31 38 virtual void removePoint(const QPointF& point);
32 virtual void setPoint(const QPointF& oldPoint, const QPointF& newPoint);
33 virtual void setPoint(int index,const QPointF& point);
34 void setPointsVisible(bool visible);
35 void clear();
36 void clearView();
37 int count() const { return m_data.size();}
38
39 const QVector<QPointF>& points(){ return m_data;}
39 virtual void replacePoint(const QPointF& oldPoint, const QPointF& newPoint);
40 virtual void replacePoint(int index,const QPointF& point);
41 virtual void updateItem(QVector<QPointF>& points,QVector<int>& map);
42 virtual void applyGeometry(QVector<QPointF>& points);
40 43
41 protected:
42 virtual void updateGeometry();
43 virtual void updateData();
44 virtual void updateDomain();
45 //refactor
46 void calculatePoint(QPointF& point, int index, const QLineSeries* series,const QSizeF& size, const Domain& domain) const;
47 void calculatePoints(QVector<QPointF>& points,QHash<int,int>& hash,const QLineSeries* series, const QSizeF& size, const Domain& domain) const;
44 void clear();
48 45
49 protected slots:
50 void handleModelChanged(int index);
51 void handleDomainChanged(const Domain& domain);
52 void handleGeometryChanged(const QRectF& size);
46 QPointF calculatePoint(int index) const;
47 void calculatePoints(QVector<QPointF>& points,QVector<int>& map) const;
53 48
54 49 private:
55 50 ChartPresenter* m_presenter;
56 51 QPainterPath m_path;
57 52 QSizeF m_size;
58 53 QRectF m_rect;
59 54 QRectF m_clipRect;
60 55 Domain m_domain;
61 QList<QGraphicsItem*> m_points;
62 QVector<QPointF> m_data;
63 QHash<int,int> m_hash;
56 QList<QGraphicsItem*> m_items;
57 QVector<QPointF> m_points;
58 QVector<int> m_map;
64 59 QLineSeries* m_series;
65 60 QPen m_pen;
66 bool m_dirtyData;
67 bool m_dirtyGeometry;
68 bool m_dirtyDomain;
69 61
70 62 };
71 63
72 64 QTCOMMERCIALCHART_END_NAMESPACE
73 65
74 66 #endif
Show file before | Show file after | Hide comments
@@ -1,213 +1,213
1 1 #include "qlineseries.h"
2 2
3 3 QTCOMMERCIALCHART_BEGIN_NAMESPACE
4 4
5 5 /*!
6 6 \class QLineSeries
7 7 \brief The QLineSeries class is used for making line charts.
8 8
9 9 \mainclass
10 10
11 11 A line chart is used to show information as a series of data points
12 12 connected by straight lines.
13 13
14 14 \image linechart.png
15 15
16 16 Creating basic line chart is simple:
17 17 \code
18 18 QLineSeries* series = new QLineSeries();
19 19 series->add(0, 6);
20 20 series->add(2, 4);
21 21 ...
22 22 chartView->addSeries(series);
23 23 \endcode
24 24 */
25 25
26 26 /*!
27 27 \fn virtual QSeriesType QLineSeries::type() const
28 28 \brief Returns type of series.
29 29 \sa QSeries, QSeriesType
30 30 */
31 31
32 32 /*!
33 33 \fn QPen QLineSeries::pen() const
34 34 \brief Returns the pen used to draw line for this series.
35 35 \sa setPen()
36 36 */
37 37
38 38 /*!
39 39 \fn bool QLineSeries::pointsVisible() const
40 40 \brief Returns if the points are drawn for this series.
41 41 \sa setPointsVisible()
42 42 */
43 43
44 44
45 45 /*!
46 \fn void QLineSeries::pointChanged(int index)
46 \fn void QLineSeries::pointReplaced(int index)
47 47 \brief \internal \a index
48 48 */
49 49
50 50 /*!
51 51 \fn void QLineSeries::pointAdded(int index)
52 52 \brief \internal \a index
53 53 */
54 54
55 55 /*!
56 56 \fn void QLineSeries::pointRemoved(int index)
57 57 \brief \internal \a index
58 58 */
59 59
60 60 /*!
61 61 Constructs empty series object which is a child of \a parent.
62 62 When series object is added to QChartView or QChart instance ownerships is transfered.
63 63 */
64 64 QLineSeries::QLineSeries(QObject* parent):QSeries(parent),
65 65 m_pointsVisible(false)
66 66 {
67 67 }
68 68 /*!
69 69 Destroys the object. Series added to QChartView or QChart instances are owned by those,
70 70 and are deleted when mentioned object are destroyed.
71 71 */
72 72 QLineSeries::~QLineSeries()
73 73 {
74 74 }
75 75
76 76 /*!
77 77 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
78 78 */
79 79 void QLineSeries::add(qreal x,qreal y)
80 80 {
81 81 Q_ASSERT(m_x.size() == m_y.size());
82 82 m_x<<x;
83 83 m_y<<y;
84 84 emit pointAdded(m_x.size()-1);
85 85 }
86 86
87 87 /*!
88 88 This is an overloaded function.
89 89 Adds data \a point to the series. Points are connected with lines on the chart.
90 90 */
91 91 void QLineSeries::add(const QPointF& point)
92 92 {
93 93 add(point.x(),point.y());
94 94 }
95 95
96 96 /*!
97 97 Modifies \a y value for given \a x a value.
98 98 */
99 99 void QLineSeries::replace(qreal x,qreal y)
100 100 {
101 101 int index = m_x.indexOf(x);
102 102 m_x[index]=x;
103 103 m_y[index]=y;
104 emit pointChanged(index);
104 emit pointReplaced(index);
105 105 }
106 106
107 107 /*!
108 108 This is an overloaded function.
109 109 Replaces current y value of for given \a point x value with \a point y value.
110 110 */
111 111 void QLineSeries::replace(const QPointF& point)
112 112 {
113 113 replace(point.x(),point.y());
114 114 }
115 115
116 116 /*!
117 117 Removes current \a x and y value.
118 118 */
119 119 void QLineSeries::remove(qreal x)
120 120 {
121 121 int index = m_x.indexOf(x);
122 122 m_x.remove(index);
123 123 m_y.remove(index);
124 124 emit pointRemoved(index);
125 125 }
126 126
127 127 /*!
128 128 Removes current \a point x value. Note \a point y value is ignored.
129 129 */
130 130 void QLineSeries::remove(const QPointF& point)
131 131 {
132 132 remove(point.x());
133 133 }
134 134
135 135 /*!
136 136 Clears all the data.
137 137 */
138 138 void QLineSeries::clear()
139 139 {
140 140 m_x.clear();
141 141 m_y.clear();
142 142 }
143 143
144 144 /*!
145 145 \internal \a pos
146 146 */
147 147 qreal QLineSeries::x(int pos) const
148 148 {
149 149 return m_x.at(pos);
150 150 }
151 151
152 152 /*!
153 153 \internal \a pos
154 154 */
155 155 qreal QLineSeries::y(int pos) const
156 156 {
157 157 return m_y.at(pos);
158 158 }
159 159
160 160 /*!
161 161 Returns number of data points within series.
162 162 */
163 163 int QLineSeries::count() const
164 164 {
165 165 Q_ASSERT(m_x.size() == m_y.size());
166 166
167 167 return m_x.size();
168 168
169 169 }
170 170
171 171 /*!
172 172 Sets \a pen used for drawing given series..
173 173 */
174 174 void QLineSeries::setPen(const QPen& pen)
175 175 {
176 176 m_pen=pen;
177 177 }
178 178
179 179 /*!
180 180 Sets if data points are \a visible and should be drawn on line.
181 181 */
182 182 void QLineSeries::setPointsVisible(bool visible)
183 183 {
184 184 m_pointsVisible=visible;
185 185 }
186 186
187 187 QDebug operator<< (QDebug debug, const QLineSeries series)
188 188 {
189 189 Q_ASSERT(series.m_x.size() == series.m_y.size());
190 190
191 191 int size = series.m_x.size();
192 192
193 193 for (int i=0;i<size;i++) {
194 194 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
195 195 }
196 196 return debug.space();
197 197 }
198 198
199 199 /*!
200 200 Stream operator for adding a data \a point to the series.
201 201 \sa add()
202 202 */
203 203
204 204 QLineSeries& QLineSeries::operator<< (const QPointF &point)
205 205 {
206 206 add(point);
207 207 return *this;
208 208 }
209 209
210 210
211 211 #include "moc_qlineseries.cpp"
212 212
213 213 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,56 +1,56
1 1 #ifndef QLINESERIES_H_
2 2 #define QLINESERIES_H_
3 3
4 4 #include "qchartglobal.h"
5 5 #include "qseries.h"
6 6 #include <QDebug>
7 7 #include <QPen>
8 8 #include <QBrush>
9 9
10 10 QTCOMMERCIALCHART_BEGIN_NAMESPACE
11 11
12 12 class QTCOMMERCIALCHART_EXPORT QLineSeries : public QSeries
13 13 {
14 14 Q_OBJECT
15 15 public:
16 16 QLineSeries(QObject* parent=0);
17 17 virtual ~QLineSeries();
18 18
19 19 public: // from QChartSeries
20 20 virtual QSeriesType type() const { return QSeries::SeriesTypeLine;}
21 21 void add(qreal x, qreal y);
22 22 void add(const QPointF& point);
23 23 void replace(qreal x,qreal y);
24 24 void replace(const QPointF& point);
25 25 void remove(qreal x);
26 26 void remove(const QPointF& point);
27 27 void clear();
28 28
29 29 void setPen(const QPen& pen);
30 30 QPen pen() const { return m_pen;}
31 31
32 32 void setPointsVisible(bool visible);
33 33 bool pointsVisible() const {return m_pointsVisible;}
34 34
35 35 int count() const;
36 36 qreal x(int pos) const;
37 37 qreal y(int pos) const;
38 38
39 39 QLineSeries& operator << (const QPointF &point);
40 40 friend QDebug operator<< (QDebug d, const QLineSeries series);
41 41
42 42 signals:
43 void pointChanged(int index);
43 void pointReplaced(int index);
44 44 void pointRemoved(int index);
45 45 void pointAdded(int index);
46 46
47 47 private:
48 48 QVector<qreal> m_x;
49 49 QVector<qreal> m_y;
50 50 QPen m_pen;
51 51 bool m_pointsVisible;
52 52 };
53 53
54 54 QTCOMMERCIALCHART_END_NAMESPACE
55 55
56 56 #endif
General Comments 0
You need to be logged in to leave comments. Login now