HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1738:0029a831c085

Fixes nicenumbers missing update issue

Michal Klocek -

r1738:0029a831c085

parent child

Context file:

r1738:0029a831c085

Collapse all files

src/axis/valuesaxis/qvaluesaxis.cpp +11 -8

             /****************************************************************************
             **
             ** 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 "domain_p.h"
             #include "chartdataset_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValuesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
             */
             /*!
                 \qmlclass ValuesAxis QValuesAxis
                 \brief The ValuesAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValuesAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(real 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.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(real 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 ValuesAxis::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 ValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValuesAxis::~QValuesAxis()
             {
                 Q_D(QValuesAxis);
                 if(d->m_dataset) {
                     d->m_dataset->removeAxis(this);
                 }
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
-                if(max<min) return;
                 Q_D(QValuesAxis);
                 bool changed = false;
-                if (min > max)
+                if (min > max) return;
-                    return;
+                if(d->m_niceNumbers) {
+                    int ticks = d->m_tickCount;
+                    d->looseNiceNumbers(min, max, ticks);
+                    if(ticks!=d->m_tickCount) setTicksCount(ticks);
+                }
                 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(d->m_niceNumbers) d->looseNiceNumbers(d->m_min, d->m_max, d->m_tickCount);
                 if (changed) {
-                    emit rangeChanged(d->m_min,d->m_max);
+                    emit rangeChanged(min,max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_tickCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
-                    if(enable && !qFuzzyIsNull(d->m_max - d->m_min)) setRange(d->min(),d->max());
+                    if(enable && !qFuzzyIsNull(d->m_max - d->m_min)) {
+                        setRange(d->m_min,d->m_max);
+                    }
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0),
                 m_max(0),
                 m_tickCount(5),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleDomainUpdated()
             {
                Q_Q(QValuesAxis);
                Domain* domain = qobject_cast<Domain*>(sender());
                Q_ASSERT(domain);
                if(orientation()==Qt::Horizontal){
                    q->setRange(domain->minX(),domain->maxX());
                }else if(orientation()==Qt::Vertical){
                    q->setRange(domain->minY(),domain->maxY());
                }
             }
             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)
             {
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             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::intializeDomain(Domain* domain)
             {
                 Q_Q(QValuesAxis);
                 if(qFuzzyCompare(m_max,m_min)) {
                     if(m_orientation==Qt::Vertical){
                         q->setRange(domain->minY(),domain->maxY());
                     }else{
                         q->setRange(domain->minX(), domain->maxX());
                     }
                 } else {
                     if(m_orientation==Qt::Vertical){
                         domain->setRangeY(m_min, m_max);
                     }else{
                         domain->setRangeX(m_min, m_max);
                     }
                 }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void QValuesAxisPrivate::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const
             {
                 qreal range = niceNumber(max-min,true); //range with ceiling
                 qreal step = niceNumber(range/(ticksCount-1),false);
                 min = qFloor(min/step);
                 max = qCeil(max/step);
                 ticksCount = int(max-min) +1;
                 min*=step;
                 max*=step;
             }
             //nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
             qreal QValuesAxisPrivate::niceNumber(qreal x,bool ceiling) const
             {
                 qreal z = qPow(10,qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x/z;//q<10 && q>=1;
                 if(ceiling) {
                     if(q <= 1.0) q=1;
                     else if(q <= 2.0) q=2;
                     else if(q <= 5.0) q=5;
                     else q=10;
                 }
                 else {
                     if(q < 1.5) q=1;
                     else if(q < 3.0) q=2;
                     else if(q < 7.0) q=5;
                     else q=10;
                 }
                 return q*z;
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +14 -2

             /****************************************************************************
             **
             ** 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 "qbarcategoriesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "qintervalsaxis.h"
             #include "qdatetimeaxis.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)
             {
             }
             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;
                 }
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 createSeriesIndex(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 if(!m_seriesDomainMap.contains(series)) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 Domain* domain = m_seriesDomainMap.take(series);
                 delete domain;
                 domain = 0;
                 removeSeriesIndex(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 removeAxes(series);
             }
             void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
             {
                 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);
             }
             void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
             {
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
             }
             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->defaultAxisType(Qt::Horizontal);
                     if(axisY) typeY&=axisY->type();
                     else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 createAxes(typeX,Qt::Horizontal);
                 createAxes(typeY,Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     while (i.hasNext()) {
                         i.next();
                         QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation);
                         if(!axis) continue;
                         initializeAxis(axis,i.key());
                         emit axisAdded(axis,i.value());
                     }
                 }
                 else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation);
                     i.toFront();
                     while (i.hasNext()) {
                         i.next();
                         initializeAxis(axis,i.key());
                     }
                     emit axisAdded(axis,i.value());
                 }
             }
             QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation)
             {
                 QAbstractAxis* axis =0;
                 switch(type) {
                 case QAbstractAxis::AxisTypeValues:
                     axis = new QValuesAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeCategories:
                     axis = new QBarCategoriesAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeIntervals:
                     axis = new QIntervalsAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
                 default:
                     axis = 0;
                     break;
                 }
                 if(axis)
                     axis->d_ptr->setOrientation(orientation);
                 return axis;
             }
             void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 axis->d_ptr->m_dataset = this;
                 axis->d_ptr->intializeDomain(domain);
                 series->d_ptr->initializeAxis(axis);
                 if(axis->orientation()==Qt::Horizontal) {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisXMap.insert(series,axis);
                 }
                 else {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisYMap.insert(series,axis);
                 }
                 axis->d_ptr->emitUpdated();
             }
             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->d_ptr->m_dataset=0;
                         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->d_ptr->m_dataset=0;
                         axisY->deleteLater();
                     }
                 }
             }
             void ChartDataSet::removeAxis(QAbstractAxis* axis)
             {
                 if(!axis->d_ptr->m_dataset) {
                     qWarning()<<"UnBound axis found !";
                     return;
                 }
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(axis->orientation()==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }
                 else {
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==axis) {
                         removeSeries(i.key());
                     }
                 }
             }
             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->d_ptr->blockSignals(enabled);
+                    if(axisX) {
-                    if(axisY) axisY->d_ptr->blockSignals(enabled);
+                        axisX->d_ptr->blockSignals(enabled);
+                        if(!enabled) {
+                            axisX->d_ptr->setDirty(false);
+                            axisX->d_ptr->emitUpdated();
+                        }
+                    }
+                    if(axisY) {
+                        axisY->d_ptr->blockSignals(enabled);
+                        if(!enabled) {
+                            axisY->d_ptr->setDirty(false);
+                            axisY->d_ptr->emitUpdated();
+                        }
+                    }
                 }
             }
             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) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
             {
                 Q_ASSERT(axis);
                 if(!series) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 axis->d_ptr->setOrientation(orientation);
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(orientation==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }else{
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
                 QList<QAbstractAxis*> axes = seriesAxisMap->values();
                 if(oldAxis) {
                     if(axes.indexOf(oldAxis)==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->disconnect();
                         QObject::disconnect(domain,0,oldAxis,0);
                         oldAxis->d_ptr->m_dataset=0;
                         oldAxis->deleteLater();
                     }
                 }
                 if(axes.indexOf(axis)==-1) {
                     initializeAxis(axis,series);
                     emit axisAdded(axis,domain);
                 }else{
                     initializeAxis(axis,series);
                 }
             }
             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_seriesDomainMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qvaluesaxis/tst_qvaluesaxis.cpp +12 -9

             /****************************************************************************
              **
              ** 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 "../qabstractaxis/tst_qabstractaxis.h"
             #include "qvaluesaxis.h"
             #include <qlineseries.h>
             class tst_QValuesAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qvaluesaxis_data();
                 void qvaluesaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void niceNumbersEnabled_data();
                 void niceNumbersEnabled();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void ticksCount_data();
                 void ticksCount();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
             private:
                 QValuesAxis* m_valuesaxis;
                 QLineSeries* m_series;
             };
             void tst_QValuesAxis::initTestCase()
             {
             }
             void tst_QValuesAxis::cleanupTestCase()
             {
             }
             void tst_QValuesAxis::init()
             {
                 m_valuesaxis = new QValuesAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_valuesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QValuesAxis::cleanup()
             {
                 delete m_series;
                 delete m_valuesaxis;
                 m_series = 0;
                 m_valuesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
             void tst_QValuesAxis::qvaluesaxis_data()
             {
             }
             void tst_QValuesAxis::qvaluesaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->ticksCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValues);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->ticksCount(), 5);
             }
             void tst_QValuesAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << 1.0;
                 QTest::newRow("50.0") << 50.0;
                 QTest::newRow("101.0") << 101.0;
             }
             void tst_QValuesAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMax(max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValuesAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QValuesAxis::max()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QValuesAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QValuesAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QValuesAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << -1.0;
                 QTest::newRow("-50.0") << -50.0;
                 QTest::newRow("-101.0") << -101.0;
             }
             void tst_QValuesAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMin(min);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValuesAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QValuesAxis::min()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QValuesAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QValuesAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QValuesAxis::niceNumbersEnabled_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("ticks");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<int>("expectedTicks");
                 QTest::newRow("true 0.1 , 99.0 , 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 1 , 10.0 , 5") << true << 1.0 << 10.0 << 5 << 0.0 << 10.0 << 6;
                 QTest::newRow("true 0.1 , 6.6 , 5") << true << 0.1 << 6.6 << 5 << 0.0 << 8.0 << 5;
                 QTest::newRow("false 0.1 , 6.6 , 5") << false << 0.1 << 6.6 << 5 << 0.1 << 6.6 << 5;
                 QTest::newRow("true 0.1, 99, 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 5, 93.5 , 5") << true << 5.0 << 93.5 << 5 << 0.0 << 100.0 << 6;
             }
             void tst_QValuesAxis::niceNumbersEnabled()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, ticks);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(int, expectedTicks);
+                m_valuesaxis->setRange(min, max);
+                m_valuesaxis->setTicksCount(ticks);
+                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
-                QCOMPARE(spy0.count(), 0);
+                if(!qFuzzyIsNull(expectedMin - min))
-                QCOMPARE(spy1.count(), 0);
+                    QCOMPARE(spy1.count(), 1);
-                QCOMPARE(spy2.count(), 0);
+                if(!qFuzzyIsNull(expectedMax - max))
+                    QCOMPARE(spy0.count(), 1);
+                if((!qFuzzyIsNull(expectedMin - min)) || (!qFuzzyIsNull(expectedMax - max)))
+                    QCOMPARE(spy2.count(), 1);
-                m_valuesaxis->setTicksCount(ticks);
-                m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - expectedMin), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - expectedMax), "Max not equal");
                 QCOMPARE(m_valuesaxis->ticksCount(), expectedTicks);
-                QCOMPARE(spy0.count(), 1);
-                QCOMPARE(spy1.count(), 1);
-                QCOMPARE(spy2.count(), 1);
             }
             void tst_QValuesAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << -1.0 << 101.0;
                 QTest::newRow("25.0 - 75.0") << 25.0 << 75.0;
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
             void tst_QValuesAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValuesAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QValuesAxis::range()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QValuesAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QValuesAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QValuesAxis::ticksCount_data()
             {
                 QTest::addColumn<int>("ticksCount");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("0") << 2;
                 QTest::newRow("1") << 2;
                 QTest::newRow("2") << 2;
                 QTest::newRow("3") << 3;
                 QTest::newRow("-1") << 2;
             }
             void tst_QValuesAxis::ticksCount()
             {
                 QFETCH(int, ticksCount);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setTicksCount(ticksCount);
                 QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
             }
             void tst_QValuesAxis::noautoscale_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << -1.0 << 101.0;
                 QTest::newRow("25.0 - 75.0") << 25.0 << 75.0;
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
             void tst_QValuesAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
             }
             void tst_QValuesAxis::autoscale_data()
             {
             }
             void tst_QValuesAxis::autoscale()
             {
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min()), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max()), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() + 100), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - 100), "Max not equal");
             }
             QTEST_MAIN(tst_QValuesAxis)
             #include "tst_qvaluesaxis.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