HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1267:e23f2bdfce30

Fix precision issue when scrolling domain

Michal Klocek -

r1267:e23f2bdfce30

parent child

Context file:

r1267:e23f2bdfce30

Collapse all files

src/chartdataset.cpp +1 -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 "chartdataset_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QAxis(this)),
                 m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false),
                 m_axisYInitialized(false)
             {
                 //create main domain
                 Domain* domain = new Domain(m_axisY);
                 m_axisDomainMap.insert(m_axisY,domain);
                 QObject::connect(m_axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(m_axisX->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),m_axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),m_axisX->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    m_axisXInitialized=true;
                    emit axisAdded(m_axisX,domain);
                 }
                 if(!m_axisYInitialized && axisY==m_axisY){
                    m_axisYInitialized=true;
                    emit axisAdded(m_axisY,domain);
                 }
                 series->d_ptr->scaleDomain(*domain);
                 // Note that with SeriesTypeBar we don't set up categories, but use real values on x-asis
                 if(series->type() == QAbstractSeries::SeriesTypeGroupedBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 series->d_ptr->m_dataset=this;
                 emit seriesAdded(series,domain);
             }
             QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 series->d_ptr->m_dataset=0;
                 QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=m_axisY){
                         axis->setParent(0);
                         delete domain;
                     }else{
                         m_axisYInitialized=false;
                         m_axisDomainMap.insert(m_axisY,domain);
                     }
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
                     QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==1);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomIn(rect,size);
                 }
                 domain->zoomIn(rect,size);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 Q_ASSERT(domain);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->zoomOut(rect,size);
                 }
                 domain->zoomOut(rect,size);
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
-            void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
+            void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
                 //main domain has to be the last one;
                 Domain *domain = m_axisDomainMap.value(axisY());
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==domain) continue;
                     i.value()->move(dx,dy,size);
                 }
                 domain->move(dx,dy,size);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesAxisMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +1 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include "qabstractseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
             class QBarSeries;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries* series,QAxis *axisY = 0);
                 QAxis* removeSeries(QAbstractSeries* series);
                 void removeAllSeries();
                 void updateSeries(QAbstractSeries* series);
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
-                void scrollDomain(int dx,int dy,const QSizeF& size);
+                void scrollDomain(qreal dx,qreal dy,const QSizeF& size);
                 int seriesCount(QAbstractSeries::SeriesType type);
                 int seriesIndex(QAbstractSeries *series);
                 Domain* domain(QAbstractSeries* series) const;
                 Domain* domain(QAxis* axis) const;
                 QAxis* axisX() const { return m_axisX; }
                 QAxis* axisY(QAbstractSeries *series = 0) const;
                 QList<QAbstractSeries*> series() const;
             Q_SIGNALS:
                 void seriesAdded(QAbstractSeries* series, Domain* domain);
                 void seriesRemoved(QAbstractSeries* series);
                 void seriesUpdated(QAbstractSeries* series);
                 void axisAdded(QAxis* axis,Domain* domain);
                 void axisRemoved(QAxis* axis);
             private:
                 QStringList createLabels(QAxis* axis,qreal min, qreal max);
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
                 QMap<QAbstractSeries *, QAxis *> m_seriesAxisMap;
                 QMap<QAxis*, Domain *> m_axisDomainMap;
                 QMap<int, QAbstractSeries *> m_indexSeriesMap;
                 QAxis* m_axisX;
                 QAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
                 bool m_axisYInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartpresenter.cpp +1 -2

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             #include "chartaxisx_p.h"
             #include "chartaxisy_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
             m_state(ShowState),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
             void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
                 ChartAxis* item;
                 if(axis == m_dataset->axisX()){
                     item = new ChartAxisX(axis,this);
                 }else{
                     item = new ChartAxisY(axis,this);
                 }
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     item->setAnimator(m_animator);
                     item->setAnimation(new AxisAnimation(item));
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
                 // We do not want "force" to stay on.
                 // Bar/pie are calling decorate when adding/removing slices/bars which means
                 // that to preserve users colors "force" must not be on.
                 m_chartTheme->setForced(false);
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
                 foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
             //        m_dataset->removeSeries(series);
             //        m_dataset->addSeries(series);
                 }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = chartGeometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
                 m_statePoint = QPointF(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
                 m_dataset->zoomInDomain(r,chartGeometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
                 m_state = ZoomOutState;
                 QRectF chartRect;
                 chartRect.setSize(chartGeometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
                 m_statePoint = QPointF(rect.center().x()/chartGeometry().width(),rect.center().y()/chartGeometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
-            void ChartPresenter::scroll(int dx,int dy)
+            void ChartPresenter::scroll(qreal dx,qreal dy)
             {
                 if(dx<0) m_state=ScrollLeftState;
                 if(dx>0) m_state=ScrollRightState;
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
                 m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect && chartRect.isValid()){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->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()));
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +1 -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$
             **
             ****************************************************************************/
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartAnimation;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn(qreal factor);
                 void zoomIn(const QRectF& rect);
                 void zoomOut(qreal factor);
-                void scroll(int dx,int dy);
+                void scroll(qreal dx,qreal dy);
                 void setGeometry(const QRectF& rect);
                 QRectF chartGeometry() const { return m_chartRect; }
                 void setMinimumMarginHeight(ChartAxis* axis, qreal height);
                 void setMinimumMarginWidth(ChartAxis* axis, qreal width);
                 qreal minimumLeftMargin() const { return m_minLeftMargin; }
                 qreal minimumBottomMargin() const { return m_minBottomMargin; }
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
             public: //TODO: fix me
                 void resetAllElements();
                 void createChartBackgroundItem();
                 void createChartTitleItem();
                 QRectF margins() const { return m_chartMargins;}
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAxis* axis);
                 void updateLayout();
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
                 void animationsFinished();
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries *, Chart *> m_chartItems;
                 QMap<QAxis *, ChartAxis *> m_axisItems;
                 QRectF m_rect;
                 QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 qreal m_minLeftMargin;
                 qreal m_minBottomMargin;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
             public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/domain.cpp +1 -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 "domain_p.h"
             #include <cmath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Domain::Domain(QObject* parent) : QObject(parent),
                 m_minX(0),
                 m_maxX(0),
                 m_minY(0),
                 m_maxY(0),
                 m_tickXCount(5),
                 m_tickYCount(5),
                 m_niceXNumbers(false),
                 m_niceYNumbers(false)
             {
             }
             Domain::~Domain()
             {
             }
             void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 setRange(minX, maxX, minY, maxY,m_tickXCount,m_tickYCount);
             }
             void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY,int tickXCount,int tickYCount)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if(m_tickXCount!=tickXCount) {
                     m_tickXCount=tickXCount;
                     axisXChanged=true;
                 }
                 if(m_tickYCount!=tickYCount) {
                     m_tickYCount=tickYCount;
                     axisYChanged=true;
                 }
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     if(m_niceXNumbers) looseNiceNumbers(minX, maxX, m_tickXCount);
                     m_minX=minX;
                     m_maxX=maxX;
                     axisXChanged=true;
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     if(m_niceYNumbers) looseNiceNumbers(minY, maxY, m_tickYCount);
                     m_minY=minY;
                     m_maxY=maxY;
                     axisYChanged=true;
                 }
                 if(axisXChanged || axisYChanged) {
                     emit this->domainChanged(m_minX, m_maxX, m_minY, m_maxY);
                 }
                 if(axisXChanged) {
                     emit rangeXChanged(minX,maxX, m_tickXCount);
                 }
                 if(axisYChanged) {
                     emit rangeYChanged(minY,maxY, m_tickYCount);
                 }
             }
             void Domain::setRangeX(qreal min, qreal max)
             {
                 setRange(min,max,m_minY, m_maxY);
             }
             void Domain::setRangeX(qreal min, qreal max, int tickCount)
             {
                 setRange(min,max,m_minY, m_maxY,tickCount,m_tickYCount);
             }
             void Domain::setRangeY(qreal min, qreal max)
             {
                 setRange(m_minX, m_maxX, min, max);
             }
             void Domain::setRangeY(qreal min, qreal max,int tickCount)
             {
                 setRange(m_minX, m_maxX, min, max,m_tickXCount,tickCount);
             }
             void Domain::setMinX(qreal min)
             {
                 setRange(min, m_maxX, m_minY, m_maxY);
             }
             void Domain::setMaxX(qreal max)
             {
                 setRange(m_minX, max, m_minY, m_maxY);
             }
             void Domain::setMinY(qreal min)
             {
                 setRange(m_minX, m_maxX, min, m_maxY);
             }
             void Domain::setMaxY(qreal max)
             {
                 setRange(m_minX, m_maxX, m_minY, max);
             }
             qreal Domain::spanX() const
             {
                 Q_ASSERT(m_maxX >= m_minX);
                 return m_maxX - m_minX;
             }
             qreal Domain::spanY() const
             {
                 Q_ASSERT(m_maxY >= m_minY);
                 return m_maxY - m_minY;
             }
             bool Domain::isEmpty() const
             {
                 return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY());
             }
             void Domain::zoomIn(const QRectF& rect, const QSizeF& size)
             {
                 qreal dx = spanX() / size.width();
                 qreal dy = spanY() / 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();
                 int tickXCount = m_tickXCount;
                 int tickYCount = m_tickYCount;
                 if(m_niceXNumbers) {
                     looseNiceNumbers(minX, maxX, tickXCount);
                 }
                 if(m_niceYNumbers) {
                     looseNiceNumbers(minY, maxY, tickYCount);
                 }
                 setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             void Domain::zoomOut(const QRectF& rect, const QSizeF& size)
             {
                 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 * size.width();
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * size.height();
                 int tickXCount = m_tickXCount;
                 int tickYCount = m_tickYCount;
                 if(m_niceXNumbers) {
                     looseNiceNumbers(minX, maxX, tickXCount);
                 }
                 if(m_niceYNumbers) {
                     looseNiceNumbers(minY, maxY, tickYCount);
                 }
                 setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
-            void Domain::move(int dx,int dy,const QSizeF& size)
+            void Domain::move(qreal dx,qreal dy,const QSizeF& size)
             {
                 qreal x = spanX() / size.width();
                 qreal y = spanY() / 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);
             }
             void Domain::handleAxisXChanged(qreal min,qreal max,int tickXCount,bool niceNumbers)
             {
                 if (m_niceXNumbers != niceNumbers) {
                     m_niceXNumbers = niceNumbers;
                     //force recalculation
                     m_minX = 0;
                     m_maxX = 0;
                 }
                 setRange(min,max,m_minY, m_maxY,tickXCount,m_tickYCount);
             }
             void Domain::handleAxisYChanged(qreal min,qreal max,int tickYCount,bool niceNumbers)
             {
                 if (m_niceYNumbers != niceNumbers) {
                     m_niceYNumbers = niceNumbers;
                     //force recalculation
                     m_minY = 0;
                     m_maxY = 0;
                 }
                 setRange(m_minX, m_maxX, min, max,m_tickXCount,tickYCount);
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void Domain::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const
             {
                 qreal range = niceNumber(max-min,true); //range with ceiling
                 qreal step = niceNumber(range/(ticksCount-1),false);
                 min = floor(min/step);
                 max = ceil(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 Domain::niceNumber(qreal x,bool ceiling) const
             {
                 qreal z = pow(10,floor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x/z;//q<10 && q>=1;
                 if(ceiling) {
                     if(q <= 1.0) q=1;
                     else if(q <= 2.0) q=2;
                     else if(q <= 5.0) q=5;
                     else q=10;
                 }
                 else {
                     if(q < 1.5) q=1;
                     else if(q < 3.0) q=2;
                     else if(q < 7.0) q=5;
                     else q=10;
                 }
                 return q*z;
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &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 Domain &domain1, const Domain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain)
             {
                 dbg.nospace() << "Domain("<<domain.m_minX<<','<<domain.m_maxX<<','<<domain.m_minY<<','<<domain.m_maxY<<')' << domain.m_tickXCount << "," << domain.m_tickYCount ;
                 return dbg.maybeSpace();
             }
             #include "moc_domain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain_p.h +1 -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$
             **
             ****************************************************************************/
             #ifndef DOMAIN_H
             #define DOMAIN_H
             #include "qchartglobal.h"
             #include <QRectF>
             #include <QSizeF>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT Domain: public QObject {
                 Q_OBJECT
             public:
                 explicit Domain(QObject* object=0);
                 virtual ~Domain();
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY, int tickXCount, int tickYCount);
                 void setRangeX(qreal min, qreal max);
                 void setRangeX(qreal min, qreal max, int tickCount);
                 void setRangeY(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max, int tickCount);
                 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;
                 int tickXCount() const {return m_tickXCount;}
                 int tickYCount() const {return m_tickYCount;}
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain);
                 void zoomIn(const QRectF& rect, const QSizeF& size);
                 void zoomOut(const QRectF& rect, const QSizeF& size);
-                void move(int dx,int dy,const QSizeF& size);
+                void move(qreal dx,qreal dy,const QSizeF& size);
             Q_SIGNALS:
                 void domainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void rangeXChanged(qreal min, qreal max, int tickXCount);
                 void rangeYChanged(qreal min, qreal max, int tickYCount);
             public Q_SLOTS:
                 void handleAxisXChanged(qreal min,qreal max,int tickXCount = 5,bool niceNumbers = false);
                 void handleAxisYChanged(qreal min,qreal max,int tickYCount = 5,bool niceNumbers = false);
             private:
                 void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const;
                 qreal niceNumber(qreal x,bool celing) const;
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 int m_tickXCount;
                 int m_tickYCount;
                 bool m_niceXNumbers;
                 bool m_niceYNumbers;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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