HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2288:a12d6a605fab

Fix domain switching

Michal Klocek -

r2288:a12d6a605fab

parent child

Context file:

r2288:a12d6a605fab

Collapse all files

src/chartdataset.cpp +22 -5

             /****************************************************************************
             **
             ** 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);
                     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->domain();
                     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;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis*> axes)
             {
                 enum Type {
+                    Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
-                int horizontal(ValueType);
+                int horizontal(Undefined);
-                int vertical(ValueType);
+                int vertical(Undefined);
                 foreach(QAbstractAxis* axis, axes)
                 {
                     switch(axis->type()) {
                         case QAbstractAxis::AxisTypeLogValue:
-                            axis->orientation()==Qt::Horizontal?horizontal:vertical|=LogType;
+                        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:
-                            axis->orientation()==Qt::Horizontal?horizontal:vertical|=ValueType;
+                        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/chartpresenter.cpp 0 -4

             /****************************************************************************
              **
              ** 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "chartitem_p.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             #include "chartbackground_p.h"
             #include "chartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
                   m_layout(new ChartLayout(this)),
                   m_background(0),
                   m_title(0)
             {
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
             	if(m_rect != rect) {
             		m_rect=rect;
             		foreach (ChartItem *chart, m_chartItems){
             			chart->domain()->setSize(rect.size());
             			chart->setPos(rect.topLeft());
             		}
             	}
             }
             QRectF ChartPresenter::geometry() const
             {
             	return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
-                qDebug()<<__FUNCTION__;
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
                 ChartAxis *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
-                qDebug()<<__FUNCTION__;
                 ChartAxis *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
-                qDebug()<<__FUNCTION__;
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
-                qDebug()<<__FUNCTION__;
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     m_options = options;
                     foreach(QAbstractSeries* series, m_series){
                         series->d_ptr->initializeAnimations(m_options);
                     }
                     foreach(QAbstractAxis* axis, m_axes){
                         axis->d_ptr->initializeAnimations(m_options);
                     }
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen);
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                 m_animations.removeAll(qobject_cast<ChartAnimation *>(sender()));
                 if (m_animations.empty())
                     emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()), this, SLOT(handleAnimationFinished()), Qt::UniqueConnection);
                 if (!m_animations.isEmpty())
                     m_animations.append(animation);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return m_title->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             ChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QList<ChartAxis *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxlogydomain.cpp +2 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 "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);
+                    if(!m_signalsBlocked)
                     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);
+                    if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXLogYDomain::zoomIn(const QRectF &rect)
             {
                 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 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 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 LogXLogYDomain::zoomOut(const QRectF &rect)
             {
                 qreal ratioX = m_size.width()/rect.width();
                 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 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 LogXLogYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
                 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
                 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
                 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
                 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
                 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
                 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 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 = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
                 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
                 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 +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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);
+                    if(!m_signalsBlocked)
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
+                    if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXYDomain::zoomIn(const QRectF &rect)
             {
                 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 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 dy = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::zoomOut(const QRectF &rect)
             {
                 qreal ratioX = m_size.width()/rect.width();
                 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 dy = spanY() / rect.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * m_size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
                 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
                 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
                 qreal y = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 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 leftEdgeX= 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 = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
                 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 +2 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 "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;
+                    if(!m_signalsBlocked)
                     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);
+                    if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XLogYDomain::zoomIn(const QRectF &rect)
             {
                 qreal dx = spanX() / m_size.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 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 maxX = m_maxX;
                 qreal minX = m_minX;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * m_size.width();
                 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 maxX = m_maxX;
                 qreal minX = m_minX;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
                 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 leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
                 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