HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2280:75ed5c985850

Log domains zoomin, zoomout and move added

Marek Rosa -

r2280:75ed5c985850

parent child

Context file:

r2280:75ed5c985850

Collapse all files

src/chartdataset.cpp +3 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 "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()
             {
                 removeAllSeries();
                 removeAllAxes();
             }
             /*
              * 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.clear();
                 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 attach 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;
                 QSharedPointer<AbstractDomain> domain =  series->d_ptr->m_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 already attached to series.");
                     return false;
                 }
                 Q_ASSERT(!attachedSeriesList.contains(series));
                 Q_ASSERT(!domain.isNull());
                 if(attachedSeriesList.isEmpty()){
                 }else{
                     domain = attachedSeriesList.first()->d_ptr->domain();
                     Q_ASSERT(!domain.isNull());
                     series->d_ptr->setDomain(domain);
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain.data());
                 if(axis->orientation()==Qt::Vertical){
                     QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
                     QObject::connect(domain.data(), 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)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
                     QObject::connect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
                 }
                 return true;
             }
             /*
              * This method detach 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;
                 QSharedPointer<AbstractDomain> domain =  series->d_ptr->m_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));
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
                 if(axis->orientation()==Qt::Vertical){
                     QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
                     QObject::disconnect(domain.data(), 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)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
                     QObject::disconnect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
                 }
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 removeAllAxes();
                 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::removeAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList)
                     removeSeries(s);
                 Q_ASSERT(m_seriesList.count() == 0);
                 qDeleteAll(m_seriesList);
             }
             void ChartDataSet::removeAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList)
                     removeAxis(a);
                 Q_ASSERT(m_axisList.count() == 0);
                 qDeleteAll(m_axisList);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             QList<QAbstractAxis*> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/abstractdomain.cpp 0 -106

             /****************************************************************************
             **
             ** 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)
             {
             }
             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::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
-            //{
-            //    bool axisXChanged = false;
-            //    bool axisYChanged = false;
-            //    if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
-            //        m_minX = minX;
-            //        m_maxX = maxX;
-            //        axisXChanged = true;
-            //        emit rangeHorizontalChanged(m_minX, m_maxX);
-            //    }
-            //    if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
-            //        m_minY = minY;
-            //        m_maxY = maxY;
-            //        axisYChanged = true;
-            //        emit rangeVerticalChanged(m_minY, m_maxY);
-            //    }
-            //    if (axisXChanged || axisYChanged)
-            //        emit updated();
-            //}
             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() ;
             }
-            void AbstractDomain::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 AbstractDomain::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 AbstractDomain::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 AbstractDomain::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> AbstractDomain::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 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);
             }
             void AbstractDomain::handleHorizontalAxisRangeChanged(qreal min, qreal max)
             {
                 if(!m_axisSignalsBlocked)
                     setRangeX(min, max);
             }
             void AbstractDomain::blockAxisSignals(bool block)
             {
                 m_axisSignalsBlocked=block;
             }
             //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;
             }
             // 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 QTCOMMERCIALCHART_AUTOTEST_EXPORT AbstractDomain: public QObject
             {
                 Q_OBJECT
             public:
                 explicit AbstractDomain(QObject *object = 0);
                 virtual ~AbstractDomain();
                 void setSize(const QSizeF& size);
                 QSizeF size() const;
                 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);
                 bool axisSignalsBlocked() const { return m_axisSignalsBlocked; }
                 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);
-                void zoomIn(const QRectF &rect);
+                virtual void zoomIn(const QRectF &rect) = 0;
-                void zoomOut(const QRectF &rect);
+                virtual void zoomOut(const QRectF &rect) = 0;
-                void move(qreal dx, qreal dy);
+                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;
                 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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTDOMAIN_H

src/domain/logxlogydomain.cpp +25 -37

             /****************************************************************************
             **
             ** 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 "logxlogydomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LogXLogYDomain::LogXLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinX(0),
                   m_logMaxX(1),
                   m_logBaseX(10),
                   m_logMinY(0),
                   m_logMaxY(1),
                   m_logBaseY(10)
             {
             }
             LogXLogYDomain::~LogXLogYDomain()
             {
             }
             void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     m_logMinX = log10(m_minX) / log10(m_logBaseX);
                     m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     m_logMinY = log10(m_minY) / log10(m_logBaseY);
                     m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXLogYDomain::zoomIn(const QRectF &rect)
             {
-                qreal dx = spanX() / m_size.width();
+                qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
-                qreal dy = spanY() / m_size.height();
+                qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
+                qreal minX = qPow(m_logBaseX, newLogMinX);
+                qreal maxX = qPow(m_logBaseX, newLogMaxX);
-                qreal maxX = m_maxX;
+                qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
-                qreal minX = m_minX;
+                qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
-                qreal minY = m_minY;
+                qreal minY = qPow(m_logBaseY, newLogMinY);
-                qreal maxY = m_maxY;
+                qreal maxY = qPow(m_logBaseY, newLogMaxY);
-                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 LogXLogYDomain::zoomOut(const QRectF &rect)
             {
-                qreal dx = spanX() / rect.width();
+                qreal ratioX = m_size.width()/rect.width();
-                qreal dy = spanY() / rect.height();
+                qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
+                qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
-                qreal maxX = m_maxX;
+                qreal minX = qPow(m_logBaseX, newLogMinX);
-                qreal minX = m_minX;
+                qreal maxX = qPow(m_logBaseX, newLogMaxX);
-                qreal minY = m_minY;
-                qreal maxY = m_maxY;
+                qreal ratioY = m_size.height()/rect.height();
+                qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
-                minX = maxX - dx * rect.right();
+                qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
-                maxX = minX + dx * m_size.width();
+                qreal minY = qPow(m_logBaseY, newLogMinY);
-                maxY = minY + dy * rect.bottom();
+                qreal maxY = qPow(m_logBaseY, newLogMaxY);
-                minY = maxY - dy * m_size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXLogYDomain::move(qreal dx, qreal dy)
             {
-                qreal x = spanX() / m_size.width();
+                qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
-                qreal y = spanY() / m_size.height();
+                qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
+                qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
-                qreal maxX = m_maxX;
+                qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
-                qreal minX = m_minX;
+                qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
-                qreal minY = m_minY;
+                qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
-                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 LogXLogYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
                 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
                     qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF LogXLogYDomain::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 LogXLogYDomain &domain1, const LogXLogYDomain &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 LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_logxlogydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxydomain.cpp +15 -20

             /****************************************************************************
             **
             ** 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 "logxydomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LogXYDomain::LogXYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinX(0),
                   m_logMaxX(1),
                   m_logBaseX(10)
             {
             }
             LogXYDomain::~LogXYDomain()
             {
             }
             void LogXYDomain::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;
                     m_logMinX = log10(m_minX) / log10(m_logBaseX);
                     m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXYDomain::zoomIn(const QRectF &rect)
             {
-                qreal dx = spanX() / m_size.width();
+                qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
-                qreal dy = spanY() / m_size.height();
+                qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
+                qreal minX = qPow(m_logBaseX, newLogMinX);
+                qreal maxX = qPow(m_logBaseX, newLogMaxX);
-                qreal maxX = m_maxX;
+                qreal dy = spanY() / m_size.height();
-                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 LogXYDomain::zoomOut(const QRectF &rect)
             {
-                qreal dx = spanX() / rect.width();
+                qreal ratioX = m_size.width()/rect.width();
-                qreal dy = spanY() / rect.height();
+                qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
+                qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
+                qreal minX = qPow(m_logBaseX, newLogMinX);
+                qreal maxX = qPow(m_logBaseX, newLogMaxX);
-                qreal maxX = m_maxX;
+                qreal dy = spanY() / rect.height();
-                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 LogXYDomain::move(qreal dx, qreal dy)
             {
-                qreal x = spanX() / m_size.width();
+                qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
-                qreal y = spanY() / m_size.height();
+                qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
+                qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
-                qreal maxX = m_maxX;
+                qreal y = spanY() / m_size.height();
-                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 LogXYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 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 = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
                     qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF LogXYDomain::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 LogXYDomain &domain1, const LogXYDomain &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 LogXYDomain &domain1, const LogXYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_logxydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/xlogydomain.cpp +16 -20

             /****************************************************************************
             **
             ** 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 "xlogydomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XLogYDomain::XLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinY(0),
                   m_logMaxY(1),
                   m_logBaseY(10)
             {
             }
             XLogYDomain::~XLogYDomain()
             {
             }
             void XLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     m_logMinY = log10(m_minY) / log10(m_logBaseY);
                     m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XLogYDomain::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();
+                qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
+                qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
+                qreal minY = qPow(m_logBaseY, newLogMinY);
+                qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::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();
+                qreal ratioY = m_size.height()/rect.height();
+                qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
+                qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
+                qreal minY = qPow(m_logBaseY, newLogMinY);
+                qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::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;
+                qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
-                    maxY = maxY + y * dy;
+                qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
+                qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF XLogYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 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 = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XLogYDomain::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 XLogYDomain &domain1, const XLogYDomain &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 XLogYDomain &domain1, const XLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_xlogydomain_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