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