@@ -61,15 +61,13 Rectangle { | |||
|
61 | 61 | if (currentIndex < speedsXml.count) { |
|
62 | 62 | // Check if there is a series for the data already (we are using driver name to identify series) |
|
63 | 63 | var lineSeries = chartView.series(speedsXml.get(currentIndex).driver); |
|
64 | if (!lineSeries) | |
|
64 | if (!lineSeries){ | |
|
65 | 65 | lineSeries = chartView.createSeries(ChartView.SeriesTypeLine, speedsXml.get(currentIndex).driver); |
|
66 | ||
|
67 | if (currentIndex < 3) { | |
|
68 | 66 | chartView.createDefaultAxes(); |
|
69 | 67 | chartView.axisY(lineSeries).min = 0; |
|
70 | 68 | chartView.axisY(lineSeries).max = 250 |
|
71 | 69 | } |
|
72 | ||
|
70 | ||
|
73 | 71 | lineSeries.append(currentIndex, speedsXml.get(currentIndex).speed); |
|
74 | 72 | |
|
75 | 73 | // Make the x-axis range dynamic |
@@ -70,7 +70,6 int main(int argc, char *argv[]) | |||
|
70 | 70 | categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun"; |
|
71 | 71 | QBarCategoriesAxis* axis = new QBarCategoriesAxis(); |
|
72 | 72 | axis->append(categories); |
|
73 | chart->createDefaultAxes(); | |
|
74 | 73 | chart->setAxisY(axis,series); |
|
75 | 74 | //![4] |
|
76 | 75 |
@@ -380,23 +380,14 QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend) | |||
|
380 | 380 | } |
|
381 | 381 | |
|
382 | 382 | |
|
383 |
void QAreaSeriesPrivate::initializeAxis |
|
|
383 | void QAreaSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |
|
384 | 384 | { |
|
385 | 385 | Q_UNUSED(axis); |
|
386 | 386 | } |
|
387 | 387 | |
|
388 | void QAreaSeriesPrivate::initializeAxisY(QAbstractAxis* axis) | |
|
389 | { | |
|
390 | Q_UNUSED(axis); | |
|
391 | } | |
|
392 | ||
|
393 | QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisXType() const | |
|
394 | { | |
|
395 | return QAbstractAxis::AxisTypeValues; | |
|
396 | } | |
|
397 | ||
|
398 | QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisYType() const | |
|
388 | QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
399 | 389 | { |
|
390 | Q_UNUSED(orientation); | |
|
400 | 391 | return QAbstractAxis::AxisTypeValues; |
|
401 | 392 | } |
|
402 | 393 |
@@ -46,10 +46,8 public: | |||
|
46 | 46 | void scaleDomain(Domain& domain); |
|
47 | 47 | Chart* createGraphics(ChartPresenter* presenter); |
|
48 | 48 | QList<LegendMarker*> createLegendMarker(QLegend* legend); |
|
49 |
void initializeAxis |
|
|
50 | void initializeAxisY(QAbstractAxis* axis); | |
|
51 | QAbstractAxis::AxisType defaultAxisXType() const; | |
|
52 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
49 | void initializeAxis(QAbstractAxis* axis); | |
|
50 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
53 | 51 | |
|
54 | 52 | Q_SIGNALS: |
|
55 | 53 | void updated(); |
@@ -597,6 +597,12 void QAbstractAxis::setRange(const QVariant &min, const QVariant &max) | |||
|
597 | 597 | d_ptr->setRange(min,max); |
|
598 | 598 | } |
|
599 | 599 | |
|
600 | ||
|
601 | Qt::Orientation QAbstractAxis::orientation() | |
|
602 | { | |
|
603 | return d_ptr->m_orientation; | |
|
604 | } | |
|
605 | ||
|
600 | 606 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
601 | 607 | |
|
602 | 608 | QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q): |
@@ -108,6 +108,8 public: | |||
|
108 | 108 | void setShadesBorderColor(QColor color); |
|
109 | 109 | QColor shadesBorderColor() const; |
|
110 | 110 | |
|
111 | Qt::Orientation orientation(); | |
|
112 | ||
|
111 | 113 | //range handling |
|
112 | 114 | void setMin(const QVariant &min); |
|
113 | 115 | void setMax(const QVariant &max); |
@@ -51,7 +51,7 Q_SIGNALS: | |||
|
51 | 51 | public: |
|
52 | 52 | virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0; |
|
53 | 53 | virtual void emitRange() = 0; |
|
54 |
virtual void in |
|
|
54 | virtual void intializeDomain(Domain* domain) = 0; | |
|
55 | 55 | |
|
56 | 56 | protected: |
|
57 | 57 | virtual void setMin(const QVariant &min) = 0; |
@@ -421,7 +421,7 void QBarCategoriesAxisPrivate::emitRange() | |||
|
421 | 421 | emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false); |
|
422 | 422 | } |
|
423 | 423 | |
|
424 |
void QBarCategoriesAxisPrivate::in |
|
|
424 | void QBarCategoriesAxisPrivate::intializeDomain(Domain* domain) | |
|
425 | 425 | { |
|
426 | 426 | Q_UNUSED(domain); |
|
427 | 427 | // TODO: this causes crash now. added to known issues. |
@@ -47,7 +47,7 public: | |||
|
47 | 47 | |
|
48 | 48 | public: |
|
49 | 49 | ChartAxis* createGraphics(ChartPresenter* presenter); |
|
50 |
void in |
|
|
50 | void intializeDomain(Domain* domain); | |
|
51 | 51 | void emitRange(); |
|
52 | 52 | |
|
53 | 53 | private: |
@@ -171,7 +171,6 qreal QValuesAxis::max() const | |||
|
171 | 171 | void QValuesAxis::setRange(qreal min, qreal max) |
|
172 | 172 | { |
|
173 | 173 | Q_D(QValuesAxis); |
|
174 | ||
|
175 | 174 | bool changed = false; |
|
176 | 175 | if (!qFuzzyIsNull(d->m_min - min)) { |
|
177 | 176 | d->m_min = min; |
@@ -306,13 +305,17 void QValuesAxisPrivate::emitRange() | |||
|
306 | 305 | emit changed(m_min, m_max, m_ticksCount, m_niceNumbers); |
|
307 | 306 | } |
|
308 | 307 | |
|
309 |
void QValuesAxisPrivate::in |
|
|
308 | void QValuesAxisPrivate::intializeDomain(Domain* domain) | |
|
310 | 309 | { |
|
311 | 310 | if(qFuzzyCompare(m_max,m_min)) { |
|
312 | 311 | if(m_orientation==Qt::Vertical){ |
|
313 | handleAxisRangeChanged(domain->minY(),domain->maxY(),domain->tickXCount()); | |
|
312 | m_min = domain->minY(); | |
|
313 | m_max = domain->maxY(); | |
|
314 | m_ticksCount = domain->tickYCount(); | |
|
314 | 315 | }else{ |
|
315 | handleAxisRangeChanged(domain->minX(),domain->maxX(),domain->tickYCount()); | |
|
316 | m_min = domain->minX(); | |
|
317 | m_max = domain->maxX(); | |
|
318 | m_ticksCount = domain->tickXCount(); | |
|
316 | 319 | } |
|
317 | 320 | } |
|
318 | 321 | } |
@@ -50,7 +50,7 public Q_SLOTS: | |||
|
50 | 50 | |
|
51 | 51 | public: |
|
52 | 52 | ChartAxis* createGraphics(ChartPresenter* presenter); |
|
53 |
void in |
|
|
53 | void intializeDomain(Domain* domain); | |
|
54 | 54 | void emitRange(); |
|
55 | 55 | |
|
56 | 56 | protected: |
@@ -702,9 +702,9 bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set) | |||
|
702 | 702 | return true; |
|
703 | 703 | } |
|
704 | 704 | |
|
705 |
void QAbstractBarSeriesPrivate::initializeAxis |
|
|
705 | void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |
|
706 | 706 | { |
|
707 | if(axis->type()==QAbstractAxis::AxisTypeCategories) | |
|
707 | if(axis->type()==QAbstractAxis::AxisTypeCategories && axis->orientation()==Qt::Horizontal) | |
|
708 | 708 | { |
|
709 | 709 | QBarCategoriesAxis* cataxis = qobject_cast<QBarCategoriesAxis*>(axis); |
|
710 | 710 | Q_ASSERT(cataxis); |
@@ -715,20 +715,12 void QAbstractBarSeriesPrivate::initializeAxisX(QAbstractAxis* axis) | |||
|
715 | 715 | } |
|
716 | 716 | } |
|
717 | 717 | |
|
718 | void QAbstractBarSeriesPrivate::initializeAxisY(QAbstractAxis* axis) | |
|
719 | { | |
|
720 | Q_UNUSED(axis) | |
|
721 | } | |
|
722 | ||
|
723 | QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisXType() const | |
|
718 | QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
724 | 719 | { |
|
720 | Q_UNUSED(orientation); | |
|
725 | 721 | return QAbstractAxis::AxisTypeNoAxis; |
|
726 | 722 | } |
|
727 | 723 | |
|
728 | QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisYType() const | |
|
729 | { | |
|
730 | return QAbstractAxis::AxisTypeNoAxis; | |
|
731 | } | |
|
732 | 724 | |
|
733 | 725 | #include "moc_qabstractbarseries.cpp" |
|
734 | 726 | #include "moc_qabstractbarseries_p.cpp" |
@@ -56,10 +56,8 public: | |||
|
56 | 56 | Chart* createGraphics(ChartPresenter* presenter); |
|
57 | 57 | QList<LegendMarker*> createLegendMarker(QLegend* legend); |
|
58 | 58 | |
|
59 |
void initializeAxis |
|
|
60 | void initializeAxisY(QAbstractAxis* axis); | |
|
61 | QAbstractAxis::AxisType defaultAxisXType() const; | |
|
62 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
59 | void initializeAxis(QAbstractAxis* axis); | |
|
60 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
63 | 61 | |
|
64 | 62 | bool append(QBarSet *set); |
|
65 | 63 | bool remove(QBarSet *set); |
@@ -113,14 +113,12 Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter) | |||
|
113 | 113 | return bar; |
|
114 | 114 | } |
|
115 | 115 | |
|
116 |
QAbstractAxis::AxisType QBarSeriesPrivate::defaultAxis |
|
|
116 | QAbstractAxis::AxisType QBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
117 | 117 | { |
|
118 | return QAbstractAxis::AxisTypeCategories; | |
|
119 | } | |
|
120 | ||
|
121 | QAbstractAxis::AxisType QBarSeriesPrivate::defaultAxisYType() const | |
|
122 | { | |
|
123 | return QAbstractAxis::AxisTypeValues; | |
|
118 | if(orientation==Qt::Horizontal) | |
|
119 | return QAbstractAxis::AxisTypeCategories; | |
|
120 | else | |
|
121 | return QAbstractAxis::AxisTypeValues; | |
|
124 | 122 | } |
|
125 | 123 | |
|
126 | 124 | #include "moc_qbarseries.cpp" |
@@ -43,8 +43,8 public: | |||
|
43 | 43 | Chart* createGraphics(ChartPresenter* presenter); |
|
44 | 44 | void scaleDomain(Domain& domain); |
|
45 | 45 | |
|
46 |
QAbstractAxis::AxisType defaultAxis |
|
|
47 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
46 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
47 | ||
|
48 | 48 | |
|
49 | 49 | private: |
|
50 | 50 | Q_DECLARE_PUBLIC(QBarSeries) |
@@ -2,6 +2,7 | |||
|
2 | 2 | #include "qhorizontalbarseries_p.h" |
|
3 | 3 | #include "horizontalbarchartitem_p.h" |
|
4 | 4 | #include "horizontalbaranimation_p.h" |
|
5 | #include "qbarcategoriesaxis.h" | |
|
5 | 6 | |
|
6 | 7 | #include "chartdataset_p.h" |
|
7 | 8 | #include "charttheme_p.h" |
@@ -62,17 +63,28 Chart* QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter* presenter) | |||
|
62 | 63 | return bar; |
|
63 | 64 | } |
|
64 | 65 | |
|
65 | QAbstractAxis::AxisType QHorizontalBarSeriesPrivate::defaultAxisXType() const | |
|
66 | void QHorizontalBarSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |
|
66 | 67 | { |
|
67 | return QAbstractAxis::AxisTypeValues; | |
|
68 | ||
|
69 | if(axis->type()==QAbstractAxis::AxisTypeCategories && axis->orientation()==Qt::Vertical) | |
|
70 | { | |
|
71 | QBarCategoriesAxis* cataxis = qobject_cast<QBarCategoriesAxis*>(axis); | |
|
72 | Q_ASSERT(cataxis); | |
|
73 | QStringList categories; | |
|
74 | for (int i(1); i < categoryCount()+1; i++) | |
|
75 | categories << QString::number(i); | |
|
76 | cataxis->append(categories); | |
|
77 | } | |
|
68 | 78 | } |
|
69 | 79 | |
|
70 |
QAbstractAxis::AxisType QHorizontalBarSeriesPrivate::defaultAxis |
|
|
80 | QAbstractAxis::AxisType QHorizontalBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
71 | 81 | { |
|
72 | return QAbstractAxis::AxisTypeCategories; | |
|
82 | if(orientation==Qt::Vertical) | |
|
83 | return QAbstractAxis::AxisTypeCategories; | |
|
84 | else | |
|
85 | return QAbstractAxis::AxisTypeValues; | |
|
73 | 86 | } |
|
74 | 87 | |
|
75 | ||
|
76 | 88 | #include "moc_qhorizontalbarseries.cpp" |
|
77 | 89 | |
|
78 | 90 | QTCOMMERCIALCHART_END_NAMESPACE |
@@ -41,8 +41,8 public: | |||
|
41 | 41 | QHorizontalBarSeriesPrivate(QHorizontalBarSeries* q); |
|
42 | 42 | Chart* createGraphics(ChartPresenter* presenter); |
|
43 | 43 | void scaleDomain(Domain& domain); |
|
44 | QAbstractAxis::AxisType defaultAxisXType() const; | |
|
45 |
QAbstractAxis::AxisType defaultAxis |
|
|
44 | void initializeAxis(QAbstractAxis* axis); | |
|
45 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
46 | 46 | |
|
47 | 47 | private: |
|
48 | 48 | Q_DECLARE_PUBLIC(QHorizontalBarSeries) |
@@ -112,15 +112,14 Chart* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter) | |||
|
112 | 112 | return bar; |
|
113 | 113 | } |
|
114 | 114 | |
|
115 |
QAbstractAxis::AxisType QPercentBarSeriesPrivate::defaultAxis |
|
|
115 | QAbstractAxis::AxisType QPercentBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
116 | 116 | { |
|
117 | return QAbstractAxis::AxisTypeCategories; | |
|
117 | if(orientation==Qt::Horizontal) | |
|
118 | return QAbstractAxis::AxisTypeCategories; | |
|
119 | else | |
|
120 | return QAbstractAxis::AxisTypeValues; | |
|
118 | 121 | } |
|
119 | 122 | |
|
120 | QAbstractAxis::AxisType QPercentBarSeriesPrivate::defaultAxisYType() const | |
|
121 | { | |
|
122 | return QAbstractAxis::AxisTypeValues; | |
|
123 | } | |
|
124 | 123 | |
|
125 | 124 | #include "moc_qpercentbarseries.cpp" |
|
126 | 125 |
@@ -42,8 +42,7 public: | |||
|
42 | 42 | QPercentBarSeriesPrivate(QPercentBarSeries* q); |
|
43 | 43 | void scaleDomain(Domain& domain); |
|
44 | 44 | Chart* createGraphics(ChartPresenter* presenter); |
|
45 |
QAbstractAxis::AxisType defaultAxis |
|
|
46 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
45 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
47 | 46 | |
|
48 | 47 | private: |
|
49 | 48 | Q_DECLARE_PUBLIC(QPercentBarSeries) |
@@ -114,14 +114,12 Chart* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter) | |||
|
114 | 114 | return bar; |
|
115 | 115 | } |
|
116 | 116 | |
|
117 |
QAbstractAxis::AxisType QStackedBarSeriesPrivate::defaultAxis |
|
|
117 | QAbstractAxis::AxisType QStackedBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
118 | 118 | { |
|
119 | return QAbstractAxis::AxisTypeCategories; | |
|
120 | } | |
|
121 | ||
|
122 | QAbstractAxis::AxisType QStackedBarSeriesPrivate::defaultAxisYType() const | |
|
123 | { | |
|
124 | return QAbstractAxis::AxisTypeValues; | |
|
119 | if(orientation==Qt::Horizontal) | |
|
120 | return QAbstractAxis::AxisTypeCategories; | |
|
121 | else | |
|
122 | return QAbstractAxis::AxisTypeValues; | |
|
125 | 123 | } |
|
126 | 124 | |
|
127 | 125 |
@@ -42,8 +42,7 public: | |||
|
42 | 42 | QStackedBarSeriesPrivate(QStackedBarSeries* q); |
|
43 | 43 | Chart* createGraphics(ChartPresenter* presenter); |
|
44 | 44 | void scaleDomain(Domain& domain); |
|
45 |
QAbstractAxis::AxisType defaultAxis |
|
|
46 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
45 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
47 | 46 | |
|
48 | 47 | private: |
|
49 | 48 | Q_DECLARE_PUBLIC(QStackedBarSeries) |
@@ -31,8 +31,7 | |||
|
31 | 31 | |
|
32 | 32 | QTCOMMERCIALCHART_BEGIN_NAMESPACE |
|
33 | 33 | |
|
34 |
ChartDataSet::ChartDataSet(QChart *parent):QObject(parent) |
|
|
35 | m_domainIndex(0) | |
|
34 | ChartDataSet::ChartDataSet(QChart *parent):QObject(parent) | |
|
36 | 35 | { |
|
37 | 36 | |
|
38 | 37 | } |
@@ -51,14 +50,47 void ChartDataSet::addSeries(QAbstractSeries* series) | |||
|
51 | 50 | return; |
|
52 | 51 | } |
|
53 | 52 | |
|
53 | domain = new Domain(series); | |
|
54 | m_seriesDomainMap.insert(series,domain); | |
|
55 | series->d_ptr->scaleDomain(*domain); | |
|
56 | ||
|
57 | createSeriesIndex(series); | |
|
58 | ||
|
54 | 59 | series->setParent(this); // take ownership |
|
60 | series->d_ptr->m_chart = qobject_cast<QChart*>(parent()); | |
|
61 | series->d_ptr->m_dataset = this; | |
|
55 | 62 | |
|
56 | domain = new Domain(series); | |
|
63 | emit seriesAdded(series,domain); | |
|
57 | 64 | |
|
58 | m_seriesDomainMap.insert(series,domain); | |
|
65 | } | |
|
66 | ||
|
67 | void ChartDataSet::removeSeries(QAbstractSeries* series) | |
|
68 | { | |
|
69 | ||
|
70 | if(!m_seriesDomainMap.contains(series)) { | |
|
71 | qWarning()<<"Can not remove series. Series not found on the chart."; | |
|
72 | return; | |
|
73 | } | |
|
74 | ||
|
75 | emit seriesRemoved(series); | |
|
76 | ||
|
77 | Domain* domain = m_seriesDomainMap.take(series); | |
|
78 | delete domain; | |
|
79 | domain = 0; | |
|
80 | ||
|
81 | removeSeriesIndex(series); | |
|
82 | ||
|
83 | series->setParent(0); | |
|
84 | series->d_ptr->m_chart = 0; | |
|
85 | series->d_ptr->m_dataset = 0; | |
|
86 | ||
|
87 | removeAxes(series); | |
|
88 | } | |
|
59 | 89 | |
|
60 | series->d_ptr->scaleDomain(*domain); | |
|
61 | 90 | |
|
91 | ||
|
92 | void ChartDataSet::createSeriesIndex(QAbstractSeries* series) | |
|
93 | { | |
|
62 | 94 | QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap); |
|
63 | 95 | |
|
64 | 96 | int key=0; |
@@ -71,12 +103,13 void ChartDataSet::addSeries(QAbstractSeries* series) | |||
|
71 | 103 | } |
|
72 | 104 | |
|
73 | 105 | m_indexSeriesMap.insert(key,series); |
|
106 | } | |
|
74 | 107 | |
|
75 | series->d_ptr->m_chart = qobject_cast<QChart*>(parent()); | |
|
76 | series->d_ptr->m_dataset = this; | |
|
77 | ||
|
78 | emit seriesAdded(series,domain); | |
|
79 | ||
|
108 | void ChartDataSet::removeSeriesIndex(QAbstractSeries* series) | |
|
109 | { | |
|
110 | int key = seriesIndex(series); | |
|
111 | Q_ASSERT(key!=-1); | |
|
112 | m_indexSeriesMap.remove(key); | |
|
80 | 113 | } |
|
81 | 114 | |
|
82 | 115 | void ChartDataSet::createDefaultAxes() |
@@ -100,62 +133,43 void ChartDataSet::createDefaultAxes() | |||
|
100 | 133 | QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key()); |
|
101 | 134 | QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key()); |
|
102 | 135 | if(axisX) typeX&=axisX->type(); |
|
103 |
else typeX|=i.key()->d_ptr->defaultAxis |
|
|
136 | else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal); | |
|
104 | 137 | if(axisY) typeY&=axisY->type(); |
|
105 |
else typeY|=i.key()->d_ptr->defaultAxis |
|
|
138 | else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical); | |
|
106 | 139 | } |
|
107 | 140 | |
|
141 | createAxes(typeX,Qt::Horizontal); | |
|
142 | createAxes(typeY,Qt::Vertical); | |
|
143 | } | |
|
108 | 144 | |
|
109 | if(typeX.testFlag(QAbstractAxis::AxisTypeValues) && typeX.testFlag(QAbstractAxis::AxisTypeCategories)) | |
|
145 | void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation) | |
|
146 | { | |
|
147 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); | |
|
148 | ||
|
149 | if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories)) | |
|
110 | 150 | { |
|
111 | i.toFront(); | |
|
112 | 151 | while (i.hasNext()) { |
|
113 |
|
|
|
114 |
|
|
|
115 |
|
|
|
116 |
|
|
|
117 |
|
|
|
118 | emit axisAdded(axis,i.value()); | |
|
152 | i.next(); | |
|
153 | QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation); | |
|
154 | if(!axis) continue; | |
|
155 | initializeAxis(axis,i.key()); | |
|
156 | emit axisAdded(axis,i.value()); | |
|
119 | 157 | } |
|
120 | 158 | |
|
121 | }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){ | |
|
122 | QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeX))); | |
|
123 | i.toFront(); | |
|
124 | while (i.hasNext()) { | |
|
125 | i.next(); | |
|
126 | i.key()->d_ptr->initializeAxisX(axis); | |
|
127 | addAxisX(axis,i.key()); | |
|
128 | } | |
|
129 | emit axisAdded(axis,i.value()); | |
|
130 | ||
|
131 | 159 | } |
|
132 | ||
|
133 | if(typeY.testFlag(QAbstractAxis::AxisTypeValues) && typeY.testFlag(QAbstractAxis::AxisTypeCategories)) | |
|
134 | { | |
|
160 | else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) { | |
|
161 | QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation); | |
|
135 | 162 | i.toFront(); |
|
136 | 163 | while (i.hasNext()) { |
|
137 |
|
|
|
138 | QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisYType()); | |
|
139 | i.key()->d_ptr->initializeAxisY(axis); | |
|
140 | addAxisY(axis,i.key()); | |
|
141 | emit axisAdded(axis,i.value()); | |
|
164 | i.next(); | |
|
165 | initializeAxis(axis,i.key()); | |
|
142 | 166 | } |
|
143 | ||
|
144 | }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){ | |
|
145 | QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeY))); | |
|
146 | i.toFront(); | |
|
147 | while (i.hasNext()) { | |
|
148 | i.next(); | |
|
149 | i.key()->d_ptr->initializeAxisY(axis); | |
|
150 | addAxisY(axis,i.key()); | |
|
151 | } | |
|
152 | emit axisAdded(axis,i.value()); | |
|
153 | ||
|
167 | emit axisAdded(axis,i.value()); | |
|
154 | 168 | } |
|
155 | 169 | } |
|
156 | 170 | |
|
157 | 171 | |
|
158 | QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type) | |
|
172 | QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation) | |
|
159 | 173 | { |
|
160 | 174 | QAbstractAxis* axis =0; |
|
161 | 175 | |
@@ -171,50 +185,28 QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type) | |||
|
171 | 185 | break; |
|
172 | 186 | } |
|
173 | 187 | |
|
174 | return axis; | |
|
175 | } | |
|
176 | ||
|
177 | void ChartDataSet::addAxisX(QAbstractAxis* axis,QAbstractSeries* series) { | |
|
178 | Domain* domain = m_seriesDomainMap.value(series); | |
|
179 | axis->d_ptr->m_orientation=Qt::Horizontal; | |
|
180 | //TODO:axis->d_ptr->initialize(domain); | |
|
181 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool))); | |
|
182 | QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
183 | m_seriesAxisXMap.insert(series,axis); | |
|
184 | } | |
|
188 | if(axis) | |
|
189 | axis->d_ptr->m_orientation=orientation; | |
|
185 | 190 | |
|
186 | void ChartDataSet::addAxisY(QAbstractAxis* axis,QAbstractSeries* series) { | |
|
187 | Domain* domain = m_seriesDomainMap.value(series); | |
|
188 | axis->d_ptr->m_orientation=Qt::Vertical; | |
|
189 | //TODO:axis->d_ptr->initialize(domain); | |
|
190 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool))); | |
|
191 | QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
192 | m_seriesAxisYMap.insert(series,axis); | |
|
191 | return axis; | |
|
193 | 192 | } |
|
194 | 193 | |
|
195 |
void ChartDataSet:: |
|
|
194 | void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series) | |
|
196 | 195 | { |
|
197 |
Domain* domain = m_seriesDomainMap. |
|
|
198 | ||
|
199 | if(!domain) { | |
|
200 | qWarning()<<"Can not remove series. Series not found on the chart."; | |
|
196 | Domain* domain = m_seriesDomainMap.value(series); | |
|
197 | axis->d_ptr->intializeDomain(domain); | |
|
198 | series->d_ptr->initializeAxis(axis); | |
|
199 | if(axis->orientation()==Qt::Horizontal) { | |
|
200 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool))); | |
|
201 | QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
202 | m_seriesAxisXMap.insert(series,axis); | |
|
201 | 203 | } |
|
202 | ||
|
203 | emit seriesRemoved(series); | |
|
204 | ||
|
205 | delete domain; | |
|
206 | domain = 0; | |
|
207 | ||
|
208 | int key = seriesIndex(series); | |
|
209 | Q_ASSERT(key!=-1); | |
|
210 | ||
|
211 | m_indexSeriesMap.remove(key); | |
|
212 | ||
|
213 | series->setParent(0); | |
|
214 | series->d_ptr->m_chart = 0; | |
|
215 | series->d_ptr->m_dataset = 0; | |
|
216 | ||
|
217 | removeAxes(series); | |
|
204 | else { | |
|
205 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool))); | |
|
206 | QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
207 | m_seriesAxisYMap.insert(series,axis); | |
|
208 | } | |
|
209 | axis->d_ptr->emitRange(); | |
|
218 | 210 | } |
|
219 | 211 | |
|
220 | 212 | void ChartDataSet::removeAxes(QAbstractSeries* series) |
@@ -296,13 +288,12 void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size) | |||
|
296 | 288 | void ChartDataSet::blockAxisSignals(bool enabled) |
|
297 | 289 | { |
|
298 | 290 | QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap); |
|
299 | Q_UNUSED(enabled); | |
|
300 | 291 | while (i.hasNext()) { |
|
301 | 292 | i.next(); |
|
302 | 293 | QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key()); |
|
303 | 294 | QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key()); |
|
304 |
if(axisX) axisX->d_ptr->blockSignals( |
|
|
305 |
if(axisY) axisY->d_ptr->blockSignals( |
|
|
295 | if(axisX) axisX->d_ptr->blockSignals(enabled); | |
|
296 | if(axisY) axisY->d_ptr->blockSignals(enabled); | |
|
306 | 297 | } |
|
307 | 298 | } |
|
308 | 299 | |
@@ -357,9 +348,10 QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const | |||
|
357 | 348 | return m_seriesAxisYMap.value(series); |
|
358 | 349 | } |
|
359 | 350 | |
|
360 |
void ChartDataSet::setAxis |
|
|
351 | void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation) | |
|
361 | 352 | { |
|
362 | 353 | Q_ASSERT(axis); |
|
354 | ||
|
363 | 355 | Domain* domain = m_seriesDomainMap.value(series); |
|
364 | 356 | |
|
365 | 357 | if(!domain) { |
@@ -367,73 +359,43 void ChartDataSet::setAxisX(QAbstractSeries *series, QAbstractAxis *axis) | |||
|
367 | 359 | return; |
|
368 | 360 | } |
|
369 | 361 | |
|
370 | if(axis->d_ptr->m_orientation==Qt::Vertical) { | |
|
362 | if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) { | |
|
371 | 363 | qWarning()<<"Axis already defined as axis Y"; |
|
372 | 364 | return; |
|
373 | 365 | } |
|
374 | 366 | |
|
375 | QAbstractAxis *oldAxis = m_seriesAxisXMap.take(series); | |
|
376 | QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values(); | |
|
377 | ||
|
378 | if(oldAxis) { | |
|
379 | ||
|
380 | int x = axesX.indexOf(oldAxis); | |
|
381 | if(x==-1) { | |
|
382 | emit axisRemoved(oldAxis); | |
|
383 | oldAxis->deleteLater(); | |
|
384 | } | |
|
385 | } | |
|
386 | ||
|
387 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool))); | |
|
388 | QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
389 | ||
|
390 | int x = axesX.indexOf(axis); | |
|
391 | if(x==-1) { | |
|
392 | axis->d_ptr->m_orientation=Qt::Horizontal; | |
|
393 | emit axisAdded(axis,domain); | |
|
367 | if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) { | |
|
368 | qWarning()<<"Axis already defined as axis X"; | |
|
369 | return; | |
|
394 | 370 | } |
|
395 | 371 | |
|
396 | m_seriesAxisXMap.insert(series,axis); | |
|
397 | axis->d_ptr->emitRange(); | |
|
398 | } | |
|
372 | axis->d_ptr->m_orientation=orientation; | |
|
399 | 373 | |
|
400 | void ChartDataSet::setAxisY(QAbstractSeries *series, QAbstractAxis *axis) | |
|
401 | { | |
|
402 | Q_ASSERT(axis); | |
|
403 | Domain* domain = m_seriesDomainMap.value(series); | |
|
374 | QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap; | |
|
404 | 375 | |
|
405 | if(!domain) { | |
|
406 | qWarning() << "Series not found on the chart."; | |
|
407 | return; | |
|
408 | } | |
|
376 | if(orientation==Qt::Vertical) { | |
|
377 | seriesAxisMap= &m_seriesAxisYMap; | |
|
409 | 378 | |
|
410 | if(axis->d_ptr->m_orientation==Qt::Horizontal) { | |
|
411 | qWarning()<<"Axis already defined as axis X"; | |
|
412 | return; | |
|
379 | }else{ | |
|
380 | seriesAxisMap= &m_seriesAxisXMap; | |
|
413 | 381 | } |
|
414 | 382 | |
|
415 |
QAbstractAxis *oldAxis = |
|
|
416 |
QList<QAbstractAxis*> axes |
|
|
383 | QAbstractAxis *oldAxis = seriesAxisMap->take(series); | |
|
384 | QList<QAbstractAxis*> axes = seriesAxisMap->values(); | |
|
417 | 385 | |
|
418 | 386 | if(oldAxis) { |
|
419 |
i |
|
|
420 | if(y==-1) { | |
|
387 | if(axes.indexOf(oldAxis)==-1) { | |
|
421 | 388 | emit axisRemoved(oldAxis); |
|
422 | 389 | oldAxis->deleteLater(); |
|
423 | 390 | } |
|
424 | 391 | } |
|
425 | 392 | |
|
426 | QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool))); | |
|
427 | QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int))); | |
|
428 | ||
|
429 | int y = axesY.indexOf(axis); | |
|
430 | if(y==-1) { | |
|
431 | axis->d_ptr->m_orientation=Qt::Vertical; | |
|
393 | if(axes.indexOf(axis)==-1) { | |
|
394 | initializeAxis(axis,series); | |
|
432 | 395 | emit axisAdded(axis,domain); |
|
396 | }else{ | |
|
397 | initializeAxis(axis,series); | |
|
433 | 398 | } |
|
434 | ||
|
435 | m_seriesAxisYMap.insert(series,axis); | |
|
436 | axis->d_ptr->emitRange(); | |
|
437 | 399 | } |
|
438 | 400 | |
|
439 | 401 | Domain* ChartDataSet::domain(QAbstractSeries *series) const |
@@ -61,8 +61,7 public: | |||
|
61 | 61 | QAbstractAxis* axisX(QAbstractSeries *series) const; |
|
62 | 62 | QAbstractAxis* axisY(QAbstractSeries *series) const; |
|
63 | 63 | |
|
64 |
void setAxis |
|
|
65 | void setAxisY(QAbstractSeries *series, QAbstractAxis *axis); | |
|
64 | void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation); | |
|
66 | 65 | |
|
67 | 66 | QList<QAbstractSeries*> series() const; |
|
68 | 67 | Domain* domain(QAbstractSeries *series) const; |
@@ -78,11 +77,13 Q_SIGNALS: | |||
|
78 | 77 | |
|
79 | 78 | private: |
|
80 | 79 | void calculateDomain(QAbstractSeries* series,Domain* domain); |
|
81 |
|
|
|
82 | void addAxisX(QAbstractAxis* axis,QAbstractSeries* series); | |
|
83 |
void |
|
|
80 | void createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation); | |
|
81 | QAbstractAxis* createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation); | |
|
82 | void initializeAxis(QAbstractAxis* axis,QAbstractSeries* series); | |
|
84 | 83 | void removeAxes(QAbstractSeries* series); |
|
85 | 84 | void blockAxisSignals(bool enabled); |
|
85 | void createSeriesIndex(QAbstractSeries* series); | |
|
86 | void removeSeriesIndex(QAbstractSeries* series); | |
|
86 | 87 | |
|
87 | 88 | private: |
|
88 | 89 | QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisXMap; |
@@ -790,23 +790,14 QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend) | |||
|
790 | 790 | return markers; |
|
791 | 791 | } |
|
792 | 792 | |
|
793 |
void QPieSeriesPrivate::initializeAxis |
|
|
793 | void QPieSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |
|
794 | 794 | { |
|
795 | 795 | Q_UNUSED(axis); |
|
796 | 796 | } |
|
797 | 797 | |
|
798 | void QPieSeriesPrivate::initializeAxisY(QAbstractAxis* axis) | |
|
799 | { | |
|
800 | Q_UNUSED(axis); | |
|
801 | } | |
|
802 | ||
|
803 | QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisXType() const | |
|
804 | { | |
|
805 | return QAbstractAxis::AxisTypeNoAxis; | |
|
806 | } | |
|
807 | ||
|
808 | QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisYType() const | |
|
798 | QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
809 | 799 | { |
|
800 | Q_UNUSED(orientation); | |
|
810 | 801 | return QAbstractAxis::AxisTypeNoAxis; |
|
811 | 802 | } |
|
812 | 803 |
@@ -47,10 +47,8 public: | |||
|
47 | 47 | void scaleDomain(Domain& domain); |
|
48 | 48 | Chart* createGraphics(ChartPresenter *presenter); |
|
49 | 49 | QList<LegendMarker*> createLegendMarker(QLegend *legend); |
|
50 |
void initializeAxis |
|
|
51 | void initializeAxisY(QAbstractAxis* axis); | |
|
52 | QAbstractAxis::AxisType defaultAxisXType() const; | |
|
53 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
50 | void initializeAxis(QAbstractAxis* axis); | |
|
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
54 | 52 | |
|
55 | 53 | void updateDerivativeData(); |
|
56 | 54 |
@@ -52,10 +52,8 public: | |||
|
52 | 52 | virtual void scaleDomain(Domain& domain) = 0; |
|
53 | 53 | virtual Chart* createGraphics(ChartPresenter* presenter) = 0; |
|
54 | 54 | virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0; |
|
55 |
virtual void initializeAxis |
|
|
56 | virtual void initializeAxisY(QAbstractAxis* axis) = 0; | |
|
57 | virtual QAbstractAxis::AxisType defaultAxisXType() const = 0; | |
|
58 | virtual QAbstractAxis::AxisType defaultAxisYType() const = 0; | |
|
55 | virtual void initializeAxis(QAbstractAxis* axis) = 0; | |
|
56 | virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0; | |
|
59 | 57 | |
|
60 | 58 | protected: |
|
61 | 59 | QAbstractSeries *q_ptr; |
@@ -462,7 +462,7 void QChart::setMarginsMinimum(const QRectF& margins) | |||
|
462 | 462 | */ |
|
463 | 463 | void QChart::setAxisX(QAbstractAxis* axis , QAbstractSeries *series) |
|
464 | 464 | { |
|
465 |
d_ptr->m_dataset->setAxis |
|
|
465 | d_ptr->m_dataset->setAxis(series,axis,Qt::Horizontal); | |
|
466 | 466 | } |
|
467 | 467 | |
|
468 | 468 | /*! |
@@ -472,7 +472,7 void QChart::setAxisX(QAbstractAxis* axis , QAbstractSeries *series) | |||
|
472 | 472 | */ |
|
473 | 473 | void QChart::setAxisY( QAbstractAxis* axis , QAbstractSeries *series) |
|
474 | 474 | { |
|
475 |
d_ptr->m_dataset->setAxis |
|
|
475 | d_ptr->m_dataset->setAxis(series,axis,Qt::Vertical); | |
|
476 | 476 | } |
|
477 | 477 | |
|
478 | 478 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
@@ -435,23 +435,14 QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend) | |||
|
435 | 435 | return list << new XYLegendMarker(q,legend); |
|
436 | 436 | } |
|
437 | 437 | |
|
438 |
void QXYSeriesPrivate::initializeAxis |
|
|
438 | void QXYSeriesPrivate::initializeAxis(QAbstractAxis* axis) | |
|
439 | 439 | { |
|
440 | 440 | Q_UNUSED(axis); |
|
441 | 441 | } |
|
442 | 442 | |
|
443 | void QXYSeriesPrivate::initializeAxisY(QAbstractAxis* axis) | |
|
444 | { | |
|
445 | Q_UNUSED(axis); | |
|
446 | } | |
|
447 | ||
|
448 | QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisXType() const | |
|
449 | { | |
|
450 | return QAbstractAxis::AxisTypeValues; | |
|
451 | } | |
|
452 | ||
|
453 | QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisYType() const | |
|
443 | QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const | |
|
454 | 444 | { |
|
445 | Q_UNUSED(orientation); | |
|
455 | 446 | return QAbstractAxis::AxisTypeValues; |
|
456 | 447 | } |
|
457 | 448 |
@@ -47,10 +47,8 public: | |||
|
47 | 47 | void scaleDomain(Domain& domain); |
|
48 | 48 | QList<LegendMarker*> createLegendMarker(QLegend* legend); |
|
49 | 49 | |
|
50 |
void initializeAxis |
|
|
51 | void initializeAxisY(QAbstractAxis* axis); | |
|
52 | QAbstractAxis::AxisType defaultAxisXType() const; | |
|
53 | QAbstractAxis::AxisType defaultAxisYType() const; | |
|
50 | void initializeAxis(QAbstractAxis* axis); | |
|
51 | QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const; | |
|
54 | 52 | |
|
55 | 53 | Q_SIGNALS: |
|
56 | 54 | void updated(); |
@@ -465,9 +465,6 void tst_QChart::scroll_right_data() | |||
|
465 | 465 | QLineSeries* series0 = new QLineSeries(this); |
|
466 | 466 | *series0 << QPointF(0, 0) << QPointF(100, 100); |
|
467 | 467 | |
|
468 | QLineSeries* series1 = new QLineSeries(this); | |
|
469 | *series1 << QPointF(0, 0) << QPointF(100, 100); | |
|
470 | ||
|
471 | 468 | QTest::newRow("lineSeries") << (QAbstractSeries*) series0; |
|
472 | 469 | |
|
473 | 470 |
General Comments 0
You need to be logged in to leave comments.
Login now