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

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

QChart mapping functions: return QPoint(0, 0) if series type is Pie...
Marek Rosa -
r2351:bd26609a29ae
parent child
Show More
Side by Side Unified
Context file:
r2351:bd26609a29ae Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,5
1 !include( ../auto.pri ) {
2 error( "Couldn't find the auto.pri file!" )
3 }
4 HEADERS += ../qabstractaxis/tst_qabstractaxis.h
5 SOURCES += tst_qlogvalueaxis.cpp ../qabstractaxis/tst_qabstractaxis.cpp
Show file before | Show file after | Hide comments
@@ -0,0 +1,378
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
21 #include "../qabstractaxis/tst_qabstractaxis.h"
22 #include "qlogvalueaxis.h"
23 #include <qlineseries.h>
24 #include <QDebug>
25
26 class tst_QLogValueAxis: public tst_QAbstractAxis
27 {
28 Q_OBJECT
29
30 public slots:
31 void initTestCase();
32 void cleanupTestCase();
33 void init();
34 void cleanup();
35
36 private slots:
37 // void qlogvalueaxis_data();
38 // void qlogvalueaxis();
39 // void max_raw_data();
40 // void max_raw();
41 // void max_data();
42 // void max();
43 // void max_animation_data();
44 // void max_animation();
45 void min_raw_data();
46 void min_raw();
47 void min_data();
48 void min();
49 void min_animation_data();
50 void min_animation();
51 // void range_raw_data();
52 // void range_raw();
53 // void range_data();
54 // void range();
55 // void range_animation_data();
56 // void range_animation();
57 // void noautoscale_data();
58 // void noautoscale();
59 // void autoscale_data();
60 // void autoscale();
61 void zoomIn();
62 // void zoomOut();
63
64 private:
65 QLogValueAxis* m_logvaluesaxis;
66 QLineSeries* m_series;
67 };
68
69 void tst_QLogValueAxis::initTestCase()
70 {
71 }
72
73 void tst_QLogValueAxis::cleanupTestCase()
74 {
75 }
76
77 void tst_QLogValueAxis::init()
78 {
79 m_logvaluesaxis = new QLogValueAxis();
80 m_series = new QLineSeries();
81 *m_series << QPointF(1, 1) << QPointF(100, 100);
82 tst_QAbstractAxis::init(m_logvaluesaxis,m_series);
83 m_chart->addSeries(m_series);
84 m_chart->createDefaultAxes();
85 }
86
87 void tst_QLogValueAxis::cleanup()
88 {
89 delete m_series;
90 delete m_logvaluesaxis;
91 m_series = 0;
92 m_logvaluesaxis = 0;
93 tst_QAbstractAxis::cleanup();
94 }
95
96 //void tst_QLogValueAxis::qlogvalueaxis_data()
97 //{
98 //}
99
100 //void tst_QLogValueAxis::qlogvalueaxis()
101 //{
102 // qabstractaxis();
103
104 // QVERIFY(qFuzzyCompare(m_logvaluesaxis->max(), 1));
105 // QVERIFY(qFuzzyCompare(m_logvaluesaxis->min(), 1));
106 // QCOMPARE(m_logvaluesaxis->type(), QAbstractAxis::AxisTypeLogValue);
107
108 // m_chart->setAxisX(m_logvaluesaxis, m_series);
109 // m_view->show();
110 // QTest::qWaitForWindowShown(m_view);
111
112 // QVERIFY(!qFuzzyCompare(m_logvaluesaxis->max(), 100));
113 // QVERIFY(!qFuzzyCompare(m_logvaluesaxis->min(), 0.1));
114 //}
115
116 //void tst_QLogValueAxis::max_raw_data()
117 //{
118 // QTest::addColumn<qreal>("max");
119 // QTest::addColumn<qreal>("expected");
120 // QTest::addColumn<bool>("minChanged");
121 // QTest::addColumn<bool>("maxChanged");
122 // QTest::newRow("-1.0") << (qreal)-1.0 << (qreal)1.0 << false << false;
123 // QTest::newRow("0.0") << (qreal)0.0 << (qreal)1.0 << false << false;
124 // QTest::newRow("0.5") << (qreal)0.5 << (qreal)0.5 << true << true;
125 // QTest::newRow("101.0") << (qreal)101.0 << (qreal)101.0 << false << true;
126 //}
127
128 //void tst_QLogValueAxis::max_raw()
129 //{
130 // QFETCH(qreal, max);
131 // QFETCH(qreal, expected);
132 // QFETCH(bool, minChanged);
133 // QFETCH(bool, maxChanged);
134
135 // QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
136 // QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
137 // QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
138
139 // m_logvaluesaxis->setMax(max);
140 // QCOMPARE(m_logvaluesaxis->max(), expected);
141
142 // QCOMPARE(spy0.count(), (int)maxChanged);
143 // QCOMPARE(spy1.count(), (int)minChanged);
144 // QCOMPARE(spy2.count(), (int)maxChanged);
145
146 //}
147
148 //void tst_QLogValueAxis::max_data()
149 //{
150 // max_raw_data();
151 //}
152
153 //void tst_QLogValueAxis::max()
154 //{
155 // m_chart->setAxisX(m_logvaluesaxis, m_series);
156 // m_view->show();
157 // QTest::qWaitForWindowShown(m_view);
158 // max_raw();
159 //}
160
161 //void tst_QLogValueAxis::max_animation_data()
162 //{
163 // max_data();
164 //}
165
166 //void tst_QLogValueAxis::max_animation()
167 //{
168 // m_chart->setAnimationOptions(QChart::GridAxisAnimations);
169 // max();
170 //}
171
172 void tst_QLogValueAxis::min_raw_data()
173 {
174 QTest::addColumn<qreal>("min");
175 QTest::addColumn<qreal>("expected");
176 QTest::addColumn<bool>("minChanged");
177 QTest::addColumn<bool>("maxChanged");
178 QTest::newRow("-1.0") << (qreal)-1.0 << (qreal)1.0 << false << false;
179 QTest::newRow("0.0") << (qreal)0.0 << (qreal)1.0 << false << false;
180 QTest::newRow("0.5") << (qreal)0.5 << (qreal)0.5 << true << false;
181 QTest::newRow("101.0") << (qreal)101.0 << (qreal)101.0 << true << true;
182 }
183
184 void tst_QLogValueAxis::min_raw()
185 {
186 QFETCH(qreal, min);
187 QFETCH(qreal, expected);
188 QFETCH(bool, minChanged);
189 QFETCH(bool, maxChanged);
190
191 QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
192 QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
193 QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
194
195 m_logvaluesaxis->setMin(min);
196 QCOMPARE(m_logvaluesaxis->min(), expected);
197
198 QCOMPARE(spy0.count(), (int)maxChanged);
199 QCOMPARE(spy1.count(), (int)minChanged);
200 QCOMPARE(spy2.count(), (int)minChanged);
201 }
202
203 void tst_QLogValueAxis::min_data()
204 {
205 min_raw_data();
206 }
207
208 void tst_QLogValueAxis::min()
209 {
210 m_chart->setAxisX(m_logvaluesaxis, m_series);
211 m_view->show();
212 QTest::qWaitForWindowShown(m_view);
213 min_raw();
214 }
215
216 void tst_QLogValueAxis::min_animation_data()
217 {
218 min_data();
219 }
220
221 void tst_QLogValueAxis::min_animation()
222 {
223 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
224 min();
225 }
226
227 //void tst_QLogValueAxis::range_raw_data()
228 //{
229 // QTest::addColumn<qreal>("min");
230 // QTest::addColumn<qreal>("max");
231 // QTest::newRow("1.0 - 101.0") << (qreal)1.0 << (qreal)101.0;
232 // QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
233 // QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
234 //}
235
236 //void tst_QLogValueAxis::range_raw()
237 //{
238 // QFETCH(qreal, min);
239 // QFETCH(qreal, max);
240
241 // QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
242 // QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
243 // QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
244
245 // m_logvaluesaxis->setRange(min, max);
246 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->min(), min), "Min not equal");
247 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->max(), max), "Max not equal");
248
249 // QCOMPARE(spy0.count(), 1);
250 // QCOMPARE(spy1.count(), 1);
251 // QCOMPARE(spy2.count(), 1);
252 //}
253
254 //void tst_QLogValueAxis::range_data()
255 //{
256 // range_raw_data();
257 //}
258
259 //void tst_QLogValueAxis::range()
260 //{
261 // m_chart->setAxisX(m_logvaluesaxis, m_series);
262 // m_view->show();
263 // QTest::qWaitForWindowShown(m_view);
264 // range_raw();
265 //}
266
267 //void tst_QLogValueAxis::range_animation_data()
268 //{
269 // range_data();
270 //}
271
272 //void tst_QLogValueAxis::range_animation()
273 //{
274 // m_chart->setAnimationOptions(QChart::GridAxisAnimations);
275 // range();
276 //}
277
278 //void tst_QLogValueAxis::noautoscale_data()
279 //{
280 // QTest::addColumn<qreal>("min");
281 // QTest::addColumn<qreal>("max");
282 // QTest::newRow("1.0 - 101.0") << (qreal)-1.0 << (qreal)101.0;
283 // QTest::newRow("25.0 - 75.0") << (qreal)25.0 << (qreal)75.0;
284 // QTest::newRow("101.0") << (qreal)40.0 << (qreal)60.0;
285 //}
286
287 //void tst_QLogValueAxis::noautoscale()
288 //{
289 // QFETCH(qreal, min);
290 // QFETCH(qreal, max);
291
292 // QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
293 // QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
294 // QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
295
296 // m_logvaluesaxis->setRange(min, max);
297 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->min(), min), "Min not equal");
298 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->max(), max), "Max not equal");
299
300 // QCOMPARE(spy0.count(), 1);
301 // QCOMPARE(spy1.count(), 1);
302 // QCOMPARE(spy2.count(), 1);
303
304 // m_chart->setAxisX(m_logvaluesaxis, m_series);
305 // m_view->show();
306 // QTest::qWaitForWindowShown(m_view);
307 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->min(), min), "Min not equal");
308 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->max(), max), "Max not equal");
309 //}
310
311 //void tst_QLogValueAxis::autoscale_data()
312 //{
313
314 //}
315
316 //void tst_QLogValueAxis::autoscale()
317 //{
318 // QSignalSpy spy0(m_logvaluesaxis, SIGNAL(maxChanged(qreal)));
319 // QSignalSpy spy1(m_logvaluesaxis, SIGNAL(minChanged(qreal)));
320 // QSignalSpy spy2(m_logvaluesaxis, SIGNAL(rangeChanged(qreal,qreal)));
321
322 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->min(), 0), "Min not equal");
323 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->max(), 0), "Max not equal");
324 // m_chart->setAxisX(m_logvaluesaxis, m_series);
325
326 // QCOMPARE(spy0.count(), 1);
327 // QCOMPARE(spy1.count(), 1);
328 // QCOMPARE(spy2.count(), 1);
329
330 // m_view->show();
331 // QTest::qWaitForWindowShown(m_view);
332 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->min(), -100), "Min not equal");
333 // QVERIFY2(qFuzzyCompare(m_logvaluesaxis->max(), 100), "Max not equal");
334 //}
335
336 void tst_QLogValueAxis::zoomIn()
337 {
338 m_chart->setAxisX(m_logvaluesaxis, m_series);
339 m_view->show();
340 QTest::qWaitForWindowShown(m_view);
341 m_logvaluesaxis->setBase(2);
342 m_logvaluesaxis->setRange(0.5, 2);
343
344 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.5);
345 QCOMPARE(m_logvaluesaxis->max(), (qreal)2.0);
346
347 m_chart->zoomOut();
348
349 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.25);
350 QCOMPARE(m_logvaluesaxis->max(), (qreal)4.0);
351
352 m_chart->zoomIn();
353
354 QCOMPARE(m_logvaluesaxis->min(), (qreal)0.5);
355 QCOMPARE(m_logvaluesaxis->max(), (qreal)2.0);
356
357 m_logvaluesaxis->setRange(0.5, 1024);
358 m_chart->zoom(11.0);
359
360 QCOMPARE(m_logvaluesaxis->min(), (qreal)16.0);
361 QCOMPARE(m_logvaluesaxis->max(), (qreal)32.0);
362
363 m_logvaluesaxis->setRange(16, 64);
364 m_chart->zoom(1/3.0);
365
366 QCOMPARE(m_logvaluesaxis->min(), (qreal)4);
367 QCOMPARE(m_logvaluesaxis->max(), (qreal)256.0);
368
369 }
370
371 //void tst_QLogValueAxis::zoomOut()
372 //{
373
374 //}
375
376 QTEST_MAIN(tst_QLogValueAxis)
377 #include "tst_qlogvalueaxis.moc"
378
Show file before | Show file after | Hide comments
@@ -41,7 +41,7 View::View(QWidget *parent)
41 41
42 42 // chart
43 43 m_chart = new QChart;
44 m_chart->setMinimumSize(800, 600);
44 m_chart->setMinimumSize(640, 480);
45 45 m_chart->setTitle("Hover the line to show callout. Click the line to make it stay");
46 46 m_chart->legend()->hide();
47 47 QLineSeries *series = new QLineSeries;
@@ -84,8 +84,12 View::View(QWidget *parent)
84 84
85 85 void View::resizeEvent(QResizeEvent *event)
86 86 {
87 if (scene())
87 if (scene()) {
88 88 scene()->setSceneRect(QRect(QPoint(0, 0), event->size()));
89 m_chart->resize(event->size());
90 m_coordX->setPos(m_chart->size().width()/2 - 50, m_chart->size().height() - 20);
91 m_coordY->setPos(m_chart->size().width()/2 + 50, m_chart->size().height() - 20);
92 }
89 93 QGraphicsView::resizeEvent(event);
90 94 }
91 95
Show file before | Show file after | Hide comments
@@ -391,8 +391,11 QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *serie
391 391 if (series == 0 && !m_seriesList.isEmpty())
392 392 series = m_seriesList.first();
393 393
394 if (series && series->type() == QAbstractSeries::SeriesTypePie)
395 return point;
396
394 397 if (series && m_seriesList.contains(series))
395 point = series->d_ptr->m_domain->calculateDomainPoint(position);
398 point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
396 399 return point;
397 400 }
398 401
@@ -402,6 +405,9 QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *serie
402 405 if (series == 0 && !m_seriesList.isEmpty())
403 406 series = m_seriesList.first();
404 407
408 if (series && series->type() == QAbstractSeries::SeriesTypePie)
409 return QPoint(0, 0);
410
405 411 if (series && m_seriesList.contains(series))
406 412 point += series->d_ptr->m_domain->calculateGeometryPoint(value);
407 413 return point;
Show file before | Show file after | Hide comments
@@ -27,11 +27,11 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 LogXLogYDomain::LogXLogYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 m_logMinX(0),
31 m_logMaxX(1),
30 m_logLeftX(0),
31 m_logRightX(1),
32 32 m_logBaseX(10),
33 m_logMinY(0),
34 m_logMaxY(1),
33 m_logLeftY(0),
34 m_logRightY(1),
35 35 m_logBaseY(10)
36 36 {
37 37 }
@@ -49,8 +49,10 void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
49 49 m_minX = minX;
50 50 m_maxX = maxX;
51 51 axisXChanged = true;
52 m_logMinX = log10(m_minX) / log10(m_logBaseX);
53 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
52 qreal logMinX = log10(m_minX) / log10(m_logBaseX);
53 qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
54 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
55 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
54 56 if(!m_signalsBlocked)
55 57 emit rangeHorizontalChanged(m_minX, m_maxX);
56 58 }
@@ -59,8 +61,10 void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
59 61 m_minY = minY;
60 62 m_maxY = maxY;
61 63 axisYChanged = true;
62 m_logMinY = log10(m_minY) / log10(m_logBaseY);
63 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
64 qreal logMinY = log10(m_minY) / log10(m_logBaseY);
65 qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
66 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
67 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
64 68 if(!m_signalsBlocked)
65 69 emit rangeVerticalChanged(m_minY, m_maxY);
66 70 }
@@ -71,73 +75,82 void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
71 75
72 76 void LogXLogYDomain::zoomIn(const QRectF &rect)
73 77 {
74 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
75 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
76 qreal minX = qPow(m_logBaseX, newLogMinX);
77 qreal maxX = qPow(m_logBaseX, newLogMaxX);
78 qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
79 qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
80 qreal leftX = qPow(m_logBaseX, logLeftX);
81 qreal rightX = qPow(m_logBaseX, logRightX);
82 qreal minX = leftX < rightX ? leftX : rightX;
83 qreal maxX = leftX > rightX ? leftX : rightX;
78 84
79 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
80 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
81 qreal minY = qPow(m_logBaseY, newLogMinY);
82 qreal maxY = qPow(m_logBaseY, newLogMaxY);
85 qreal logLeftY = m_logRightY - rect.bottom() * (m_logRightY - m_logLeftY) / m_size.height();
86 qreal logRightY = m_logRightY - rect.top() * (m_logRightY - m_logLeftY) / m_size.height();
87 qreal leftY = qPow(m_logBaseY, logLeftY);
88 qreal rightY = qPow(m_logBaseY, logRightY);
89 qreal minY = leftY < rightY ? leftY : rightY;
90 qreal maxY = leftY > rightY ? leftY : rightY;
83 91
84 92 setRange(minX, maxX, minY, maxY);
85 93 }
86 94
87 95 void LogXLogYDomain::zoomOut(const QRectF &rect)
88 96 {
89 qreal ratioX = m_size.width()/rect.width();
90 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
91 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
92 qreal minX = qPow(m_logBaseX, newLogMinX);
93 qreal maxX = qPow(m_logBaseX, newLogMaxX);
97 const qreal factorX = m_size.width() / rect.width();
98 const qreal factorY = m_size.height() / rect.height();
94 99
95 qreal ratioY = m_size.height()/rect.height();
96 qreal newLogMinY = m_logMinY - (m_logMaxY - m_logMinY) / ratioY;
97 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
98 qreal minY = qPow(m_logBaseY, newLogMinY);
99 qreal maxY = qPow(m_logBaseY, newLogMaxY);
100 qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 - factorX);
101 qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 + factorX);
102 qreal leftX = qPow(m_logBaseX, logLeftX);
103 qreal rightX = qPow(m_logBaseX, logRIghtX);
104 qreal minX = leftX < rightX ? leftX : rightX;
105 qreal maxX = leftX > rightX ? leftX : rightX;
106
107 qreal newLogMinY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 - factorY);
108 qreal newLogMaxY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 + factorY);
109 qreal leftY = qPow(m_logBaseY, newLogMinY);
110 qreal rightY = qPow(m_logBaseY, newLogMaxY);
111 qreal minY = leftY < rightY ? leftY : rightY;
112 qreal maxY = leftY > rightY ? leftY : rightY;
100 113
101 114 setRange(minX, maxX, minY, maxY);
102 115 }
103 116
104 117 void LogXLogYDomain::move(qreal dx, qreal dy)
105 118 {
106 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
107 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
108 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
119 qreal stepX = dx * qAbs(m_logRightX - m_logLeftX) / m_size.width();
120 qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
121 qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
122 qreal minX = leftX < rightX ? leftX : rightX;
123 qreal maxX = leftX > rightX ? leftX : rightX;
109 124
110 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
111 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
112 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
125 qreal stepY = dy * (m_logRightY - m_logLeftY) / m_size.height();
126 qreal leftY = qPow(m_logBaseY, m_logLeftY + stepY);
127 qreal rightY = qPow(m_logBaseY, m_logRightY + stepY);
128 qreal minY = leftY < rightY ? leftY : rightY;
129 qreal maxY = leftY > rightY ? leftY : rightY;
113 130
114 131 setRange(minX, maxX, minY, maxY);
115 132 }
116 133
117 134 QPointF LogXLogYDomain::calculateGeometryPoint(const QPointF &point) const
118 135 {
119 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
120 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
121 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
122 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
123 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
124 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
136 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
137 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
138 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
139 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
125 140 return QPointF(x, y);
126 141 }
127 142
128 143 QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
129 144 {
130 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
131 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
132 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
133 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
145 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
146 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
134 147
135 148 QVector<QPointF> result;
136 149 result.resize(vector.count());
137 150
138 151 for (int i = 0; i < vector.count(); ++i) {
139 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
140 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
152 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
153 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
141 154 result[i].setX(x);
142 155 result[i].setY(y);
143 156 }
@@ -146,12 +159,10 QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& v
146 159
147 160 QPointF LogXLogYDomain::calculateDomainPoint(const QPointF &point) const
148 161 {
149 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
150 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
151 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
152 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
153 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
154 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
162 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
163 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
164 qreal x = qPow(m_logBaseX, m_logLeftX + point.x() / deltaX);
165 qreal y = qPow(m_logBaseY, m_logLeftY + (m_size.height() - point.y()) / deltaY);
155 166 return QPointF(x, y);
156 167 }
157 168
@@ -190,16 +201,20 bool LogXLogYDomain::detachAxis(QAbstractAxis* axis)
190 201 void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
191 202 {
192 203 m_logBaseY = baseY;
193 m_logMinY = log10(m_minY) / log10(m_logBaseY);
194 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
204 qreal logMinY = log10(m_minY) / log10(m_logBaseY);
205 qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
206 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
207 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
195 208 emit updated();
196 209 }
197 210
198 211 void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
199 212 {
200 213 m_logBaseX = baseX;
201 m_logMinX = log10(m_minX) / log10(m_logBaseX);
202 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
214 qreal logMinX = log10(m_minX) / log10(m_logBaseX);
215 qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
216 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
217 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
203 218 emit updated();
204 219 }
205 220
Show file before | Show file after | Hide comments
@@ -66,11 +66,11 public Q_SLOTS:
66 66 void handleHorizontalAxisBaseChanged(qreal baseX);
67 67
68 68 private:
69 qreal m_logMinX;
70 qreal m_logMaxX;
69 qreal m_logLeftX;
70 qreal m_logRightX;
71 71 qreal m_logBaseX;
72 qreal m_logMinY;
73 qreal m_logMaxY;
72 qreal m_logLeftY;
73 qreal m_logRightY;
74 74 qreal m_logBaseY;
75 75 };
76 76
Show file before | Show file after | Hide comments
@@ -27,8 +27,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 LogXYDomain::LogXYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 m_logMinX(0),
31 m_logMaxX(1),
30 m_logLeftX(0),
31 m_logRightX(1),
32 32 m_logBaseX(10)
33 33 {
34 34 }
@@ -46,8 +46,10 void LogXYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
46 46 m_minX = minX;
47 47 m_maxX = maxX;
48 48 axisXChanged = true;
49 m_logMinX = log10(m_minX) / log10(m_logBaseX);
50 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
49 qreal logMinX = log10(m_minX) / log10(m_logBaseX);
50 qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
51 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
52 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
51 53 if(!m_signalsBlocked)
52 54 emit rangeHorizontalChanged(m_minX, m_maxX);
53 55 }
@@ -66,10 +68,12 void LogXYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
66 68
67 69 void LogXYDomain::zoomIn(const QRectF &rect)
68 70 {
69 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
70 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
71 qreal minX = qPow(m_logBaseX, newLogMinX);
72 qreal maxX = qPow(m_logBaseX, newLogMaxX);
71 qreal logLeftX = rect.left() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
72 qreal logRightX = rect.right() * (m_logRightX - m_logLeftX) / m_size.width() + m_logLeftX;
73 qreal leftX = qPow(m_logBaseX, logLeftX);
74 qreal rightX = qPow(m_logBaseX, logRightX);
75 qreal minX = leftX < rightX ? leftX : rightX;
76 qreal maxX = leftX > rightX ? leftX : rightX;
73 77
74 78 qreal dy = spanY() / m_size.height();
75 79 qreal minY = m_minY;
@@ -83,11 +87,14 void LogXYDomain::zoomIn(const QRectF &rect)
83 87
84 88 void LogXYDomain::zoomOut(const QRectF &rect)
85 89 {
86 qreal ratioX = m_size.width()/rect.width();
87 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
88 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
89 qreal minX = qPow(m_logBaseX, newLogMinX);
90 qreal maxX = qPow(m_logBaseX, newLogMaxX);
90 const qreal factorX = m_size.width() / rect.width();
91
92 qreal logLeftX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 - factorX);
93 qreal logRIghtX = m_logLeftX + (m_logRightX - m_logLeftX) / 2 * (1 + factorX);
94 qreal leftX = qPow(m_logBaseX, logLeftX);
95 qreal rightX = qPow(m_logBaseX, logRIghtX);
96 qreal minX = leftX < rightX ? leftX : rightX;
97 qreal maxX = leftX > rightX ? leftX : rightX;
91 98
92 99 qreal dy = spanY() / rect.height();
93 100 qreal minY = m_minY;
@@ -101,9 +108,11 void LogXYDomain::zoomOut(const QRectF &rect)
101 108
102 109 void LogXYDomain::move(qreal dx, qreal dy)
103 110 {
104 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
105 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
106 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
111 qreal stepX = dx * (m_logRightX - m_logLeftX) / m_size.width();
112 qreal leftX = qPow(m_logBaseX, m_logLeftX + stepX);
113 qreal rightX = qPow(m_logBaseX, m_logRightX + stepX);
114 qreal minX = leftX < rightX ? leftX : rightX;
115 qreal maxX = leftX > rightX ? leftX : rightX;
107 116
108 117 qreal y = spanY() / m_size.height();
109 118 qreal minY = m_minY;
@@ -118,26 +127,24 void LogXYDomain::move(qreal dx, qreal dy)
118 127
119 128 QPointF LogXYDomain::calculateGeometryPoint(const QPointF &point) const
120 129 {
121 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
122 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
130 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
123 131 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
124 132
125 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
133 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
126 134 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
127 135 return QPointF(x, y);
128 136 }
129 137
130 138 QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
131 139 {
132 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
133 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
140 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
134 141 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
135 142
136 143 QVector<QPointF> result;
137 144 result.resize(vector.count());
138 145
139 146 for (int i = 0; i < vector.count(); ++i) {
140 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
147 qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - m_logLeftX * deltaX;
141 148 qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
142 149 result[i].setX(x);
143 150 result[i].setY(y);
@@ -147,10 +154,9 QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vect
147 154
148 155 QPointF LogXYDomain::calculateDomainPoint(const QPointF &point) const
149 156 {
150 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
151 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
157 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
152 158 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
153 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
159 qreal x = qPow(m_logBaseX, m_logLeftX + point.x() / deltaX);
154 160 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
155 161 return QPointF(x, y);
156 162 }
@@ -182,8 +188,10 bool LogXYDomain::detachAxis(QAbstractAxis* axis)
182 188 void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
183 189 {
184 190 m_logBaseX = baseX;
185 m_logMinX = log10(m_minX) / log10(m_logBaseX);
186 m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
191 qreal logMinX = log10(m_minX) / log10(m_logBaseX);
192 qreal logMaxX = log10(m_maxX) / log10(m_logBaseX);
193 m_logLeftX = logMinX < logMaxX ? logMinX : logMaxX;
194 m_logRightX = logMinX > logMaxX ? logMinX : logMaxX;
187 195 emit updated();
188 196 }
189 197
Show file before | Show file after | Hide comments
@@ -65,8 +65,8 public Q_SLOTS:
65 65 void handleHorizontalAxisBaseChanged(qreal baseX);
66 66
67 67 private:
68 qreal m_logMinX;
69 qreal m_logMaxX;
68 qreal m_logLeftX;
69 qreal m_logRightX;
70 70 qreal m_logBaseX;
71 71 };
72 72
Show file before | Show file after | Hide comments
@@ -27,8 +27,8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
27 27
28 28 XLogYDomain::XLogYDomain(QObject *parent)
29 29 : AbstractDomain(parent),
30 m_logMinY(0),
31 m_logMaxY(1),
30 m_logLeftY(0),
31 m_logRightY(1),
32 32 m_logBaseY(10)
33 33 {
34 34 }
@@ -54,8 +54,10 void XLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
54 54 m_minY = minY;
55 55 m_maxY = maxY;
56 56 axisYChanged = true;
57 m_logMinY = log10(m_minY) / log10(m_logBaseY);
58 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
57 qreal logMinY = log10(m_minY) / log10(m_logBaseY);
58 qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
59 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
60 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
59 61 if(!m_signalsBlocked)
60 62 emit rangeVerticalChanged(m_minY, m_maxY);
61 63 }
@@ -73,10 +75,12 void XLogYDomain::zoomIn(const QRectF &rect)
73 75 maxX = minX + dx * rect.right();
74 76 minX = minX + dx * rect.left();
75 77
76 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
77 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
78 qreal minY = qPow(m_logBaseY, newLogMinY);
79 qreal maxY = qPow(m_logBaseY, newLogMaxY);
78 qreal logLeftY = m_logRightY - rect.bottom() * (m_logRightY - m_logLeftY) / m_size.height();
79 qreal logRightY = m_logRightY - rect.top() * (m_logRightY - m_logLeftY) / m_size.height();
80 qreal leftY = qPow(m_logBaseY, logLeftY);
81 qreal rightY = qPow(m_logBaseY, logRightY);
82 qreal minY = leftY < rightY ? leftY : rightY;
83 qreal maxY = leftY > rightY ? leftY : rightY;
80 84
81 85 setRange(minX, maxX, minY, maxY);
82 86 }
@@ -90,11 +94,13 void XLogYDomain::zoomOut(const QRectF &rect)
90 94 minX = maxX - dx * rect.right();
91 95 maxX = minX + dx * m_size.width();
92 96
93 qreal ratioY = m_size.height()/rect.height();
94 qreal newLogMinY = m_logMinY - (m_logMaxY - m_logMinY) / ratioY;
95 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
96 qreal minY = qPow(m_logBaseY, newLogMinY);
97 qreal maxY = qPow(m_logBaseY, newLogMaxY);
97 const qreal factorY = m_size.height() / rect.height();
98 qreal newLogMinY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 - factorY);
99 qreal newLogMaxY = m_logLeftY + (m_logRightY - m_logLeftY) / 2 * (1 + factorY);
100 qreal leftY = qPow(m_logBaseY, newLogMinY);
101 qreal rightY = qPow(m_logBaseY, newLogMaxY);
102 qreal minY = leftY < rightY ? leftY : rightY;
103 qreal maxY = leftY > rightY ? leftY : rightY;
98 104
99 105 setRange(minX, maxX, minY, maxY);
100 106 }
@@ -110,36 +116,36 void XLogYDomain::move(qreal dx, qreal dy)
110 116 maxX = maxX + x * dx;
111 117 }
112 118
113 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
114 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
115 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
119 qreal stepY = dy * (m_logRightY - m_logLeftY) / m_size.height();
120 qreal leftY = qPow(m_logBaseY, m_logLeftY + stepY);
121 qreal rightY = qPow(m_logBaseY, m_logRightY + stepY);
122 qreal minY = leftY < rightY ? leftY : rightY;
123 qreal maxY = leftY > rightY ? leftY : rightY;
116 124
117 125 setRange(minX, maxX, minY, maxY);
118 126 }
119 127
120 128 QPointF XLogYDomain::calculateGeometryPoint(const QPointF &point) const
121 129 {
122 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
123 130 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
124 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
131 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
125 132
126 133 qreal x = (point.x() - m_minX) * deltaX;
127 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
134 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
128 135 return QPointF(x, y);
129 136 }
130 137
131 138 QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
132 139 {
133 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
134 140 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
135 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
141 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
136 142
137 143 QVector<QPointF> result;
138 144 result.resize(vector.count());
139 145
140 146 for (int i = 0; i < vector.count(); ++i) {
141 147 qreal x = (vector[i].x() - m_minX) * deltaX;
142 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
148 qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - m_logLeftY * -deltaY + m_size.height();
143 149 result[i].setX(x);
144 150 result[i].setY(y);
145 151 }
@@ -149,10 +155,9 QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vect
149 155 QPointF XLogYDomain::calculateDomainPoint(const QPointF &point) const
150 156 {
151 157 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
152 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
153 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
158 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);
154 159 qreal x = point.x() / deltaX + m_minX;
155 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
160 qreal y = qPow(m_logBaseY, m_logLeftY + (m_size.height() - point.y()) / deltaY);
156 161 return QPointF(x, y);
157 162 }
158 163
@@ -180,8 +185,10 bool XLogYDomain::detachAxis(QAbstractAxis* axis)
180 185 void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
181 186 {
182 187 m_logBaseY = baseY;
183 m_logMinY = log10(m_minY) / log10(m_logBaseY);
184 m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
188 qreal logMinY = log10(m_minY) / log10(m_logBaseY);
189 qreal logMaxY = log10(m_maxY) / log10(m_logBaseY);
190 m_logLeftY = logMinY < logMaxY ? logMinY : logMaxY;
191 m_logRightY = logMinY > logMaxY ? logMinY : logMaxY;
185 192 emit updated();
186 193 }
187 194
Show file before | Show file after | Hide comments
@@ -65,8 +65,8 public Q_SLOTS:
65 65 void handleVerticalAxisBaseChanged(qreal baseY);
66 66
67 67 private:
68 qreal m_logMinY;
69 qreal m_logMaxY;
68 qreal m_logLeftY;
69 qreal m_logRightY;
70 70 qreal m_logBaseY;
71 71 };
72 72
Show file before | Show file after | Hide comments
@@ -21,6 +21,7 SUBDIRS += \
21 21 qhorizontalstackedbarseries \
22 22 qhorizontalpercentbarseries \
23 23 qvalueaxis \
24 qlogvalueaxis \
24 25 qcategoryaxis \
25 26 qbarcategoryaxis \
26 27 domain \
General Comments 0
You need to be logged in to leave comments. Login now