HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r825:d850de289019

Reserve ordering of chart series internally....

Tero Ahola -

r825:d850de289019

parent child

Context file:

r825:d850de289019

Collapse all files

src/chartdataset.cpp +53 -64

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QChartAxis(this)),
                 m_axisY(new QChartAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
-                QChartAxis* axis = m_seriesAxisMap.value(series);
+                if (seriesIndex(series) > -1) {
-                if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 if(!series->parent()){
                    series->setParent(this); // take ownership
                 };
                 if(!axisY->parent()){
                    axisY->setParent(this); // take ownership
                 }
                 Domain* domain = m_axisDomainMap.value(axisY);
+                if (!domain) {
-                if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY,SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY,SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axisX(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
-                if(!m_axisXInitialized){
+                if (!m_axisXInitialized) {
-                   emit axisAdded(axisX(),domain);
+                   emit axisAdded(axisX(), domain);
-                   m_axisXInitialized=true;
+                   m_axisXInitialized = true;
                 }
-                calculateDomain(series,domain);
+                calculateDomain(series, domain);
-                m_seriesAxisMap.insert(series,axisY);
+                m_seriesAxisList.append(QPair<QSeries*, QChartAxis*>(series, axisY));
-                emit seriesAdded(series,domain);
+                emit seriesAdded(series, domain);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
+                int index = seriesIndex(series);
-                QChartAxis* axis = m_seriesAxisMap.value(series);
+                if (!index < 0) {
+                    qWarning() << "Can not remove series. Series not found on the chart.";
-                if(!axis){
-                    qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
-                emit seriesRemoved(series);
-                m_seriesAxisMap.remove(series);
-                if(series->parent()==this){
+                // Remove the series and the axis from the container
+                QChartAxis* axis = m_seriesAxisList.at(index).second;
+                m_seriesAxisList.removeAt(index);
+                // Delete the series
+                emit seriesRemoved(series);
+                if (series->parent() == this) {
                     delete series;
-                    series=0;
+                    series = 0;
                 }
-                QList<QChartAxis*> axes =  m_seriesAxisMap.values();
+                // Check if the Y axis is still in use
+                bool yAxisInUse(false);
-                int i = axes.indexOf(axis);
+                for (int i(0); i < m_seriesAxisList.count(); i++) {
+                    QPair<QSeries *, QChartAxis *> pair = m_seriesAxisList.at(i);
+                    if (pair.second == axis)
+                        yAxisInUse = true;
+                }
-                if(i==-1){
+                // Remove the Y axis if not in use
+                if (!yAxisInUse) {
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
-                    if(axis!=axisY()){
+                    if (axis != axisY()) {
-                        if(axis->parent()==this){
+                        // Delete the Y axis unless it is the default one
+                        if (axis->parent() == this) {
                             delete axis;
-                            axis=0;
+                            axis = 0;
                         }
                     }
                     delete domain;
                 }
-                if(m_seriesAxisMap.values().size()==0)
+                // Remove the x axis in case there are no y-axes left
+                if (m_seriesAxisList.count() == 0) {
-                    m_axisXInitialized=false;
+                    m_axisXInitialized = false;
                     emit axisRemoved(axisX());
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
+                while (m_seriesAxisList.count()) {
-                QList<QSeries*> series =  m_seriesAxisMap.keys();
+                    QPair<QSeries *, QChartAxis *> pair = m_seriesAxisList.last();
+                    removeSeries(pair.first);
-                foreach(QSeries* s , series) {
-                    removeSeries(s);
                 }
-                Q_ASSERT(m_seriesAxisMap.count()==0);
+                Q_ASSERT(m_seriesAxisList.count() == 0);
-                Q_ASSERT(m_axisDomainMap.count()==0);
+                Q_ASSERT(m_axisDomainMap.count() == 0);
             }
             //to be removed with PIMPL
             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain)
             {
                 qreal minX(domain->minX());
                 qreal minY(domain->minY());
                 qreal maxX(domain->maxX());
                 qreal maxY(domain->maxY());
                 int tickXCount(domain->tickXCount());
                 int tickYCount(domain->tickYCount());
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine:
                     case QSeries::SeriesTypeSpline:
                     case QSeries::SeriesTypeScatter:
                     {
                         QXYSeries* xySeries = static_cast<QXYSeries*>(series);
                         for (int i = 0; i < xySeries->count(); i++)
                         {
                             qreal x = xySeries->x(i);
                             qreal y = xySeries->y(i);
                             minX = qMin(minX, x);
                             minY = qMin(minY, y);
                             maxX = qMax(maxX, x);
                             maxY = qMax(maxY, y);
                         }
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         QLineSeries* upperSeries = areaSeries->upperSeries();
                         QLineSeries* lowerSeries = areaSeries->lowerSeries();
                         for (int i = 0; i < upperSeries->count(); i++)
                         {
                             qreal x = upperSeries->x(i);
                             qreal y = upperSeries->y(i);
                             minX = qMin(minX, x);
                             minY = qMin(minY, y);
                             maxX = qMax(maxX, x);
                             maxY = qMax(maxY, y);
                         }
                         if(lowerSeries) {
                             for (int i = 0; i < lowerSeries->count(); i++)
                             {
                                 qreal x = lowerSeries->x(i);
                                 qreal y = lowerSeries->y(i);
                                 minX = qMin(minX, x);
                                 minY = qMin(minY, y);
                                 maxX = qMax(maxX, x);
                                 maxY = qMax(maxY, y);
                             }}
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                         tickXCount = x+1;
                         setupCategories(barSeries);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                         tickXCount = x+1;
                         setupCategories(stackedBarSeries);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         minX = qMin(minX, x);
                         maxX = qMax(maxX, x);
                         minY = 0;
                         maxY = 100;
                         setupCategories(percentBarSeries);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         //QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                     }
                 }
                 domain->setRangeX(minX,maxX,tickXCount);
                 domain->setRangeY(minY,maxY,tickYCount);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QChartAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
-            int ChartDataSet::seriesCount(QSeries::QSeriesType type)
+            int ChartDataSet::seriesIndex(QSeries *series) const
-                int count=0;
-                QMapIterator<QSeries*, QChartAxis*> i(m_seriesAxisMap);
-                while (i.hasNext()) {
-                       i.next();
-                       if(i.key()->type()==type) count++;
-                return count;
-            int ChartDataSet::seriesIndex(QSeries *series)
             {
-                int count=-1;
+                for (int i(0); i < m_seriesAxisList.count(); i++) {
-                QMapIterator<QSeries*, QChartAxis*> i(m_seriesAxisMap);
+                    QPair<QSeries *, QChartAxis *> pair = m_seriesAxisList.at(i);
-                while (i.hasNext()) {
+                    if (pair.first == series)
-                    i.next();
+                        return i;
-                    count++;
-                    if (i.key() == series)
-                        return count;
                 }
-                return count;
+                return -1;
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
-                if(series == 0) return m_axisY;
+                if (series == 0)
-                return m_seriesAxisMap.value(series);
+                    return m_axisY;
+                return m_seriesAxisList.at(seriesIndex(series)).second;
             }
             Domain* ChartDataSet::domain(QSeries* series) const
             {
-            	QChartAxis* axis = m_seriesAxisMap.value(series);
+                QChartAxis* axis = m_seriesAxisList.at(seriesIndex(series)).second;
-            	if(axis){
+                if (axis)
             		return m_axisDomainMap.value(axis);
-            	}else
+                return 0;
-            		return 0;
             }
             Domain* ChartDataSet::domain(QChartAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
             	 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
             	 	while (i.hasNext()) {
             	        i.next();
             	        i.value()->move(dx,dy,size);
             	    }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +2 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTDATASET_P_H_
             #define CHARTDATASET_P_H_
             #include "qseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class QBarSeries;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QSeries* series,QChartAxis *axisY = 0);
                 void removeSeries(QSeries* series);
                 void removeAllSeries();
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(int dx,int dy,const QSizeF& size);
-                int seriesCount(QSeries::QSeriesType type);
+                int seriesIndex(QSeries *series) const;
-                int seriesIndex(QSeries *series);
                 Domain* domain(QSeries* series) const;
                 Domain* domain(QChartAxis* axis) const;
                 QChartAxis* axisX() const { return m_axisX; }
                 QChartAxis* axisY(QSeries* series = 0) const;
             Q_SIGNALS:
                 void seriesAdded(QSeries* series,Domain* domain);
                 void seriesRemoved(QSeries* series);
                 void axisAdded(QChartAxis* axis,Domain* domain);
                 void axisRemoved(QChartAxis* axis);
             private:
                 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
                 void calculateDomain(QSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
-                QMap<QSeries*, QChartAxis*> m_seriesAxisMap;
+                QList<QPair<QSeries*, QChartAxis*> > m_seriesAxisList;
                 QMap<QChartAxis*, Domain*> m_axisDomainMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

test/auto/chartdataset/tst_chartdataset.cpp 0 -36

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartaxis.h>
             #include <qlineseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain*)
             Q_DECLARE_METATYPE(QChartAxis*)
             Q_DECLARE_METATYPE(QSeries*)
             Q_DECLARE_METATYPE(QLineSeries*)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public Q_SLOTS:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private Q_SLOTS:
             	void chartdataset_data();
             	void chartdataset();
             	void addSeries_data();
             	void addSeries();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
             	void axisY_data();
             	void axisY();
-                void seriesCount_data();
-            	void seriesCount();
                 void seriesIndex_data();
             	void seriesIndex();
             	void domain_data();
             	void domain();
                 void zoomInDomain_data();
             	void zoomInDomain();
                 void zoomOutDomain_data();
                 void zoomOutDomain();
                 void scrollDomain_data();
                 void scrollDomain();
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QChartAxis*>();
             	qRegisterMetaType<QSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
             }
             void tst_ChartDataSet::cleanup()
             {
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	ChartDataSet dataSet;
             	QVERIFY2(dataSet.axisX(), "Missing axisX.");
             	QVERIFY2(dataSet.axisY(), "Missing axisY.");
             	//check if not dangling pointer
             	dataSet.axisX()->objectName();
             	dataSet.axisY()->objectName();
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QLineSeries*>("series0");
                 QTest::addColumn<QChartAxis*>("axis0");
                 QTest::addColumn<QLineSeries*>("series1");
                 QTest::addColumn<QChartAxis*>("axis1");
                 QTest::addColumn<QLineSeries*>("series2");
                 QTest::addColumn<QChartAxis*>("axis2");
                 QTest::addColumn<int>("axisCount");
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QChartAxis* axis0 = new QChartAxis(this);
                 QChartAxis* axis1 = new QChartAxis(this);
                 QChartAxis* axis2 = new QChartAxis(this);
             	QTest::newRow("default axis Y: series0,series1,series2") << series0 << (QChartAxis*)0 << series1 << (QChartAxis*)0  << series2 << (QChartAxis*)0 << 2;
             	QTest::newRow("default axis Y: series0, axis 0: series1,series2") << series0 << (QChartAxis*)0 << series1 << axis0 << series2 << axis0 << 3;
             	QTest::newRow("axis0: series0, axis1: series1, axis2: series2") << series0 << axis0 << series1 << axis1 << series2 << axis2 << 4;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
                 QCOMPARE(spy0.count(), axisCount);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 3);
                 QCOMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), axisCount);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(QLineSeries*, series0);
                   QFETCH(QChartAxis*, axis0);
                   QFETCH(QLineSeries*, series1);
                   QFETCH(QChartAxis*, axis1);
                   QFETCH(QLineSeries*, series2);
                   QFETCH(QChartAxis*, axis2);
                   QFETCH(int, axisCount);
                   ChartDataSet dataSet;
                   dataSet.addSeries(series0,axis0);
                   dataSet.addSeries(series1,axis1);
                   dataSet.addSeries(series2,axis2);
                   QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                   QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                   QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                   QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                   dataSet.removeAllSeries();
                   QCOMPARE(spy0.count(), 0);
                   QCOMPARE(spy1.count(), axisCount);
                   QCOMPARE(spy2.count(), 0);
                   QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::axisY_data()
             {
                 QTest::addColumn<QChartAxis*>("axis0");
                 QTest::addColumn<QChartAxis*>("axis1");
                 QTest::addColumn<QChartAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QChartAxis*)0 << new QChartAxis() << new QChartAxis();
                 QTest::newRow("3 optional") << new QChartAxis() << new QChartAxis() << new QChartAxis();
             }
             void tst_ChartDataSet::axisY()
             {
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QChartAxis*, axis2);
                 ChartDataSet dataSet;
                 QChartAxis* defaultAxisY = dataSet.axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 dataSet.addSeries(series0,axis0);
                 QLineSeries* series1 = new QLineSeries();
                 dataSet.addSeries(series1,axis1);
                 QLineSeries* series2 = new QLineSeries();
                 dataSet.addSeries(series2,axis2);
                 if(!axis0) axis0=defaultAxisY ;
                 if(!axis1) axis1=defaultAxisY ;
                 if(!axis2) axis2=defaultAxisY ;
                 QVERIFY(dataSet.axisY(series0) == axis0);
                 QVERIFY(dataSet.axisY(series1) == axis1);
                 QVERIFY(dataSet.axisY(series2) == axis2);
             }
-            void tst_ChartDataSet::seriesCount_data()
-                addSeries_data();
-            void tst_ChartDataSet::seriesCount()
-                QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
-                QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
-                QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
-                QFETCH(int, axisCount);
-                Q_UNUSED(axisCount);
-                ChartDataSet dataSet;
-                dataSet.addSeries(series0, axis0);
-                dataSet.addSeries(series1, axis1);
-                dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
-                QCOMPARE(dataSet.seriesCount(series0->type()),3);
-                QCOMPARE(spy0.count(), 0);
-                QCOMPARE(spy1.count(), 0);
-                QCOMPARE(spy2.count(), 0);
-                QCOMPARE(spy3.count(), 0);
             void tst_ChartDataSet::seriesIndex_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 int i0 = dataSet.seriesIndex(series0);
                 int i1 = dataSet.seriesIndex(series1);
                 int i2 = dataSet.seriesIndex(series2);
                 QVERIFY(i1!=i2);
                 QVERIFY(i0!=i2);
                 QVERIFY(i0!=i1);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 QVERIFY(dataSet.domain(axis0)==dataSet.domain(series0));
                 QVERIFY(dataSet.domain(axis1)==dataSet.domain(series1));
                 QVERIFY(dataSet.domain(axis2)==dataSet.domain(series2));
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.zoomInDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.scrollDomain(10,10,QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

test/chartwidgettest/mainwidget.cpp +3 0

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartview.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qlineseries.h"
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString, int, int, QString, bool)),
                             this, SLOT(addSeries(QString, int, int, QString, bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
+                        series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
+                        areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
+                        series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(column.at(i), labels.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
                     QBarSeries* series = 0;
                     if (seriesName == "Bar")
                         series = new QBarSeries(category, this);
                     else if (seriesName == "Stacked bar")
                         series = new QStackedBarSeries(category, this);
                     else
                         series = new QPercentBarSeries(category, this);
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
                         series->appendBarSet(set);
                     }
                     // TODO: new implementation of setFloatingValuesEnabled with signals
                     //series->setFloatingValuesEnabled(true);
                     series->setToolTipEnabled(true);
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chart->setTheme((QChart::ChartTheme) themeIndex);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages