HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r442:6c610328d6c5

Bugfix missing min max intialization when axis added to domain

Michal Klocek -

r442:6c610328d6c5

parent child

Context file:

r442:6c610328d6c5

Collapse all files

src/chartdataset.cpp +4 -1

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QChartAxis(this)),
                 m_axisY(new QChartAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 if(!series->parent()){
                    series->setParent(this); // take ownership
                 };
                 if(!axisY->parent()){
                    axisY->setParent(this); // take ownership
                 }
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain();
                     QObject::connect(axisY,SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeXChanged(qreal,qreal)));
                     QObject::connect(axisX(),SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeYChanged(qreal,qreal)));
+                    //initialize
+                    qDebug()<<axisX()->min()<<axisX()->max();
+                    domain->handleAxisRangeYChanged(axisY->min(),axisY->max());
+                    domain->handleAxisRangeXChanged(axisX()->min(),axisX()->max());
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 calculateDomain(series,domain);
                 m_seriesAxisMap.insert(series,axisY);
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 if(series->parent()==this){
                     delete series;
                     series=0;
                 }
                 QList<QChartAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QSeries*> series =  m_seriesAxisMap.keys();
                 foreach(QSeries* s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
             }
             //to be removed with PIMPL
             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         for (int i = 0; i < lineSeries->count(); i++)
                         {
                             qreal x = lineSeries->x(i);
                             qreal y = lineSeries->y(i);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         QLineSeries* upperSeries = areaSeries->upperSeries();
                         QLineSeries* lowerSeries = areaSeries->lowerSeries();
                         for (int i = 0; i < upperSeries->count(); i++)
                         {
                             qreal x = upperSeries->x(i);
                             qreal y = upperSeries->y(i);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         if(lowerSeries) {
                             for (int i = 0; i < lowerSeries->count(); i++)
                             {
                                 qreal x = lowerSeries->x(i);
                                 qreal y = lowerSeries->y(i);
                                 domain->setMinX(qMin(domain->minX(),x));
                                 domain->setMinY(qMin(domain->minY(),y));
                                 domain->setMaxX(qMax(domain->maxX(),x));
                                 domain->setMaxY(qMax(domain->maxY(),y));
                             }}
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(0);
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(100);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain->setMinX(qMin(domain->minX(), point.x()));
                             domain->setMinY(qMax(domain->maxX(), point.x()));
                             domain->setMaxX(qMin(domain->minY(), point.y()));
                             domain->setMaxY(qMax(domain->maxY(), point.y()));
                         }
                         break;
                     }
                     case QSeries::SeriesTypeSpline: {
                         QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                         for (int i = 0; i < splineSeries->count(); i++)
                         {
                             qreal x = splineSeries->x(i);
                             qreal y = splineSeries->y(i);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QSeries* series) const
             {
             	QChartAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QChartAxis* axis) const
             {
             	return m_axisDomainMap.value(axis);
             }
             QChartAxis* ChartDataSet::axis(QSeries* series) const
             {
             	return m_seriesAxisMap.value(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.cpp +7 -1

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QChartAxis
                 \brief The QChartAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the share common X axis.
                 Axis can be setup to show axis line with ticks, gird lines and shades.
             */
             /*!
                \fn bool QChartAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
                \fn QPen QChartAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
                \fn bool QChartAxis::isGridVisible() const
                \brief Returns if grid is visible
                \sa setGridVisible()
             */
             /*!
                \fn QPen QChartAxis::gridPen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridPen()
             */
             /*!
                \fn  bool QChartAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
                \fn QPen QChartAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
                \fn QBrush QChartAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
                \fn QFont QChartAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
                \fn QFont QChartAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
                \fn bool QChartAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
               \fn  qreal QChartAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
                \fn QPen QChartAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
                \fn QBrush QChartAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
                \fn qreal QChartAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
                \fn qreal QChartAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
                \fn void QChartAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
                \fn void QChartAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
                \fn void QChartAxis::rangeChanged(qreal min, qreal max)
                \brief Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                \fn int QChartAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
                 \fn void QChartAxis::updated()
                 \brief \internal
             */
             /*!
                 \fn void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
                 \brief \internal \a min \a max
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChatView or QChart when axis added.
             */
             QChartAxis::QChartAxis(QObject* parent):QObject(parent),
             m_axisVisible(true),
             m_gridVisible(true),
             m_labelsVisible(true),
             m_labelsAngle(0),
             m_shadesVisible(true),
             m_shadesOpacity(1.0),
             m_min(0),
             m_max(0),
             m_ticksCount(5)
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QChartAxis::~QChartAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QChartAxis::setAxisPen(const QPen& pen)
             {
             	if (pen != m_axisPen) {
                 m_axisPen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QChartAxis::setAxisVisible(bool visible)
             {
             	if (m_axisVisible!=visible) {
                 m_axisVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets if grid is \a visible.
              */
             void QChartAxis::setGridVisible(bool visible)
             {
             	if (m_gridVisible!=visible) {
                 m_gridVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw grid.
              */
             void QChartAxis::setGridPen(const QPen& pen)
             {
             	if (m_gridPen!=pen) {
                 m_gridPen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets if axis' labels are \a visible.
              */
             void QChartAxis::setLabelsVisible(bool visible)
             {
             	if(m_labelsVisible!=visible) {
                 m_labelsVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw labels.
              */
             void QChartAxis::setLabelsPen(const QPen& pen)
             {
             	if(m_labelsPen!=pen) {
                 m_labelsPen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QChartAxis::setLabelsBrush(const QBrush& brush)
             {
             	if(m_labelsBrush!=brush) {
                 m_labelsBrush=brush;
                 emit updated();
             	}
             }
             /*!
               Sets \a font used to draw labels.
              */
             void QChartAxis::setLabelsFont(const QFont& font)
             {
             	if(m_labelsFont!=font) {
                 m_labelsFont=font;
                 emit updated();
             	}
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
             void QChartAxis::setLabelsAngle(int angle)
             {
             	if(m_labelsAngle!=angle) {
             	m_labelsAngle=angle;
             	emit updated();
             	}
             }
             /*!
               Sets if shades are \a visible.
              */
             void QChartAxis::setShadesVisible(bool visible)
             {
             	if(m_shadesVisible!=visible) {
                 m_shadesVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw shades.
              */
             void QChartAxis::setShadesPen(const QPen& pen)
             {
             	if(m_shadesPen!=pen) {
             	m_shadesPen=pen;
             	emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw shades.
              */
             void QChartAxis::setShadesBrush(const QBrush& brush)
             {
             	if(m_shadesBrush!=brush) {
                 m_shadesBrush=brush;
                 emit updated();
             	}
             }
             /*!
               Sets \a opacity of the shades.
              */
             void QChartAxis::setShadesOpacity(qreal opacity)
             {
             	if(m_shadesOpacity!=opacity) {
                 m_shadesOpacity=opacity;
                 emit updated();
             	}
             }
             /*!
              Sets \a min value on the axis.
              */
             void QChartAxis::setMin(qreal min)
             {
             	setRange(min,m_max);
             }
             /*!
              Sets \a max value on the axis.
              */
             void QChartAxis::setMax(qreal max)
             {
                 setRange(m_min,max);
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
             void QChartAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if(m_min!=min) {
                     m_min=min;
+                    changed=true;
                     emit minChanged(min);
                 }
                 if(m_max!=max) {
                     m_max=max;
+                    changed=true;
                     emit maxChanged(max);
                 }
-                if(changed) emit rangeChanged(m_min,m_max);
+                if(changed) {
+                    emit rangeChanged(m_min,m_max);
+                }
             }
             void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
             {
                setRange(min,max);
             }
             /*!
               Sets \a count for ticks on the axis.
              */
             void QChartAxis::setTicksCount(int count)
             {
             	if(m_ticksCount!=count) {
             	m_ticksCount=count;
             	emit updated();
             	}
             }
             /*!
               TODO: refactor me. Sets string \a label for \a value on the axis.
              */
             void QChartAxis::addAxisTickLabel(qreal value,const QString& label)
             {
             	m_ticks.insert(value,label);
             	emit updated();
             }
             /*!
               TODO: refactor me. Removes label for \a value on the axis.
              */
             void QChartAxis::removeAxisTickLabel(qreal value)
             {
             	m_ticks.remove(value);
             	emit updated();
             }
             /*!
               TODO: refactor me. Returns label for \a value on the axis.
              */
             QString QChartAxis::axisTickLabel(qreal value) const
             {
             	return m_ticks.value(value);
             }
             /*!
               TODO: refactor me. Removes all the string labels for on the axis.
              */
             void QChartAxis::clearAxisTickLabels()
             {
             	m_ticks.clear();
             	emit updated();
             }
             #include "moc_qchartaxis.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