HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2289:d4cb0061d8bc

Bugfix resize event during zoomin

Michal Klocek -

r2289:d4cb0061d8bc

parent child

Context file:

r2289:d4cb0061d8bc

Collapse all files

src/chartdataset.cpp +7 -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 "chartdataset_p.h"
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             #ifndef QT_ON_ARM
             #include "qdatetimeaxis.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
                   m_chart(chart)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 deleteAllSeries();
                 deleteAllAxes();
             }
             /*
              * This method adds series to chartdataset, series ownership is taken from caller.
              */
             void ChartDataSet::addSeries(QAbstractSeries *series)
             {
                 if (m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not add series. Series already on the chart.");
                     return;
                 }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = m_chart;
                 emit seriesAdded(series);
             }
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
             void ChartDataSet::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
             {
                 if (m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
                     return;
                 }
                 axis->d_ptr->setAlignment(aligment);
                 if(!axis->alignment()) {
                     qWarning()<< QObject::tr("No alignment specified !");
                     return;
                 };
                 QSharedPointer<AbstractDomain> domain(new XYDomain());
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 axis->d_ptr->m_chart = m_chart;
                 m_axisList.append(axis);
                 emit axisAdded(axis);
             }
             /*
              * This method removes series form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (! m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
                     return;
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_domain.reset(0);
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     axis->d_ptr->m_series.removeAll(series);
                     series->d_ptr->m_axes.removeAll(axis);
                 }
             }
             /*
              * This method removes axis form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (! m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
                     return;
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                    s->d_ptr->m_axes.removeAll(axis);
                    axis->d_ptr->m_series.removeAll(s);
                 }
             }
             /*
              * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 if (attachedSeriesList.contains(series)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 AbstractDomain* domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
                 if(type == AbstractDomain::UndefinedDomain) return false;
                 if(domain->type()!=type){
                     domain =  createDomain(type);
                 }
                 if(!domain) return false;
                 if(!domain->attachAxis(axis)) return false;
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 if(domain!=series->d_ptr->domain()){
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
                 return true;
             }
             /*
              * This method detaches axis to series, return true if success.
              */
             bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 AbstractDomain* domain =  series->d_ptr->domain();
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (!attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis not attached to series.");
                     return false;
                 }
                 Q_ASSERT(axis->d_ptr->m_series.contains(series));
                 domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 deleteAllAxes();
                 Q_ASSERT(m_axisList.isEmpty());
                 // Select the required axis x and axis y types based on the types of the current series
                 foreach(QAbstractSeries* s, m_seriesList) {
                     typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal);
                     typeY |= s->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 // Create the axes of the types selected
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QAbstractAxis *axis = 0;
                 //decide what axis should be created
                 switch (type) {
                     case QAbstractAxis::AxisTypeValue:
                     axis = new QValueAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeBarCategory:
                     axis = new QBarCategoryAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategory:
                     axis = new QCategoryAxis(this);
                     break;
             #ifndef Q_WS_QWS
                     case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
             #endif
                     default:
                     axis = 0;
                     break;
                 }
                 if (axis) {
                     //create one axis for all
                     addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                 }
                 else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                     //create separate axis
                     foreach(QAbstractSeries *s, m_seriesList) {
                         QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
                         if(axis) {
                             addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                             attachAxis(s,axis);
                         }
                     }
                 }
             }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     delete s;
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     delete a;
                 }
                 Q_ASSERT(m_axisList.count() == 0);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
-                    s->d_ptr->m_domain->blockAxisSignals(true);
+                    s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
-                    domain->blockAxisSignals(false);
+                    domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
-                    s->d_ptr->m_domain->blockAxisSignals(true);
+                    s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
-                    domain->blockAxisSignals(false);
+                    domain->blockRangeSignals(false);
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
-                    AbstractDomain* domain = s->d_ptr->m_domain.data();
+                    AbstractDomain* domain = s->d_ptr->domain();
-                    if(domains.contains(domain)) continue;
+                    s->d_ptr->m_domain->blockRangeSignals(true);
-                    s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
-                    domain->blockAxisSignals(false);
+                    domain->blockRangeSignals(false);
             }
             QList<QAbstractAxis*> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis*> axes)
             {
                 enum Type {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 foreach(QAbstractAxis* axis, axes)
                 {
                     switch(axis->type()) {
                         case QAbstractAxis::AxisTypeLogValue:
                         if(axis->orientation()==Qt::Horizontal) {
                             horizontal|=LogType;
                         }
                         if(axis->orientation()==Qt::Vertical) {
                             vertical|=LogType;
                         }
                         break;
                         case QAbstractAxis::AxisTypeValue:
                         case QAbstractAxis::AxisTypeBarCategory:
                         case QAbstractAxis::AxisTypeCategory:
                         case QAbstractAxis::AxisTypeDateTime:
                         if(axis->orientation()==Qt::Horizontal) {
                             horizontal|=ValueType;
                         }
                         if(axis->orientation()==Qt::Vertical) {
                             vertical|=ValueType;
                         }
                         break;
                         default:
                         qWarning()<<"Undefined type";
                         break;
                     }
                 }
                 if(vertical==Undefined) vertical=ValueType;
                 if(horizontal==Undefined) horizontal=ValueType;
                 if(vertical==ValueType && horizontal== ValueType) {
                     return AbstractDomain::XYDomain;
                 }
                 if(vertical==LogType && horizontal== ValueType) {
                     return AbstractDomain::XLogYDomain;
                 }
                 if(vertical==ValueType && horizontal== LogType) {
                     return AbstractDomain::LogXYDomain;
                 }
                 if(vertical==LogType && horizontal== LogType) {
                     return AbstractDomain::LogXLogYDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
             	switch(type)
             	{
             		case AbstractDomain::LogXLogYDomain:
             			return new LogXLogYDomain();
             		case AbstractDomain::XYDomain:
             			return new XYDomain();
             		case AbstractDomain::XLogYDomain:
             			return new XLogYDomain();
             		case AbstractDomain::LogXYDomain:
             			return new LogXYDomain();
             		default:
             			return 0;
             	}
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/abstractdomain.cpp +11 -7

             /****************************************************************************
             **
             ** 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 "abstractdomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractDomain::AbstractDomain(QObject *parent)
                 : QObject(parent),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                   m_maxY(0),
-                  m_axisSignalsBlocked(false)
+                  m_signalsBlocked(false)
             {
             }
             AbstractDomain::~AbstractDomain()
             {
             }
             void AbstractDomain::setSize(const QSizeF& size)
             {
             	if(m_size!=size)
             	{
             		m_size=size;
             		emit updated();
             	}
             }
             QSizeF AbstractDomain::size() const
             {
             	return m_size;
             }
             void AbstractDomain::setRangeX(qreal min, qreal max)
             {
                 setRange(min, max, m_minY, m_maxY);
             }
             void AbstractDomain::setRangeY(qreal min, qreal max)
             {
                 setRange(m_minX, m_maxX, min, max);
             }
             void AbstractDomain::setMinX(qreal min)
             {
                 setRange(min, m_maxX, m_minY, m_maxY);
             }
             void AbstractDomain::setMaxX(qreal max)
             {
                 setRange(m_minX, max, m_minY, m_maxY);
             }
             void AbstractDomain::setMinY(qreal min)
             {
                 setRange(m_minX, m_maxX, min, m_maxY);
             }
             void AbstractDomain::setMaxY(qreal max)
             {
                 setRange(m_minX, m_maxX, m_minY, max);
             }
             qreal AbstractDomain::spanX() const
             {
                 Q_ASSERT(m_maxX >= m_minX);
                 return m_maxX - m_minX;
             }
             qreal AbstractDomain::spanY() const
             {
                 Q_ASSERT(m_maxY >= m_minY);
                 return m_maxY - m_minY;
             }
             bool AbstractDomain::isEmpty() const
             {
                 return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY()) || m_size.isEmpty() ;
             }
             QPointF AbstractDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             // handlers
             void AbstractDomain::handleVerticalAxisRangeChanged(qreal min, qreal max)
             {
-                if(!m_axisSignalsBlocked)
+                setRangeY(min, max);
-                    setRangeY(min, max);
             }
             void AbstractDomain::handleHorizontalAxisRangeChanged(qreal min, qreal max)
             {
-                if(!m_axisSignalsBlocked)
+                setRangeX(min, max);
-                    setRangeX(min, max);
             }
-            void AbstractDomain::blockAxisSignals(bool block)
+            void AbstractDomain::blockRangeSignals(bool block)
             {
-                m_axisSignalsBlocked=block;
+                if(m_signalsBlocked!=block){
+                    m_signalsBlocked=block;
+                    if(!block) {
+                        emit rangeHorizontalChanged(m_minX,m_maxX);
+                        emit rangeVerticalChanged(m_minY,m_maxY);
+                    }
+                }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void AbstractDomain::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount)
             {
                 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 AbstractDomain::niceNumber(qreal x, bool ceiling)
             {
                 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;
             }
             bool AbstractDomain::attachAxis(QAbstractAxis* axis)
             {
             	if(axis->orientation()==Qt::Vertical) {
             		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
             		QObject::connect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             	if(axis->orientation()==Qt::Horizontal) {
             		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
             		QObject::connect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             	return true;
             }
             bool AbstractDomain::detachAxis(QAbstractAxis* axis)
             {
             	if(axis->orientation()==Qt::Vertical) {
             		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
             		QObject::disconnect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             	if(axis->orientation()==Qt::Horizontal) {
             		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
             		QObject::disconnect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
             	}
             	return true;
             }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
                         qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
                         qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
                         qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_abstractdomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/abstractdomain_p.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef ABSTRACTDOMAIN_H
             #define ABSTRACTDOMAIN_H
             #include "qchartglobal.h"
             #include <QRectF>
             #include <QSizeF>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT AbstractDomain: public QObject
             {
                 Q_OBJECT
             public:
                 enum DomainType { UndefinedDomain, XYDomain, XLogYDomain, LogXYDomain, LogXLogYDomain };
             public:
                 explicit AbstractDomain(QObject *object = 0);
                 virtual ~AbstractDomain();
                 void setSize(const QSizeF& size);
                 QSizeF size() const;
                 virtual DomainType type() = 0;
                 virtual void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY) = 0;
                 void setRangeX(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const { return m_minX; }
                 qreal maxX() const { return m_maxX; }
                 qreal minY() const { return m_minY; }
                 qreal maxY() const { return m_maxY; }
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
-                void blockAxisSignals(bool block);
+                void blockRangeSignals(bool block);
-                bool axisSignalsBlocked() const { return m_axisSignalsBlocked; }
+                bool rangeSignalsBlocked() const { return m_signalsBlocked; }
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain);
                 virtual void zoomIn(const QRectF &rect) = 0;
                 virtual void zoomOut(const QRectF &rect) = 0;
                 virtual void move(qreal dx, qreal dy) = 0;
                 virtual QPointF calculateGeometryPoint(const QPointF &point) const = 0;
                 virtual QPointF calculateDomainPoint(const QPointF &point) const = 0;
                 virtual QVector<QPointF> calculateGeometryPoints(const QList<QPointF>& vector) const = 0;
                 virtual bool attachAxis(QAbstractAxis* axis);
                 virtual bool detachAxis(QAbstractAxis* axis);
                 static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 static qreal niceNumber(qreal x, bool ceiling);
             Q_SIGNALS:
                 void updated();
                 void rangeHorizontalChanged(qreal min, qreal max);
                 void rangeVerticalChanged(qreal min, qreal max);
             public Q_SLOTS:
                 void handleVerticalAxisRangeChanged(qreal min,qreal max);
                 void handleHorizontalAxisRangeChanged(qreal min,qreal max);
             protected:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QSizeF m_size;
-                bool m_axisSignalsBlocked;
+                bool m_signalsBlocked;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTDOMAIN_H

src/domain/xydomain.cpp +4 -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 "xydomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYDomain::XYDomain(QObject *parent)
                 : AbstractDomain(parent)
             {
             }
             XYDomain::~XYDomain()
             {
             }
             void XYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
-                    emit rangeHorizontalChanged(m_minX, m_maxX);
+                    if(!m_signalsBlocked)
+                        emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyCompare(m_minY, minY) || !qFuzzyCompare(m_maxY, maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
-                    emit rangeVerticalChanged(m_minY, m_maxY);
+                    if(!m_signalsBlocked)
+                        emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XYDomain::zoomIn(const QRectF &rect)
             {
                 qreal dx = spanX() / m_size.width();
                 qreal dy = spanY() / m_size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 setRange(minX, maxX, minY, maxY);
             }
             void XYDomain::zoomOut(const QRectF &rect)
             {
                 qreal dx = spanX() / rect.width();
                 qreal dy = spanY() / rect.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * m_size.width();
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * m_size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void XYDomain::move(qreal dx, qreal dy)
             {
                 qreal x = spanX() / m_size.width();
                 qreal y = spanY() / m_size.height();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 if (dy != 0) {
                     minY = minY + y * dy;
                     maxY = maxY + y * dy;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF XYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> XYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     qreal x = (vector[i].x() - m_minX) * deltaX;
                     qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XYDomain &domain1, const XYDomain &domain2)
             {
                 return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&
                         qFuzzyCompare(domain1.m_maxY, domain2.m_maxY) &&
                         qFuzzyCompare(domain1.m_minX, domain2.m_minX) &&
                         qFuzzyCompare(domain1.m_minY, domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XYDomain &domain1, const XYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_xydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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