HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1593:c1bed7868e27

Fix all tst_chartdataset test cases

Michal Klocek -

r1593:c1bed7868e27

parent child

Context file:

r1593:c1bed7868e27

Collapse all files

src/axis/qvaluesaxis.cpp +4 -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$
             **
             ****************************************************************************/
             #include "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "chartvaluesaxisx_p.h"
             #include "chartvaluesaxisy_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QValuesAxis
                 \brief The Axis element is used for manipulating chart's axes
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int Axis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool Axis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
-                   emit rangeChanged(d->m_min,d->m_max);
+                    emit rangeChanged(d->m_min,d->m_max);
-                   emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
+                    if(!signalsBlocked()){
+                        emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
+                    }
                 }
-            //    d->setRange(min,max);
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
             void QValuesAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValuesAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValuesAxisPrivate::setRange(const QVariant &min, const QVariant &max, bool force)
             {
                 Q_UNUSED(force);    // TODO: use this
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValuesAxisY(q,presenter);
                 }else{
                     return new ChartValuesAxisX(q,presenter);
                 }
             }
             void QValuesAxisPrivate::updateRange()
             {
                 setRange(m_min,m_max,true);
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +30 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 "chartdataset_p.h"
             #include "qchart.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *parent):QObject(parent),
                 m_domainIndex(0)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(domain) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 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);
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if(m_seriesDomainMap.isEmpty()) return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                            i.next();
                            removeAxes(i.key());
                 }
                 i.toFront();
                 while (i.hasNext()) {
                         i.next();
                         QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                         QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                         if(axisX) typeX&=axisX->type();
                         else typeX|=i.key()->d_ptr->defaultAxisXType();
                         if(axisY) typeY&=axisY->type();
                         else typeY|=i.key()->d_ptr->defaultAxisYType();
                 }
                 if(typeX.testFlag(QAbstractAxis::AxisTypeValues) && typeX.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     i.toFront();
                     while (i.hasNext()) {
                            i.next();
                            QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisXType());
                            i.key()->d_ptr->initializeAxisX(axis);
                            addAxisX(axis,i.key());
                            emit axisAdded(axis,i.value());
                     }
                 }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeX)));
                     i.toFront();
                           while (i.hasNext()) {
                                  i.next();
                                  i.key()->d_ptr->initializeAxisX(axis);
                                  addAxisX(axis,i.key());
                           }
                     emit axisAdded(axis,i.value());
                 }
                 if(typeY.testFlag(QAbstractAxis::AxisTypeValues) && typeY.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     i.toFront();
                     while (i.hasNext()) {
                            i.next();
                            QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisYType());
                            i.key()->d_ptr->initializeAxisY(axis);
                            addAxisY(axis,i.key());
                            emit axisAdded(axis,i.value());
                     }
                 }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeY)));
                     i.toFront();
                           while (i.hasNext()) {
                                  i.next();
                                  i.key()->d_ptr->initializeAxisY(axis);
                                  addAxisY(axis,i.key());
                           }
                           emit axisAdded(axis,i.value());
                 }
             }
             QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type)
             {
                 QAbstractAxis* axis =0;
                 switch(type) {
                     case QAbstractAxis::AxisTypeValues:
                     axis = new QValuesAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategories:
                     axis = new QCategoriesAxis(this);
                     break;
                     default:
                     axis = 0;
                     break;
                 }
                 return axis;
             }
             void ChartDataSet::addAxisX(QAbstractAxis* axis,QAbstractSeries* series) {
                 Domain* domain = m_seriesDomainMap.value(series);
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 axis->d_ptr->m_orientation=Qt::Horizontal;
                 m_seriesAxisXMap.insert(series,axis);
             }
             void ChartDataSet::addAxisY(QAbstractAxis* axis,QAbstractSeries* series) {
                 Domain* domain = m_seriesDomainMap.value(series);
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 axis->d_ptr->m_orientation=Qt::Vertical;
                 m_seriesAxisYMap.insert(series,axis);
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.take(series);
                 if(!domain) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                 }
                 emit seriesRemoved(series);
                 delete domain;
                 domain = 0;
                 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;
                 removeAxes(series);
             }
             void ChartDataSet::removeAxes(QAbstractSeries* series)
             {
                 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
                 if(axisX) {
                     QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                     int x = axesX.indexOf(axisX);
                     if(x==-1) {
                         emit axisRemoved(axisX);
                         axisX->deleteLater();
                     }
                 }
                 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
                 if(axisY) {
                     QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                     int y = axesY.indexOf(axisY);
                     if(y==-1) {
                         emit axisRemoved(axisY);
                         axisY->deleteLater();
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
                 foreach(QAbstractSeries *s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesDomainMap.count()==0);
                 qDeleteAll(series);
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
+                //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
+                blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
+                blockAxisSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
+                //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
+                blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
+                blockAxisSignals(false);
+            }
+            void ChartDataSet::blockAxisSignals(bool enabled)
+            {
+                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                while (i.hasNext()) {
+                       i.next();
+                       QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
+                       QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
+                       if(axisX) axisX->blockSignals(enabled);
+                       if(axisY) axisY->blockSignals(enabled);
+                   }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 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;
             }
             QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
             {
                 if(series == 0) return m_seriesAxisXMap.begin().value();
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_seriesAxisYMap.begin().value();
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxisX(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisXMap.take(series);
                 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                 if(oldAxis) {
                     int x = axesX.indexOf(oldAxis);
                     if(x==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int x = axesX.indexOf(axis);
                 if(x==-1) {
                     axis->d_ptr->m_orientation=Qt::Horizontal;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisXMap.insert(series,axis);
                 // Force range update
                 axis->d_ptr->updateRange();
             }
             void ChartDataSet::setAxisY(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisYMap.take(series);
                 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                 if(oldAxis) {
                     int y = axesY.indexOf(oldAxis);
                     if(y==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int y = axesY.indexOf(axis);
                 if(y==-1) {
                     axis->d_ptr->m_orientation=Qt::Vertical;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisYMap.insert(series,axis);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
                 return m_seriesDomainMap.value(series);
             }
             void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
+                blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->move(dx,dy,size);
                 }
+                blockAxisSignals(false);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisXMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_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 CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include "qabstractseries.h"
             #include "domain_p.h"
             #include "qabstractaxis_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QChart* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries* series);
                 void 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);
                 QAbstractAxis* axisX(QAbstractSeries *series) const;
                 QAbstractAxis* axisY(QAbstractSeries *series) const;
                 void setAxisX(QAbstractSeries *series, QAbstractAxis *axis);
                 void setAxisY(QAbstractSeries *series, QAbstractAxis *axis);
                 QList<QAbstractSeries*> series() const;
                 Domain* domain(QAbstractSeries *series) const;
                 void createDefaultAxes();
             Q_SIGNALS:
                 void seriesAdded(QAbstractSeries* series, Domain* domain);
                 void seriesRemoved(QAbstractSeries* series);
                 void seriesUpdated(QAbstractSeries* series);
                 void axisAdded(QAbstractAxis* axis,Domain* domain);
                 void axisRemoved(QAbstractAxis* axis);
             private:
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
                 QAbstractAxis* createAxis(QAbstractAxis::AxisType type);
                 void addAxisX(QAbstractAxis* axis,QAbstractSeries* series);
                 void addAxisY(QAbstractAxis* axis,QAbstractSeries* series);
                 void removeAxes(QAbstractSeries* series);
+                void blockAxisSignals(bool enabled);
             private:
                 QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisXMap;
                 QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisYMap;
                 QMap<QAbstractSeries*, Domain*> m_seriesDomainMap;
                 QMap<int, QAbstractSeries*> m_indexSeriesMap;
                 int m_domainIndex;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

tests/auto/chartdataset/tst_chartdataset.cpp +47 -59

             /****************************************************************************
             **
             ** 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 <qabstractaxis.h>
             #include <qvaluesaxis.h>
             #include <qcategoriesaxis.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qgroupedbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             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 setAxisX_data();
                 void setAxisX();
                 void setAxisY_data();
                 void setAxisY();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
                 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();
-                */
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
                 m_dataset = new ChartDataSet();
             }
             void tst_ChartDataSet::cleanup()
             {
                 QList<QAbstractSeries*> series = m_dataset->series();
                 foreach(QAbstractSeries* serie, series)
                 {
                     m_dataset->removeSeries(serie);
                 }
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axisX(0) == 0);
             	QVERIFY(m_dataset->axisY(0) == 0);
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(m_dataset->seriesIndex(series),-1);
             	QVERIFY(m_dataset->domain(series) == 0);
             	QVERIFY(m_dataset->axisX(series) == 0);
             	QVERIFY(m_dataset->axisY(series) == 0);
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QGroupedBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
             	QTest::newRow("line") << line;
             	QTest::newRow("area") << area;
             	QTest::newRow("scatter") << scatter;
             	QTest::newRow("spline") << spline;
             	QTest::newRow("pie") << pie;
                 QTest::newRow("bar") << bar;
             	QTest::newRow("percent") << percent;
             	QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 if(series->type()==QAbstractSeries::SeriesTypePie){
                     TRY_COMPARE(spy0.count(), 0);
                 }else{
                     TRY_COMPARE(spy0.count(), 2);
                 }
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::setAxisX_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QGroupedBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
                 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
                 QList<QAbstractAxis*> axes0;
                 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
                 axes0 << axes0.last();
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << axes0 << 2;
                 //TODO: add more test cases
             }
             void tst_ChartDataSet::setAxisX()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::setAxisY_data()
             {
                 setAxisX_data();
             }
             void tst_ChartDataSet::setAxisY()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeSeries(series);
                 TRY_COMPARE(spy0.count(), 0);
                 if (series->type() == QAbstractSeries::SeriesTypePie) {
                     TRY_COMPARE(spy1.count(), 0);
                 }
                 else {
                     TRY_COMPARE(spy1.count(), 2);
                 }
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
                         << new QScatterSeries(this))
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
                         << new QValuesAxis(this)) << 3;
                 //TODO:
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeAllSeries();
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), axisCount);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), seriesList.count());
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<int>("seriesCount");
                 QTest::newRow("line,line, line, spline  3") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) ) << 3;
                 QTest::newRow("scatter,scatter, line, line  2") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(int, seriesCount);
                 foreach(QAbstractSeries* series, seriesList){
                       m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
                 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->removeSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 1)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(2));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->removeSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2 && i != 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(2));
                 m_dataset->addSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i == 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
                     else if (i == 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 QVERIFY(m_dataset->domain(series));
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 QList<QVariant> arguments = spy2.takeFirst();
                 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
                 QVERIFY(m_dataset->domain(series) == domain);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
+                QTest::addColumn<bool >("sameAxis");
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
-                QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
+                QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
+                QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
             }
             void tst_ChartDataSet::zoomInDomain()
             {
+                QFETCH(bool, sameAxis);
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
-                /*
+                if(sameAxis) m_dataset->createDefaultAxes();
-                QValuesAxis* axis = new QValuesAxis();
-                for (int i = 0; i < seriesList.count(); i++) {
-                    m_dataset->setAxisX(seriesList.at(i), axis);
-            */
-                m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 }
                 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll(spyList);
             }
-            /*
             void tst_ChartDataSet::zoomOutDomain_data()
             {
-                addSeries_data();
+                zoomInDomain_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
-                QFETCH(QLineSeries*, series0);
+                QFETCH(bool, sameAxis);
-                QFETCH(QAxis*, axis0);
+                QFETCH(QList<QAbstractSeries*>, seriesList);
-                QFETCH(QLineSeries*, series1);
-                QFETCH(QAxis*, axis1);
-                QFETCH(QLineSeries*, series2);
-                QFETCH(QAxis*, axis2);
-                QFETCH(int, axisCount);
-                Q_UNUSED(axisCount);
+                foreach(QAbstractSeries* series, seriesList) {
+                    m_dataset->addSeries(series);
+                }
-                m_dataset->addSeries(series0, axis0);
+                if (sameAxis)
-                m_dataset->addSeries(series1, axis1);
+                    m_dataset->createDefaultAxes();
-                m_dataset->addSeries(series2, axis2);
-                Domain* domain0 = m_dataset->domain(series0);
+                QList<QSignalSpy*> spyList;
-                Domain* domain1 = m_dataset->domain(series1);
-                Domain* domain2 = m_dataset->domain(series2);
-                QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
+                foreach(QAbstractSeries* series, seriesList) {
-                QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
+                    spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
-                QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
-                m_dataset->zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
+                m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
-                TRY_COMPARE(spy0.count(), 1);
+                foreach(QSignalSpy* spy, spyList) {
-                TRY_COMPARE(spy1.count(), 1);
+                    TRY_COMPARE(spy->count(), 1);
-                TRY_COMPARE(spy2.count(), 1);
+                qDeleteAll (spyList);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
-                addSeries_data();
+                zoomInDomain_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
-                QFETCH(QLineSeries*, series0);
+                QFETCH(bool, sameAxis);
-                QFETCH(QAxis*, axis0);
+                QFETCH(QList<QAbstractSeries*>, seriesList);
-                QFETCH(QLineSeries*, series1);
-                QFETCH(QAxis*, axis1);
+                foreach(QAbstractSeries* series, seriesList) {
-                QFETCH(QLineSeries*, series2);
+                    m_dataset->addSeries(series);
-                QFETCH(QAxis*, axis2);
-                QFETCH(int, axisCount);
-                Q_UNUSED(axisCount);
+                if (sameAxis)
+                    m_dataset->createDefaultAxes();
-                m_dataset->addSeries(series0, axis0);
+                QList<QSignalSpy*> spyList;
-                m_dataset->addSeries(series1, axis1);
-                m_dataset->addSeries(series2, axis2);
-                Domain* domain0 = m_dataset->domain(series0);
+                foreach(QAbstractSeries* series, seriesList) {
-                Domain* domain1 = m_dataset->domain(series1);
+                    spyList
-                Domain* domain2 = m_dataset->domain(series2);
+                        << new QSignalSpy(m_dataset->domain(series),
+                            SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
+                }
-                QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
+                m_dataset->scrollDomain(10, 10, QSize(1000, 1000));
-                QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
-                QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
-                m_dataset->scrollDomain(10,10,QSize(1000,1000));
+                foreach(QSignalSpy* spy, spyList) {
+                    TRY_COMPARE(spy->count(), 1);
+                }
-                TRY_COMPARE(spy0.count(), 1);
+                qDeleteAll(spyList);
-                TRY_COMPARE(spy1.count(), 1);
-                TRY_COMPARE(spy2.count(), 1);
             }
-            */
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.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