HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1314:f6f67dde6408

Implemented QAbstractSeries::chart()...

Jani Honkonen -

r1314:f6f67dde6408

parent child

Context file:

r1314:f6f67dde6408

Collapse all files

src/chartdataset.cpp +5 -1

             /****************************************************************************
             **
             ** 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 "qchart.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
+            ChartDataSet::ChartDataSet(QChart *parent):QObject(parent),
                 m_axisX(new QAxis(this)),
                 m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false),
                 m_axisYInitialized(false)
             {
                 //create main domain
                 Domain* domain = new Domain(m_axisY);
                 m_axisDomainMap.insert(m_axisY,domain);
                 QObject::connect(m_axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(m_axisX->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),m_axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),m_axisX->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    m_axisXInitialized=true;
                    emit axisAdded(m_axisX,domain);
                 }
                 if(!m_axisYInitialized && axisY==m_axisY){
                    m_axisYInitialized=true;
                    emit axisAdded(m_axisY,domain);
                 }
                 series->d_ptr->scaleDomain(*domain);
                 // Note that with SeriesTypeBar we don't set up categories, but use real values on x-asis
                 if(series->type() == QAbstractSeries::SeriesTypeGroupedBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
+                series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
+                series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=m_axisY){
                         axis->setParent(0);
                         delete domain;
                     }else{
                         m_axisYInitialized=false;
                         m_axisDomainMap.insert(m_axisY,domain);
                     }
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
                     QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==1);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomIn(rect,size);
                 }
                 domain->zoomIn(rect,size);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomOut(rect,size);
                 }
                 domain->zoomOut(rect,size);
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->move(dx,dy,size);
                 }
                 domain->move(dx,dy,size);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +1 -1

             /****************************************************************************
             **
             ** 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 "qabstractseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class QBarSeries;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
-                ChartDataSet(QObject* parent=0);
+                ChartDataSet(QChart* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries* series,QAxis *axisY = 0);
                 QAxis* removeSeries(QAbstractSeries* series);
                 void removeAllSeries();
                 void updateSeries(QAbstractSeries* series);
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(qreal dx,qreal dy,const QSizeF& size);
                 int seriesCount(QAbstractSeries::SeriesType type);
                 int seriesIndex(QAbstractSeries *series);
                 Domain* domain(QAbstractSeries* series) const;
                 Domain* domain(QAxis* axis) const;
                 QAxis* axisX() const { return m_axisX; }
                 QAxis* axisY(QAbstractSeries *series = 0) const;
                 QList<QAbstractSeries*> series() const;
             Q_SIGNALS:
                 void seriesAdded(QAbstractSeries* series, Domain* domain);
                 void seriesRemoved(QAbstractSeries* series);
                 void seriesUpdated(QAbstractSeries* series);
                 void axisAdded(QAxis* axis,Domain* domain);
                 void axisRemoved(QAxis* axis);
             private:
                 QStringList createLabels(QAxis* axis,qreal min, qreal max);
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
                 QMap<QAbstractSeries *, QAxis *> m_seriesAxisMap;
                 QMap<QAxis*, Domain *> m_axisDomainMap;
                 QMap<int, QAbstractSeries *> m_indexSeriesMap;
                 QAxis* m_axisX;
                 QAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
                 bool m_axisYInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/qabstractseries.cpp +12 0

             /****************************************************************************
             **
             ** 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 "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypeGroupedBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \fn QSeriesType QAbstractSeries::type() const
                 \brief The type of the series.
             */
             /*!
                 \fn bool QAbstractSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property
             */
             /*!
                 \fn void QAbstractSeries::setName(const QString& name)
                 \brief Sets a \a name for the series.
                 The name of a series is shown in the legend for QXYSeries.
                 \sa QChart::setTitle()
                 \sa QPieSlice::setLabel()
                 \sa QBarSet::setName()
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if(d_ptr->m_dataset) qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString& name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 \brief Returns the name of the series.
                 \sa setName()
             */
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
+            /*!
+                \brief Returns the chart where series belongs to.
+                Set automatically when the series is added to the chart
+                and unset when the series is removed from the chart.
+            */
+            QChart* QAbstractSeries::chart() const
+            {
+                return d_ptr->m_chart;
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q):
                 q_ptr(q),
+                m_chart(0),
                 m_dataset(0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries_p.h +1 0

             /****************************************************************************
             **
             ** 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 QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include "qabstractseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class ChartPresenter;
             class Chart;
             class LegendMarker;
             class QLegend;
             class ChartDataSet;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void scaleDomain(Domain& domain) = 0;
                 virtual Chart* createGraphics(ChartPresenter* presenter) = 0;
                 virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
             protected:
                 QAbstractSeries *q_ptr;
+                QChart *m_chart;
                 ChartDataSet *m_dataset;
                 QString m_name;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

tests/auto/qchart/tst_qchart.cpp +11 -2

             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void margins_data();
                 void margins();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scrollDown_data();
                 void scrollDown();
                 void scrollLeft_data();
                 void scrollLeft();
                 void scrollRight_data();
                 void scrollRight();
                 void scrollUp_data();
                 void scrollUp();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::createTestData()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                 m_chart->addSeries(series0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(m_chart->axisX());
                 QVERIFY(m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scrollDown();
                 m_chart->scrollLeft();
                 m_chart->scrollRight();
                 m_chart->scrollUp();
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::addColumn<QAxis *>("axis");
                 QAbstractSeries* series0 = new QLineSeries(this);
                 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
                 QAbstractSeries* series2 = new QScatterSeries(this);
                 QAbstractSeries* series3 = new QSplineSeries(this);
                 QAbstractSeries* series4 = new QPieSeries(this);
                 QAbstractSeries* series5 = new QBarSeries(this);
                 QAbstractSeries* series6 = new QPercentBarSeries(this);
                 QAbstractSeries* series7 = new QStackedBarSeries(this);
                 QBarSeries* s5 = static_cast<QBarSeries*> (series5);
                 s5->setCategories(QBarCategories());
                 QPercentBarSeries* s6 = static_cast<QPercentBarSeries*> (series6);
                 s6->setCategories(QBarCategories());
                 QStackedBarSeries* s7 = static_cast<QStackedBarSeries*> (series7);
                 s7->setCategories(QBarCategories());
                 QAxis* axis = new QAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
                 QTest::newRow("default axis: areaSeries") << series1 << (QAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
                 QTest::newRow("default axis: scatterSeries") << series2 << (QAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
                 QTest::newRow("default axis: splineSeries") << series3 << (QAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
                 QTest::newRow("default axis: pieSeries") << series4 << (QAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
                 QTest::newRow("default axis: barSeries") << series5 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
                 QTest::newRow("default axis: percentBarSeries") << series6 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
                 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
+                QVERIFY(!series->chart());
                 m_chart->addSeries(series,axis);
+                QVERIFY(series->chart() == m_chart);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
+                QVERIFY(!series->chart());
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
             }
             void tst_QChart::axisX()
             {
                 QVERIFY(m_chart->axisX());
                 QAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
                 QTest::addColumn<QAxis*>("axis0");
                 QTest::addColumn<QAxis*>("axis1");
                 QTest::addColumn<QAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QAxis*)0 << new QAxis() << new QAxis();
                 QTest::newRow("3 optional") << new QAxis() << new QAxis() << new QAxis();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAxis*, axis0);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QAxis*, axis2);
                 QAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0, axis0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1, axis1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2, axis2);
                 if (!axis0)
                     axis0 = defaultAxisY;
                 if (!axis1)
                     axis1 = defaultAxisY;
                 if (!axis2)
                     axis2 = defaultAxisY;
                 QVERIFY(m_chart->axisY(series0) == axis0);
                 QVERIFY(m_chart->axisY(series1) == axis1);
                 QVERIFY(m_chart->axisY(series2) == axis2);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QVERIFY(m_chart->legend());
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
+                QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
+                QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
+                QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
+                QCOMPARE(deleteSpy1.count(), 1);
+                QCOMPARE(deleteSpy2.count(), 1);
+                QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAxis *, axis);
+                QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
+                QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scrollDown_data()
             {
             }
             void tst_QChart::scrollDown()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollDown();
                 QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::scrollLeft_data()
             {
             }
             void tst_QChart::scrollLeft()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollLeft();
                 QVERIFY(m_chart->axisX()->min()<min);
             }
             void tst_QChart::scrollRight_data()
             {
             }
             void tst_QChart::scrollRight()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollRight();
                 QVERIFY(m_chart->axisX()->min()>min);
             }
             void tst_QChart::scrollUp_data()
             {
             }
             void tst_QChart::scrollUp()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollUp();
                 QVERIFY(m_chart->axisY()->min()>min);
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 QRectF marigns = m_chart->margins();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<m_chart->axisX()->min());
                     QVERIFY(maxX>m_chart->axisX()->max());
                     QVERIFY(minY<m_chart->axisY()->min());
                     QVERIFY(maxY>m_chart->axisY()->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < m_chart->axisX()->min());
                 QVERIFY(maxX > m_chart->axisX()->max());
                 QVERIFY(minY < m_chart->axisY()->min());
                 QVERIFY(maxY > m_chart->axisY()->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(m_chart->axisX()->min()));
                 else
                     QCOMPARE(minX, m_chart->axisX()->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(m_chart->axisY()->min()));
                 else
                     QCOMPARE(minY, m_chart->axisY()->min());
                 QVERIFY(maxX == m_chart->axisX()->max());
                 QVERIFY(maxY == m_chart->axisY()->max());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

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