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

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

Rename axisLabelsChanged to axisRangeChanged
Michal Klocek -
r399:91816cf9fc5c
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,340 +1,340
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 61 }
62 62
63 63 void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
64 64 {
65 65 Q_UNUSED(painter);
66 66 Q_UNUSED(option);
67 67 Q_UNUSED(widget);
68 68 }
69 69
70 70 void AxisItem::updateItems(QVector<qreal>& oldLayout,QVector<qreal>& newLayout)
71 71 {
72 72 if(newLayout.count()==0) return;
73 73 applyLayout(newLayout);
74 74 oldLayout=newLayout;
75 75 }
76 76
77 77 void AxisItem::handleAxisUpdate(QChartAxis* axis)
78 78 {
79 79 if(m_layoutVector.count()==0) return;
80 80
81 81 if(axis->isAxisVisible()) {
82 82 setAxisOpacity(100);
83 83 }
84 84 else {
85 85 setAxisOpacity(0);
86 86 }
87 87
88 88 if(axis->isGridVisible()) {
89 89 setGridOpacity(100);
90 90 }
91 91 else {
92 92 setGridOpacity(0);
93 93 }
94 94
95 95 if(axis->labelsVisible())
96 96 {
97 97 setLabelsOpacity(100);
98 98 }
99 99 else {
100 100 setLabelsOpacity(0);
101 101 }
102 102
103 103 if(axis->shadesVisible()) {
104 104 setShadesOpacity(axis->shadesOpacity());
105 105 }
106 106 else {
107 107 setShadesOpacity(0);
108 108 }
109 109
110 110 setLabelsAngle(axis->labelsAngle());
111 111 setAxisPen(axis->axisPen());
112 112 setLabelsPen(axis->labelsPen());
113 113 setLabelsBrush(axis->labelsBrush());
114 114 setLabelsFont(axis->labelsFont());
115 115 setGridPen(axis->gridPen());
116 116 setShadesPen(axis->shadesPen());
117 117 setShadesBrush(axis->shadesBrush());
118 118 }
119 119
120 void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
120 void AxisItem::handleRangeChanged(QChartAxis* axis,const QStringList& labels)
121 121 {
122 122 int diff = m_thicksList.size() - labels.size();
123 123
124 124 if(diff>0){
125 125 clear(diff);
126 126 }else if(diff<0){
127 127 createItems(-diff);
128 128 }
129 129 m_thicksList=labels;
130 130 QVector<qreal> vector = calculateLayout();
131 131 updateItems(m_layoutVector,vector);
132 132 if(diff!=0) handleAxisUpdate(axis);
133 133 }
134 134
135 135 void AxisItem::handleGeometryChanged(const QRectF& rect)
136 136 {
137 137 m_rect = rect;
138 138
139 139 if(m_thicksList.size()==0) return;
140 140
141 141 QVector<qreal> vector = calculateLayout();
142 142 updateItems(m_layoutVector,vector);
143 143 }
144 144
145 145 void AxisItem::setAxisOpacity(qreal opacity)
146 146 {
147 147 m_axis.setOpacity(opacity);
148 148 }
149 149
150 150 qreal AxisItem::axisOpacity() const
151 151 {
152 152 return m_axis.opacity();
153 153 }
154 154
155 155 void AxisItem::setGridOpacity(qreal opacity)
156 156 {
157 157 m_grid.setOpacity(opacity);
158 158 }
159 159
160 160 qreal AxisItem::gridOpacity() const
161 161 {
162 162 return m_grid.opacity();
163 163 }
164 164
165 165 void AxisItem::setLabelsOpacity(qreal opacity)
166 166 {
167 167 m_labels.setOpacity(opacity);
168 168 }
169 169
170 170 qreal AxisItem::labelsOpacity() const
171 171 {
172 172 return m_labels.opacity();
173 173 }
174 174
175 175 void AxisItem::setShadesOpacity(qreal opacity)
176 176 {
177 177 m_shades.setOpacity(opacity);
178 178 }
179 179
180 180 qreal AxisItem::shadesOpacity() const
181 181 {
182 182 return m_shades.opacity();
183 183 }
184 184
185 185 void AxisItem::setLabelsAngle(int angle)
186 186 {
187 187 foreach(QGraphicsItem* item , m_labels.childItems()) {
188 188 QPointF center = item->boundingRect().center();
189 189 item->setRotation(angle);
190 190 }
191 191
192 192 m_labelsAngle=angle;
193 193 }
194 194
195 195 void AxisItem::setLabelsPen(const QPen& pen)
196 196 {
197 197 foreach(QGraphicsItem* item , m_labels.childItems()) {
198 198 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
199 199 }
200 200 }
201 201
202 202 void AxisItem::setLabelsBrush(const QBrush& brush)
203 203 {
204 204 foreach(QGraphicsItem* item , m_labels.childItems()) {
205 205 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
206 206 }
207 207 }
208 208
209 209 void AxisItem::setLabelsFont(const QFont& font)
210 210 {
211 211 foreach(QGraphicsItem* item , m_labels.childItems()) {
212 212 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
213 213 }
214 214 }
215 215
216 216 void AxisItem::setShadesBrush(const QBrush& brush)
217 217 {
218 218 foreach(QGraphicsItem* item , m_shades.childItems()) {
219 219 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
220 220 }
221 221 }
222 222
223 223 void AxisItem::setShadesPen(const QPen& pen)
224 224 {
225 225 foreach(QGraphicsItem* item , m_shades.childItems()) {
226 226 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
227 227 }
228 228 }
229 229
230 230 void AxisItem::setAxisPen(const QPen& pen)
231 231 {
232 232 foreach(QGraphicsItem* item , m_axis.childItems()) {
233 233 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
234 234 }
235 235 }
236 236
237 237 void AxisItem::setGridPen(const QPen& pen)
238 238 {
239 239 foreach(QGraphicsItem* item , m_grid.childItems()) {
240 240 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
241 241 }
242 242 }
243 243
244 244 QVector<qreal> AxisItem::calculateLayout() const
245 245 {
246 246 QVector<qreal> points;
247 247 points.resize(m_thicksList.size());
248 248
249 249 switch (m_type)
250 250 {
251 251 case X_AXIS:
252 252 {
253 253 const qreal deltaX = m_rect.width()/(m_thicksList.size()-1);
254 254 for (int i = 0; i < m_thicksList.size(); ++i) {
255 255 int x = i * deltaX + m_rect.left();
256 256 points[i] = x;
257 257 }
258 258 }
259 259 break;
260 260 case Y_AXIS:
261 261 {
262 262 const qreal deltaY = m_rect.height()/(m_thicksList.size()-1);
263 263 for (int i = 0; i < m_thicksList.size(); ++i) {
264 264 int y = i * -deltaY + m_rect.bottom();
265 265 points[i] = y;
266 266 }
267 267 }
268 268 break;
269 269 }
270 270 return points;
271 271 }
272 272
273 273 void AxisItem::applyLayout(const QVector<qreal>& points)
274 274 {
275 275 Q_ASSERT(points.size() == m_thicksList.size());
276 276
277 277 QList<QGraphicsItem *> lines = m_grid.childItems();
278 278 QList<QGraphicsItem *> labels = m_labels.childItems();
279 279 QList<QGraphicsItem *> shades = m_shades.childItems();
280 280 QList<QGraphicsItem *> axis = m_axis.childItems();
281 281
282 282 Q_ASSERT(labels.size() == m_thicksList.size());
283 283
284 284 switch (m_type)
285 285 {
286 286 case X_AXIS:
287 287 {
288 288 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
289 289 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
290 290
291 291 for (int i = 0; i < points.size(); ++i) {
292 292 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
293 293 lineItem->setLine(points[i], m_rect.top(), points[i], m_rect.bottom());
294 294 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
295 295 labelItem->setText(m_thicksList.at(i));
296 296 QPointF center = labelItem->boundingRect().center();
297 297 labelItem->setTransformOriginPoint(center.x(), center.y());
298 298 labelItem->setPos(points[i] - center.x(), m_rect.bottom() + label_padding);
299 299 if(i%2){
300 300 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
301 301 rectItem->setRect(points[i],m_rect.top(),points[i+1]-points[i],m_rect.height());
302 302 }
303 303 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
304 304 lineItem->setLine(points[i],m_rect.bottom(),points[i],m_rect.bottom()+5);
305 305 }
306 306 }
307 307 break;
308 308
309 309 case Y_AXIS:
310 310 {
311 311 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
312 312 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
313 313
314 314 for (int i = 0; i < points.size(); ++i) {
315 315 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
316 316 lineItem->setLine(m_rect.left() , points[i], m_rect.right(), points[i]);
317 317 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
318 318 labelItem->setText(m_thicksList.at(i));
319 319 QPointF center = labelItem->boundingRect().center();
320 320 labelItem->setTransformOriginPoint(center.x(), center.y());
321 321 labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , points[i]-center.y());
322 322 if(i%2){
323 323 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
324 324 rectItem->setRect(m_rect.left(),points[i],m_rect.width(),points[i]-points[i+1]);
325 325 }
326 326 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
327 327 lineItem->setLine(m_rect.left()-5,points[i],m_rect.left(),points[i]);
328 328 }
329 329 }
330 330 break;
331 331 default:
332 332 qDebug()<<"Unknown axis type";
333 333 break;
334 334 }
335 335 }
336 336
337 337 //TODO "nice numbers algorithm"
338 338 #include "moc_axisitem_p.cpp"
339 339
340 340 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,79 +1,79
1 1 #ifndef AXISITEM_H_
2 2 #define AXISITEM_H_
3 3
4 4 #include "domain_p.h"
5 5 #include "chartitem_p.h"
6 6 #include <QGraphicsItem>
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class QChartAxis;
11 11
12 12 class AxisItem : public QObject, public ChartItem
13 13 {
14 14 Q_OBJECT
15 15 public:
16 16 enum AxisType{X_AXIS,Y_AXIS};
17 17
18 18 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
19 19 ~AxisItem();
20 20
21 21 //from QGraphicsItem
22 22 QRectF boundingRect() const;
23 23 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
24 24
25 25 AxisType axisType() const {return m_type;};
26 26
27 27 void setAxisOpacity(qreal opacity);
28 28 qreal axisOpacity() const;
29 29
30 30 void setGridOpacity(qreal opacity);
31 31 qreal gridOpacity() const;
32 32
33 33 void setLabelsOpacity(qreal opacity);
34 34 qreal labelsOpacity() const;
35 35
36 36 void setShadesOpacity(qreal opacity);
37 37 qreal shadesOpacity() const;
38 38
39 39 void setLabelsAngle(int angle);
40 40 int labelsAngle()const { return m_labelsAngle; }
41 41
42 42 void setShadesBrush(const QBrush& brush);
43 43 void setShadesPen(const QPen& pen);
44 44
45 45 void setAxisPen(const QPen& pen);
46 46 void setGridPen(const QPen& pen);
47 47
48 48 void setLabelsPen(const QPen& pen);
49 49 void setLabelsBrush(const QBrush& brush);
50 50 void setLabelsFont(const QFont& font);
51 51
52 52 public slots:
53 53 void handleAxisUpdate(QChartAxis* axis); //look and feel
54 void handleLabelsChanged(QChartAxis* axis,const QStringList& labels); //labels from dataset
54 void handleRangeChanged(QChartAxis* axis,const QStringList& labels); //labels from dataset
55 55 void handleGeometryChanged(const QRectF& size); // geometry from presenter
56 56 public:
57 57 virtual void updateItems(QVector<qreal>& oldLayout,QVector<qreal>& newLayout);
58 58 QVector<qreal> calculateLayout() const;
59 59 void applyLayout(const QVector<qreal>& points);
60 60
61 61 private:
62 62 void clear(int count);
63 63 void createItems(int count);
64 64 private:
65 65 AxisType m_type;
66 66 QRectF m_rect;
67 67 int m_labelsAngle;
68 68 QGraphicsItemGroup m_grid;
69 69 QGraphicsItemGroup m_shades;
70 70 QGraphicsItemGroup m_labels;
71 71 QGraphicsItemGroup m_axis;
72 72 QStringList m_thicksList;
73 73 QVector<qreal> m_layoutVector;
74 74
75 75 };
76 76
77 77 QTCOMMERCIALCHART_END_NAMESPACE
78 78
79 79 #endif /* AXISITEM_H_ */
Show file before | Show file after | Hide comments
@@ -1,358 +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 153 QStringList ylabels = createLabels(axisY,domain.m_minY,domain.m_maxY);
154 154 QStringList xlabels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
155 emit axisLabelsChanged(axisY,ylabels);
156 emit axisLabelsChanged(axisX(),xlabels);
155 emit axisRangeChanged(axisY,ylabels);
156 emit axisRangeChanged(axisX(),xlabels);
157 157 emit seriesAdded(series);
158 158 emit seriesDomainChanged(series,domain);
159 159
160 160 }
161 161
162 162 void ChartDataSet::removeSeries(QSeries* series)
163 163 {
164 164 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
165 165 foreach(QChartAxis* axis , keys) {
166 166 if(m_seriesMap.contains(axis,series)){
167 167 emit seriesRemoved(series);
168 168 m_seriesMap.remove(axis,series);
169 169 //remove axis if no longer there
170 170 if(!m_seriesMap.contains(axis)){
171 171 emit axisRemoved(axis);
172 172 m_domainMap.remove(axis);
173 173 if(axis != m_axisY)
174 174 delete axis;
175 175 }
176 176 series->setParent(0);
177 177 break;
178 178 }
179 179 }
180 180 }
181 181
182 182 void ChartDataSet::removeAllSeries()
183 183 {
184 184 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
185 185 foreach(QChartAxis* axis , keys) {
186 186 QList<QSeries*> seriesList = m_seriesMap.values(axis);
187 187 for(int i =0 ; i < seriesList.size();i++ )
188 188 {
189 189 emit seriesRemoved(seriesList.at(i));
190 190 delete(seriesList.at(i));
191 191 }
192 192 m_seriesMap.remove(axis);
193 193 m_domainMap.remove(axis);
194 194 emit axisRemoved(axis);
195 195 if(axis != m_axisY) delete axis;
196 196 }
197 197 m_domainIndex=0;
198 198 }
199 199
200 200 bool ChartDataSet::nextDomain()
201 201 {
202 202 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
203 203
204 204 if (m_domainIndex < limit) {
205 205 m_domainIndex++;
206 206 setDomain(m_domainIndex);
207 207 return true;
208 208 }
209 209 else {
210 210 return false;
211 211 }
212 212 }
213 213
214 214 bool ChartDataSet::previousDomain()
215 215 {
216 216 if (m_domainIndex > 0) {
217 217 m_domainIndex--;
218 218 setDomain(m_domainIndex);
219 219 return true;
220 220 }
221 221 else {
222 222 return false;
223 223 }
224 224 }
225 225
226 226 void ChartDataSet::setDomain(int index)
227 227 {
228 228 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
229 229
230 230 if(domainList.count()==0) return;
231 231
232 232 Domain domain;
233 233
234 234 foreach (QChartAxis* axis , domainList) {
235 235 int i = m_domainMap.count(axis) - index -1;
236 236 Q_ASSERT(i>=0);
237 237 domain = m_domainMap.values(axis).at(i);
238 238 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
239 239 QList<QSeries*> seriesList = m_seriesMap.values(axis);
240 240 foreach(QSeries* series, seriesList) {
241 241 emit seriesDomainChanged(series,domain);
242 242 }
243 emit axisLabelsChanged(axis,labels);
243 emit axisRangeChanged(axis,labels);
244 244 }
245 245
246 246 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
247 emit axisLabelsChanged(axisX(),labels);
247 emit axisRangeChanged(axisX(),labels);
248 248 }
249 249
250 250 void ChartDataSet::clearDomains(int toIndex)
251 251 {
252 252 Q_ASSERT(toIndex>=0);
253 253
254 254 m_domainIndex = toIndex;
255 255
256 256 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
257 257
258 258 foreach (QChartAxis* key , keys)
259 259 {
260 260 QList<Domain> domains = m_domainMap.values(key);
261 261 m_domainMap.remove(key);
262 262 int i = domains.size() - toIndex - 1;
263 263 while(i--){
264 264 domains.removeFirst();
265 265 }
266 266 for(int j=domains.size()-1; j>=0 ;j--)
267 267 m_domainMap.insert(key,domains.at(j));
268 268 }
269 269 }
270 270
271 271 void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
272 272 {
273 273 Q_ASSERT(rect.isValid());
274 274 Q_ASSERT(viewport.isValid());
275 275
276 276 clearDomains(m_domainIndex);
277 277
278 278 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
279 279
280 280 Domain domain;
281 281
282 282 foreach (QChartAxis* axis , domainList){
283 283 domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
284 284 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
285 285 QList<QSeries*> seriesList = m_seriesMap.values(axis);
286 286 foreach(QSeries* series, seriesList){
287 287 emit seriesDomainChanged(series,domain);
288 288 }
289 emit axisLabelsChanged(axis,labels);
289 emit axisRangeChanged(axis,labels);
290 290 m_domainMap.insert(axis,domain);
291 291 }
292 292
293 293 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
294 emit axisLabelsChanged(axisX(),labels);
294 emit axisRangeChanged(axisX(),labels);
295 295
296 296 m_domainIndex++;
297 297 }
298 298
299 299 QChartAxis* ChartDataSet::axisY(QSeries* series) const
300 300 {
301 301 if(series == 0) return m_axisY;
302 302
303 303 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
304 304
305 305 foreach(QChartAxis* axis , keys) {
306 306 if(m_seriesMap.contains(axis,series)){
307 307 return axis;
308 308 }
309 309 }
310 310 return 0;
311 311 }
312 312
313 313 QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
314 314 {
315 315 Q_ASSERT(max>=min);
316 316
317 317 QStringList labels;
318 318
319 319 int ticks = axis->ticksCount()-1;
320 320
321 321 for(int i=0; i<= ticks; i++){
322 322 qreal value = min + (i * (max - min)/ ticks);
323 323 QString label = axis->axisTickLabel(value);
324 324 if(label.isEmpty()){
325 325 labels << QString::number(value);
326 326 }else{
327 327 labels << label;
328 328 }
329 329 }
330 330 return labels;
331 331 }
332 332
333 333
334 334 void ChartDataSet::handleMinChanged(qreal min)
335 335 {
336 336
337 337 }
338 338
339 339 void ChartDataSet::handleMaxChanged(qreal max)
340 340 {
341 341
342 342 }
343 343
344 344 void ChartDataSet::handleTickChanged(QChartAxis* axis)
345 345 {
346 346 Domain domain = m_domainMap.value(axisY());
347 347 if(axis==axisX()){
348 348 QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
349 emit axisLabelsChanged(axis,labels);
349 emit axisRangeChanged(axis,labels);
350 350 }else{
351 351 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
352 emit axisLabelsChanged(axis,labels);
352 emit axisRangeChanged(axis,labels);
353 353 }
354 354 }
355 355
356 356 #include "moc_chartdataset_p.cpp"
357 357
358 358 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,60 +1,60
1 1 #ifndef CHARTDATASET_P_H_
2 2 #define CHARTDATASET_P_H_
3 3
4 4 #include "qseries.h"
5 5 #include "domain_p.h"
6 6 #include <QVector>
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class QChartAxis;
11 11
12 12 class ChartDataSet : public QObject
13 13 {
14 14 Q_OBJECT
15 15 public:
16 16 ChartDataSet(QObject* parent=0);
17 17 virtual ~ChartDataSet();
18 18
19 19 void addSeries(QSeries* series,QChartAxis *axisY = 0);
20 20 void removeSeries(QSeries* series);
21 21 void removeAllSeries();
22 22 void addDomain(const QRectF& rect, const QRectF& viewport);
23 23 bool nextDomain();
24 24 bool previousDomain();
25 25 void clearDomains(int toIndex =0);
26 26 const Domain domain(QChartAxis *axisY) const;
27 27 int domainIndex() const {return m_domainIndex;}
28 28 void setDomain(int index);
29 29
30 30 QChartAxis* axisX() const { return m_axisX;};
31 31 QChartAxis* axisY(QSeries* series = 0) const;
32 32
33 33 signals:
34 34 void seriesAdded(QSeries* series);
35 35 void seriesRemoved(QSeries* series);
36 36 void axisAdded(QChartAxis* axis);
37 37 void axisRemoved(QChartAxis* axis);
38 void axisLabelsChanged(QChartAxis* axis, const QStringList& labels);
38 void axisRangeChanged(QChartAxis* axis, const QStringList& labels);
39 39 void seriesDomainChanged(QSeries* series,const Domain& domain);
40 40
41 41 private slots:
42 42 void handleMinChanged(qreal min);
43 43 void handleMaxChanged(qreal max);
44 44 void handleTickChanged(QChartAxis*);
45 45
46 46 private:
47 47 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
48 48
49 49 private:
50 50 QMultiMap<QChartAxis*, Domain> m_domainMap;
51 51 QMultiMap<QChartAxis*, QSeries*> m_seriesMap;
52 52 QChartAxis* m_axisX;
53 53 QChartAxis* m_axisY;
54 54 int m_domainIndex;
55 55 bool m_axisXInitialized;
56 56 };
57 57
58 58 QTCOMMERCIALCHART_END_NAMESPACE
59 59
60 60 #endif /* CHARTENGINE_P_H_ */
Show file before | Show file after | Hide comments
@@ -1,287 +1,287
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 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
51 QObject::connect(m_dataset,SIGNAL(axisRangeChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisRangeChanged(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 121 QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
122 122 QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
123 123 QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
124 124 QObject::connect(lineSeries,SIGNAL(updated()),item,SLOT(handleUpdated()));
125 125 m_chartItems.insert(series,item);
126 126 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
127 127 item->handleUpdated();
128 128 break;
129 129 }
130 130
131 131 case QSeries::SeriesTypeBar: {
132 132 QBarSeries* barSeries = static_cast<QBarSeries*>(series);
133 133 BarPresenter* item = new BarPresenter(barSeries,m_chart);
134 134 m_chartTheme->decorate(item,barSeries,m_chartItems.count());
135 135 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
136 136 QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
137 137 m_chartItems.insert(series,item);
138 138 // m_axisXItem->setVisible(false);
139 139 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
140 140 break;
141 141 }
142 142
143 143 case QSeries::SeriesTypeStackedBar: {
144 144
145 145 QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
146 146 StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
147 147 m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
148 148 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
149 149 QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
150 150 m_chartItems.insert(series,item);
151 151 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
152 152 break;
153 153 }
154 154
155 155 case QSeries::SeriesTypePercentBar: {
156 156
157 157 QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
158 158 PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
159 159 m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
160 160 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
161 161 QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
162 162 m_chartItems.insert(series,item);
163 163 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
164 164 break;
165 165 }
166 166 case QSeries::SeriesTypeScatter: {
167 167 QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
168 168 ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
169 169 QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
170 170 scatterSeries, SIGNAL(clicked(QPointF)));
171 171 QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
172 172 scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
173 173 m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
174 174 m_chartItems.insert(scatterSeries, scatterPresenter);
175 175 if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
176 176 break;
177 177 }
178 178 case QSeries::SeriesTypePie: {
179 179 QPieSeries *s = qobject_cast<QPieSeries *>(series);
180 180 PiePresenter* pie = new PiePresenter(m_chart, s);
181 181 m_chartTheme->decorate(pie, s, m_chartItems.count());
182 182 QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
183 183
184 184 // Hide all from background when there is only piechart
185 185 // TODO: refactor this ugly code... should be one setting for this
186 186 if (m_chartItems.count() == 0) {
187 187 m_chart->axisX()->setAxisVisible(false);
188 188 m_chart->axisY()->setAxisVisible(false);
189 189 m_chart->axisX()->setGridVisible(false);
190 190 m_chart->axisY()->setGridVisible(false);
191 191 m_chart->axisX()->setLabelsVisible(false);
192 192 m_chart->axisY()->setLabelsVisible(false);
193 193 m_chart->axisX()->setShadesVisible(false);
194 194 m_chart->axisY()->setShadesVisible(false);
195 195 m_chart->setChartBackgroundBrush(Qt::transparent);
196 196 }
197 197
198 198 m_chartItems.insert(series, pie);
199 199 pie->handleGeometryChanged(m_rect);
200 200 break;
201 201 }
202 202 default: {
203 203 qDebug()<< "Series type" << series->type() << "not implemented.";
204 204 break;
205 205 }
206 206 }
207 207 }
208 208
209 209 void ChartPresenter::handleSeriesRemoved(QSeries* series)
210 210 {
211 211 ChartItem* item = m_chartItems.take(series);
212 212 delete item;
213 213 }
214 214
215 215 void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
216 216 {
217 217 m_chartItems.value(series)->handleDomainChanged(domain);
218 218 }
219 219
220 void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
220 void ChartPresenter::handleAxisRangeChanged(QChartAxis* axis,const QStringList& labels)
221 221 {
222 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
222 m_axisItems.value(axis)->handleRangeChanged(axis,labels);
223 223 }
224 224
225 225 void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
226 226 {
227 227 delete m_chartTheme;
228 228
229 229 m_chartTheme = ChartTheme::createTheme(theme);
230 230
231 231 m_chartTheme->decorate(m_chart);
232 232 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
233 233
234 234 int index=0;
235 235 while (i.hasNext()) {
236 236 i.next();
237 237 m_chartTheme->decorate(i.value(),i.key(),index);
238 238 index++;
239 239 }
240 240
241 241 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
242 242 while (j.hasNext()) {
243 243 j.next();
244 244 m_chartTheme->decorate(j.key(),j.value());
245 245 }
246 246 }
247 247
248 248 QChart::ChartTheme ChartPresenter::chartTheme()
249 249 {
250 250 return m_chartTheme->id();
251 251 }
252 252
253 253 void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
254 254 {
255 255 if(m_options!=options) {
256 256
257 257 m_options=options;
258 258
259 259 //recreate elements
260 260
261 261 QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
262 262 QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
263 263
264 264 foreach(QChartAxis* axis, axisList) {
265 265 handleAxisRemoved(axis);
266 266 handleAxisAdded(axis);
267 267 }
268 268 foreach(QSeries* series, seriesList) {
269 269 handleSeriesRemoved(series);
270 270 handleSeriesAdded(series);
271 271 }
272 272
273 273 //now reintialize view data
274 274 //TODO: make it more nice
275 275 m_dataset->setDomain(m_dataset->domainIndex());
276 276 }
277 277 }
278 278
279 279 QChart::AnimationOptions ChartPresenter::animationOptions() const
280 280 {
281 281 return m_options;
282 282 }
283 283
284 284
285 285 #include "moc_chartpresenter_p.cpp"
286 286
287 287 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,73 +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 void handleAxisLabelsChanged(QChartAxis* axis, const QStringList& labels);
55 void handleAxisRangeChanged(QChartAxis* axis, const QStringList& labels);
56 56 void handleGeometryChanged();
57 57 signals:
58 58 void geometryChanged(const QRectF& rect);
59 59 private:
60 60 QMap<QSeries*,ChartItem*> m_chartItems;
61 61 QMap<QChartAxis*,AxisItem*> m_axisItems;
62 62 QChart* m_chart;
63 63 ChartDataSet* m_dataset;
64 64 ChartTheme *m_chartTheme;
65 65 int m_marginSize;
66 66 QRectF m_rect;
67 67 QChart::AnimationOptions m_options;
68 68
69 69 };
70 70
71 71 QTCOMMERCIALCHART_END_NAMESPACE
72 72
73 73 #endif /* CHARTPRESENTER_H_ */
Show file before | Show file after | Hide comments
@@ -1,598 +1,598
1 1 #include <QtTest/QtTest>
2 2 #include <qchartaxis.h>
3 3 #include <qlineseries.h>
4 4 #include <private/chartdataset_p.h>
5 5 #include <private/domain_p.h>
6 6
7 7 QTCOMMERCIALCHART_USE_NAMESPACE
8 8
9 9 Q_DECLARE_METATYPE(Domain)
10 10 Q_DECLARE_METATYPE(QChartAxis*)
11 11 Q_DECLARE_METATYPE(QSeries*)
12 12 Q_DECLARE_METATYPE(QLineSeries*)
13 13
14 14 class tst_ChartDataSet: public QObject {
15 15 Q_OBJECT
16 16
17 17 public slots:
18 18 void initTestCase();
19 19 void cleanupTestCase();
20 20 void init();
21 21 void cleanup();
22 22
23 23 private slots:
24 24 void chartdataset_data();
25 25 void chartdataset();
26 26
27 27 void addDomain_data();
28 28 void addDomain();
29 29 void addSeries_data();
30 30 void addSeries();
31 31 void axisY_data();
32 32 void axisY();
33 33 void clearDomains_data();
34 34 void clearDomains();
35 35 void domain_data();
36 36 void domain();
37 37 void nextpreviousDomain_data();
38 38 void nextpreviousDomain();
39 39 void removeSeries_data();
40 40 void removeSeries();
41 41 void removeAllSeries_data();
42 42 void removeAllSeries();
43 43 };
44 44
45 45 void tst_ChartDataSet::initTestCase()
46 46 {
47 47 qRegisterMetaType<Domain>("Domain");
48 48 qRegisterMetaType<QChartAxis*>();
49 49 qRegisterMetaType<QSeries*>();
50 50 }
51 51
52 52 void tst_ChartDataSet::cleanupTestCase()
53 53 {
54 54 }
55 55
56 56 void tst_ChartDataSet::init()
57 57 {
58 58 }
59 59
60 60 void tst_ChartDataSet::cleanup()
61 61 {
62 62 }
63 63
64 64 void tst_ChartDataSet::chartdataset_data()
65 65 {
66 66 }
67 67
68 68 void tst_ChartDataSet::chartdataset()
69 69 {
70 70 ChartDataSet dataSet;
71 71 QVERIFY2(dataSet.axisX(), "Missing axisX.");
72 72 QVERIFY2(dataSet.axisY(), "Missing axisY.");
73 73 //check if not dangling pointer
74 74 dataSet.axisX()->objectName();
75 75 dataSet.axisY()->objectName();
76 76 QVERIFY(dataSet.domain(dataSet.axisX())==Domain());
77 77 QVERIFY(dataSet.domain(dataSet.axisY())==Domain());
78 78 QCOMPARE(dataSet.domainIndex(), 0);
79 79 }
80 80
81 81 void tst_ChartDataSet::addDomain_data()
82 82 {
83 83 QTest::addColumn<QRectF>("rect");
84 84 QTest::addColumn<QRectF>("viewport");
85 85 QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
86 86 << QRectF(0, 0, 1000, 1000);
87 87 QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
88 88 << QRectF(0, 0, 1000, 1000);
89 89 QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
90 90 << QRectF(0, 0, 1000, 1000);
91 91 }
92 92
93 93 void tst_ChartDataSet::addDomain()
94 94 {
95 95 QFETCH(QRectF, rect);
96 96 QFETCH(QRectF, viewport);
97 97
98 98 ChartDataSet dataSet;
99 99
100 100 Domain domain1(0, 1000, 0, 1000);
101 101 QLineSeries series;
102 102 series.add(0, 0);
103 103 series.add(1000, 1000);
104 104
105 105 dataSet.addSeries(&series);
106 106
107 107 QCOMPARE(dataSet.domainIndex(), 0);
108 108
109 109 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
110 110 QSignalSpy spy1(&dataSet,
111 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
111 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
112 112 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
113 113 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
114 114 QSignalSpy spy4(&dataSet,
115 115 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
116 116 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
117 117
118 118 Domain domain2 = dataSet.domain(dataSet.axisY());
119 119 QVERIFY(domain1 == domain2);
120 120
121 121 dataSet.addDomain(rect, viewport);
122 122 QCOMPARE(dataSet.domainIndex(), 1);
123 123 Domain domain3 = dataSet.domain(dataSet.axisY());
124 124 Domain domain4 = domain1.subDomain(rect, viewport.width(),
125 125 viewport.height());
126 126 QVERIFY(domain3 == domain4);
127 127
128 128 QCOMPARE(spy0.count(), 0);
129 129 QCOMPARE(spy1.count(), 2);
130 130 QCOMPARE(spy2.count(), 0);
131 131 QCOMPARE(spy3.count(), 0);
132 132 QCOMPARE(spy4.count(), 1);
133 133 QCOMPARE(spy5.count(), 0);
134 134 }
135 135
136 136 void tst_ChartDataSet::addSeries_data()
137 137 {
138 138 QTest::addColumn<int>("seriesCount");
139 139 QTest::addColumn<int>("axisYCount");
140 140 QTest::newRow("2 series, default axis") << 2 << 0;
141 141 QTest::newRow("2 series, 2 new axis") << 2 << 2;
142 142 QTest::newRow("2 series, 1 new axis") << 2 << 2;
143 143 QTest::newRow("3 series, 3 new axis") << 3 << 3;
144 144 QTest::newRow("3 series, 2 new axis") << 3 << 2;
145 145 QTest::newRow("3 series, 1 new axis") << 3 << 1;
146 146 }
147 147
148 148 void tst_ChartDataSet::addSeries()
149 149 {
150 150 QFETCH(int, seriesCount);
151 151 QFETCH(int, axisYCount);
152 152
153 153 ChartDataSet dataSet;
154 154
155 155 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
156 156 QSignalSpy spy1(&dataSet,
157 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
157 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
158 158 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
159 159 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
160 160 QSignalSpy spy4(&dataSet,
161 161 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
162 162 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
163 163
164 164 QList<QChartAxis*> axisList;
165 165
166 166 for (int i = 0; i < axisYCount; i++) {
167 167 QChartAxis* axis = new QChartAxis();
168 168 axisList << axis;
169 169 }
170 170
171 171 QList<QChartAxis*>::iterator iterator = axisList.begin();
172 172
173 173 for (int i = 0; i < seriesCount; i++) {
174 174 QChartAxis* axisY = 0;
175 175 QLineSeries* series = new QLineSeries();
176 176 if (iterator != axisList.end()) {
177 177 axisY = *iterator;
178 178 iterator++;
179 179 } else if (axisList.count() > 0) {
180 180 iterator--;
181 181 axisY = *iterator;
182 182 iterator++;
183 183 }
184 184 dataSet.addSeries(series, axisY);
185 185 }
186 186
187 187 //default axis
188 188 if (axisYCount == 0)
189 189 axisYCount+=2;
190 190 else
191 191 axisYCount++;
192 192
193 193 QCOMPARE(spy0.count(), axisYCount);
194 194 QCOMPARE(spy1.count(), seriesCount*2);
195 195 QCOMPARE(spy2.count(), 0);
196 196 QCOMPARE(spy3.count(), seriesCount);
197 197 QCOMPARE(spy4.count(), seriesCount);
198 198 QCOMPARE(spy5.count(), 0);
199 199
200 200 QCOMPARE(dataSet.domainIndex(), 0);
201 201 }
202 202
203 203 void tst_ChartDataSet::axisY_data()
204 204 {
205 205 QTest::addColumn<QChartAxis*>("axisY");
206 206 QTest::newRow("axisY1") << new QChartAxis();
207 207 QTest::newRow("axisY2") << new QChartAxis();
208 208 }
209 209
210 210 void tst_ChartDataSet::axisY()
211 211 {
212 212 QFETCH(QChartAxis*, axisY);
213 213
214 214 ChartDataSet dataSet;
215 215
216 216 QChartAxis* defaultAxisY = dataSet.axisY();
217 217
218 218 QVERIFY2(defaultAxisY, "Missing axisY.");
219 219
220 220 QLineSeries* series1 = new QLineSeries();
221 221 dataSet.addSeries(series1);
222 222
223 223 QLineSeries* series2 = new QLineSeries();
224 224 dataSet.addSeries(series2, axisY);
225 225
226 226 QVERIFY(dataSet.axisY(series1) == defaultAxisY);
227 227 QVERIFY(dataSet.axisY(series2) == axisY);
228 228
229 229
230 230 }
231 231
232 232 void tst_ChartDataSet::clearDomains_data()
233 233 {
234 234 QTest::addColumn<int>("indexCount");
235 235 QTest::newRow("0") << 0;
236 236 QTest::newRow("1") << 1;
237 237 QTest::newRow("5") << 2;
238 238 QTest::newRow("8") << 3;
239 239 }
240 240
241 241 void tst_ChartDataSet::clearDomains()
242 242 {
243 243 QFETCH(int, indexCount);
244 244
245 245 Domain domain1(0, 100, 0, 100);
246 246 QLineSeries* series = new QLineSeries();
247 247 series->add(0, 0);
248 248 series->add(100, 100);
249 249
250 250 ChartDataSet dataSet;
251 251
252 252 QCOMPARE(dataSet.domainIndex(), 0);
253 253
254 254 dataSet.addSeries(series);
255 255
256 256 Domain domain2 = dataSet.domain(dataSet.axisY());
257 257
258 258 QVERIFY(domain2 == domain1);
259 259
260 260 QList<Domain> domains;
261 261
262 262 domains << domain1;
263 263
264 264 for (int i = 0; i < indexCount; i++) {
265 265 dataSet.addDomain(QRect(0, 0, 10, 10), QRect(0, 0, 100, 100));
266 266 domains << dataSet.domain(dataSet.axisY());
267 267 }
268 268
269 269 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
270 270 QSignalSpy spy1(&dataSet,
271 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
271 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
272 272 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
273 273 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
274 274 QSignalSpy spy4(&dataSet,
275 275 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
276 276 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
277 277
278 278 dataSet.clearDomains(indexCount);
279 279
280 280 QCOMPARE(dataSet.domainIndex(), indexCount);
281 281
282 282 domain2 = dataSet.domain(dataSet.axisY());
283 283
284 284 QVERIFY(domain2 == domains.at(indexCount));
285 285
286 286 QCOMPARE(spy0.count(), 0);
287 287 QCOMPARE(spy1.count(), 0);
288 288 QCOMPARE(spy2.count(), 0);
289 289 QCOMPARE(spy3.count(), 0);
290 290 QCOMPARE(spy4.count(), 0);
291 291 QCOMPARE(spy5.count(), 0);
292 292 }
293 293
294 294 void tst_ChartDataSet::domain_data()
295 295 {
296 296 QTest::addColumn<Domain>("domain1");
297 297 QTest::addColumn<Domain>("domain2");
298 298 QTest::addColumn<Domain>("domain3");
299 299 QTest::addColumn<Domain>("domain");
300 300 QTest::newRow("Domain(0,10,0,10)") << Domain(0, 10, 0, 10)
301 301 << Domain(0, 5, 0, 5) << Domain(0, 3, 0, 3) << Domain(0, 10, 0, 10);
302 302 QTest::newRow("Domain(-1,11,0,11)") << Domain(-1, 10, 0, 10)
303 303 << Domain(0, 11, 0, 11) << Domain(0, 3, 0, 3)
304 304 << Domain(-1, 11, 0, 11);
305 305 QTest::newRow("Domain(-5,5,1,8)") << Domain(-5, 0, 1, 1)
306 306 << Domain(0, 5, 0, 8) << Domain(1, 2, 1, 2) << Domain(-5, 5, 0, 8);
307 307 }
308 308
309 309 void tst_ChartDataSet::domain()
310 310 {
311 311 QFETCH(Domain, domain1);
312 312 QFETCH(Domain, domain2);
313 313 QFETCH(Domain, domain3);
314 314 QFETCH(Domain, domain);
315 315
316 316 ChartDataSet dataSet;
317 317 QLineSeries* series1 = new QLineSeries();
318 318 series1->add(domain1.m_minX, domain1.m_minY);
319 319 series1->add(domain1.m_maxX, domain1.m_maxY);
320 320 QLineSeries* series2 = new QLineSeries();
321 321 series2->add(domain2.m_minX, domain2.m_minY);
322 322 series2->add(domain2.m_maxX, domain2.m_maxY);
323 323 QLineSeries* series3 = new QLineSeries();
324 324 series3->add(domain3.m_minX, domain3.m_minY);
325 325 series3->add(domain3.m_maxX, domain3.m_maxY);
326 326
327 327 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
328 328 QSignalSpy spy1(&dataSet,
329 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
329 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
330 330 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
331 331 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
332 332 QSignalSpy spy4(&dataSet,
333 333 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
334 334 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
335 335
336 336 dataSet.addSeries(series1);
337 337 dataSet.addSeries(series2);
338 338 dataSet.addSeries(series3);
339 339
340 340 QCOMPARE(dataSet.domainIndex(), 0);
341 341 QVERIFY2(dataSet.domain(dataSet.axisY()) == domain, "Domain not equal");
342 342
343 343 QCOMPARE(spy0.count(), 2);
344 344 QCOMPARE(spy1.count(), 6);
345 345 QCOMPARE(spy2.count(), 0);
346 346 QCOMPARE(spy3.count(), 3);
347 347 QCOMPARE(spy4.count(), 3);
348 348 QCOMPARE(spy5.count(), 0);
349 349 }
350 350
351 351 void tst_ChartDataSet::nextpreviousDomain_data()
352 352 {
353 353 QTest::addColumn<QRectF>("rect");
354 354 QTest::addColumn<QRectF>("viewport");
355 355 QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
356 356 << QRectF(0, 0, 1000, 1000);
357 357 QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
358 358 << QRectF(0, 0, 1000, 1000);
359 359 QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
360 360 << QRectF(0, 0, 1000, 1000);
361 361 }
362 362
363 363 void tst_ChartDataSet::nextpreviousDomain()
364 364 {
365 365
366 366 QFETCH(QRectF, rect);
367 367 QFETCH(QRectF, viewport);
368 368
369 369 ChartDataSet dataSet;
370 370
371 371 Domain domain1(0, 1000, 0, 1000);
372 372 QLineSeries* series = new QLineSeries();
373 373 series->add(0, 0);
374 374 series->add(1000, 1000);
375 375
376 376 dataSet.addSeries(series);
377 377
378 378 QCOMPARE(dataSet.domainIndex(), 0);
379 379
380 380 Domain domain2 = dataSet.domain(dataSet.axisY());
381 381 QVERIFY(domain1 == domain2);
382 382
383 383 dataSet.addDomain(rect, viewport);
384 384 QCOMPARE(dataSet.domainIndex(), 1);
385 385 Domain domain3 = dataSet.domain(dataSet.axisY());
386 386 Domain domain4 = domain1.subDomain(rect, viewport.width(),
387 387 viewport.height());
388 388 QVERIFY(domain3 == domain4);
389 389
390 390 dataSet.addDomain(rect, viewport);
391 391 QCOMPARE(dataSet.domainIndex(), 2);
392 392 Domain domain5 = dataSet.domain(dataSet.axisY());
393 393 Domain domain6 = domain3.subDomain(rect, viewport.width(),
394 394 viewport.height());
395 395 QVERIFY(domain5 == domain6);
396 396
397 397 dataSet.addDomain(rect, viewport);
398 398 QCOMPARE(dataSet.domainIndex(), 3);
399 399 Domain domain7 = dataSet.domain(dataSet.axisY());
400 400 Domain domain8 = domain5.subDomain(rect, viewport.width(),
401 401 viewport.height());
402 402 QVERIFY(domain7 == domain8);
403 403
404 404 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
405 405 QSignalSpy spy1(&dataSet,
406 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
406 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
407 407 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
408 408 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
409 409 QSignalSpy spy4(&dataSet,
410 410 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
411 411 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
412 412
413 413 Domain domain;
414 414
415 415 bool previous = dataSet.previousDomain();
416 416 QCOMPARE(previous, true);
417 417 QCOMPARE(dataSet.domainIndex(), 2);
418 418 domain = dataSet.domain(dataSet.axisY());
419 419 QVERIFY(domain == domain5);
420 420 previous = dataSet.previousDomain();
421 421 QCOMPARE(previous, true);
422 422 QCOMPARE(dataSet.domainIndex(), 1);
423 423 domain = dataSet.domain(dataSet.axisY());
424 424 QVERIFY(domain == domain3);
425 425 previous = dataSet.previousDomain();
426 426 QCOMPARE(previous, true);
427 427 QCOMPARE(dataSet.domainIndex(), 0);
428 428 domain = dataSet.domain(dataSet.axisY());
429 429 QVERIFY(domain == domain1);
430 430 previous = dataSet.previousDomain();
431 431 QCOMPARE(previous, false);
432 432 QCOMPARE(dataSet.domainIndex(), 0);
433 433 domain = dataSet.domain(dataSet.axisY());
434 434 QVERIFY(domain == domain1);
435 435
436 436 bool next = dataSet.nextDomain();
437 437 QCOMPARE(next, true);
438 438 QCOMPARE(dataSet.domainIndex(),1);
439 439 next = dataSet.nextDomain();
440 440 QCOMPARE(next, true);
441 441 QCOMPARE(dataSet.domainIndex(),2);
442 442 next = dataSet.nextDomain();
443 443 QCOMPARE(next, true);
444 444 QCOMPARE(dataSet.domainIndex(),3);
445 445 next = dataSet.nextDomain();
446 446 QCOMPARE(next, false);
447 447 QCOMPARE(dataSet.domainIndex(),3);
448 448
449 449
450 450 QCOMPARE(spy0.count(), 0);
451 451 QCOMPARE(spy1.count(), 12);
452 452 QCOMPARE(spy2.count(), 0);
453 453 QCOMPARE(spy3.count(), 0);
454 454 QCOMPARE(spy4.count(), 6);
455 455 QCOMPARE(spy5.count(), 0);
456 456 }
457 457
458 458 void tst_ChartDataSet::removeSeries_data()
459 459 {
460 460 QTest::addColumn<int>("seriesCount");
461 461 QTest::addColumn<int>("axisYCount");
462 462 QTest::newRow("2 series, default axis") << 2 << 0;
463 463 QTest::newRow("2 series, 2 new axis") << 2 << 2;
464 464 QTest::newRow("2 series, 1 new axis") << 2 << 2;
465 465 QTest::newRow("3 series, 3 new axis") << 3 << 3;
466 466 QTest::newRow("3 series, 2 new axis") << 3 << 2;
467 467 QTest::newRow("3 series, 1 new axis") << 3 << 1;
468 468 }
469 469
470 470 void tst_ChartDataSet::removeSeries()
471 471 {
472 472 QFETCH(int, seriesCount);
473 473 QFETCH(int, axisYCount);
474 474
475 475 ChartDataSet dataSet;
476 476
477 477 QList<QChartAxis*> axisList;
478 478 QList<QSeries*> seriesList;
479 479
480 480 for (int i = 0; i < axisYCount; i++) {
481 481 QChartAxis* axis = new QChartAxis();
482 482 axisList << axis;
483 483 }
484 484
485 485 QList<QChartAxis*>::iterator iterator = axisList.begin();
486 486
487 487 for (int i = 0; i < seriesCount; i++) {
488 488 QChartAxis* axisY = 0;
489 489 QLineSeries* series = new QLineSeries();
490 490 if (iterator != axisList.end()) {
491 491 axisY = *iterator;
492 492 iterator++;
493 493 } else if (axisList.count() > 0) {
494 494 iterator--;
495 495 axisY = *iterator;
496 496 iterator++;
497 497 }
498 498 dataSet.addSeries(series, axisY);
499 499 seriesList << series;
500 500 }
501 501
502 502 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
503 503 QSignalSpy spy1(&dataSet,
504 SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
504 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
505 505 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
506 506 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
507 507 QSignalSpy spy4(&dataSet,
508 508 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
509 509 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
510 510
511 511 for (int i = 0; i < seriesCount; i++) {
512 512 dataSet.removeSeries(seriesList.at(i));
513 513 }
514 514
515 515 //default axis
516 516 if (axisYCount == 0)
517 517 axisYCount++;
518 518
519 519 QCOMPARE(spy0.count(), 0);
520 520 QCOMPARE(spy1.count(), 0);
521 521 QCOMPARE(spy2.count(), axisYCount);
522 522 QCOMPARE(spy3.count(), 0);
523 523 QCOMPARE(spy4.count(), 0);
524 524 QCOMPARE(spy5.count(), seriesCount);
525 525
526 526 QCOMPARE(dataSet.domainIndex(), 0);
527 527
528 528 qDeleteAll(seriesList);
529 529 }
530 530
531 531 void tst_ChartDataSet::removeAllSeries_data()
532 532 {
533 533 QTest::addColumn<int>("seriesCount");
534 534 QTest::addColumn<int>("axisYCount");
535 535 QTest::newRow("2 series, default axis") << 2 << 0;
536 536 QTest::newRow("2 series, 2 new axis") << 2 << 2;
537 537 QTest::newRow("2 series, 1 new axis") << 2 << 2;
538 538 QTest::newRow("3 series, 3 new axis") << 3 << 3;
539 539 QTest::newRow("3 series, 2 new axis") << 3 << 2;
540 540 QTest::newRow("3 series, 1 new axis") << 3 << 1;
541 541 }
542 542
543 543 void tst_ChartDataSet::removeAllSeries()
544 544 {
545 545 QFETCH(int, seriesCount);
546 546 QFETCH(int, axisYCount);
547 547
548 548 ChartDataSet dataSet;
549 549
550 550 QList<QChartAxis*> axisList;
551 551
552 552 for (int i = 0; i < axisYCount; i++) {
553 553 QChartAxis* axis = new QChartAxis();
554 554 axisList << axis;
555 555 }
556 556
557 557 QList<QChartAxis*>::iterator iterator = axisList.begin();
558 558
559 559 for (int i = 0; i < seriesCount; i++) {
560 560 QChartAxis* axisY = 0;
561 561 QLineSeries* series = new QLineSeries();
562 562 if (iterator != axisList.end()) {
563 563 axisY = *iterator;
564 564 iterator++;
565 565 } else if (axisList.count() > 0) {
566 566 iterator--;
567 567 axisY = *iterator;
568 568 iterator++;
569 569 }
570 570 dataSet.addSeries(series, axisY);
571 571 }
572 572
573 573 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
574 QSignalSpy spy1(&dataSet, SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
574 QSignalSpy spy1(&dataSet, SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
575 575 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
576 576 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
577 577 QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
578 578 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
579 579
580 580 dataSet.removeAllSeries();
581 581 //default axis
582 582 if (axisYCount == 0)
583 583 axisYCount++;
584 584
585 585 QCOMPARE(spy0.count(), 0);
586 586 QCOMPARE(spy1.count(), 0);
587 587 QCOMPARE(spy2.count(), axisYCount);
588 588 QCOMPARE(spy3.count(), 0);
589 589 QCOMPARE(spy4.count(), 0);
590 590 QCOMPARE(spy5.count(), seriesCount);
591 591
592 592 QCOMPARE(dataSet.domainIndex(), 0);
593 593 }
594 594
595 595
596 596 QTEST_MAIN(tst_ChartDataSet)
597 597 #include "tst_chartdataset.moc"
598 598
General Comments 0
You need to be logged in to leave comments. Login now