HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2408:f065af9daaed

adds Andy's customer request, first call to createDaultAxis scales whole domain (if on common axis)

Michal Klocek -

r2408:f065af9daaed

parent child

Context file:

r2408:f065af9daaed

Collapse all files

src/chartdataset.cpp +19 -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 "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;
                 }
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     detachAxis(series,axis);
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
             }
             /*
              * 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;
                 }
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                   detachAxis(s,axis);
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
             }
             /*
              * 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){
                     AbstractDomain *old = domain;
                     domain =  createDomain(type);
                     domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY());
                 }
                 if(!domain) return false;
                 if(!domain->attachAxis(axis)) return false;
                 if(domain!=series->d_ptr->domain()){
                     foreach(QAbstractAxis* axis,series->d_ptr->m_axes){
                         series->d_ptr->domain()->detachAxis(axis);
                         domain->attachAxis(axis);
                     }
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 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);
+                    qreal min = 0;
+                    qreal max = 0;
+                    findMinMaxForSeries(m_seriesList,orientation,min,max);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
+                    axis->setRange(min,max);
                 }
                 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::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max)
+            {
+            	Q_ASSERT(!series.isEmpty());
+            	AbstractDomain* domain = series.first()->d_ptr->domain();
+            	min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
+            	max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
+            	for(int i = 1; i< series.size(); i++) {
+            		AbstractDomain* domain = series[i]->d_ptr->domain();
+            		min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min);
+            		max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max);
+            	}
+            }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     s->deleteLater();
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     a->deleteLater();
                 }
                 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->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 QPointF point;
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return point;
                 if (series && m_seriesList.contains(series))
                     point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
                 return point;
             }
             QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 QPointF point = m_chart->plotArea().topLeft();
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return QPoint(0, 0);
                 bool ok;
                 if (series && m_seriesList.contains(series))
                     point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok);
                 return point;
             }
             QList<QAbstractAxis*> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
             AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis*> axes)
             {
                 enum Type {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 foreach(QAbstractAxis* axis, axes)
                 {
                     switch(axis->type()) {
                         case QAbstractAxis::AxisTypeLogValue:
                         if(axis->orientation()==Qt::Horizontal) {
                             horizontal|=LogType;
                         }
                         if(axis->orientation()==Qt::Vertical) {
                             vertical|=LogType;
                         }
                         break;
                         case QAbstractAxis::AxisTypeValue:
                         case QAbstractAxis::AxisTypeBarCategory:
                         case QAbstractAxis::AxisTypeCategory:
                         case QAbstractAxis::AxisTypeDateTime:
                         if(axis->orientation()==Qt::Horizontal) {
                             horizontal|=ValueType;
                         }
                         if(axis->orientation()==Qt::Vertical) {
                             vertical|=ValueType;
                         }
                         break;
                         default:
                         qWarning()<<"Undefined type";
                         break;
                     }
                 }
                 if(vertical==Undefined) vertical=ValueType;
                 if(horizontal==Undefined) horizontal=ValueType;
                 if(vertical==ValueType && horizontal== ValueType) {
                     return AbstractDomain::XYDomain;
                 }
                 if(vertical==LogType && horizontal== ValueType) {
                     return AbstractDomain::XLogYDomain;
                 }
                 if(vertical==ValueType && horizontal== LogType) {
                     return AbstractDomain::LogXYDomain;
                 }
                 if(vertical==LogType && horizontal== LogType) {
                     return AbstractDomain::LogXLogYDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
             	switch(type)
             	{
             		case AbstractDomain::LogXLogYDomain:
             			return new LogXLogYDomain();
             		case AbstractDomain::XYDomain:
             			return new XYDomain();
             		case AbstractDomain::XLogYDomain:
             			return new XLogYDomain();
             		case AbstractDomain::LogXYDomain:
             			return new LogXYDomain();
             		default:
             			return 0;
             	}
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +1 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$
             **
             ****************************************************************************/
             //  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 "abstractdomain_p.h"
             #include "qabstractaxis_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QChart *chart);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 QList<QAbstractSeries *> series() const;
                 void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes() const;
                 bool attachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 bool detachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 void createDefaultAxes();
                 void zoomInDomain(const QRectF &rect);
                 void zoomOutDomain(const QRectF &rect);
                 void scrollDomain(qreal dx, qreal dy);
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
             Q_SIGNALS:
                 void axisAdded(QAbstractAxis* axis);
                 void axisRemoved(QAbstractAxis* axis);
                 void seriesAdded(QAbstractSeries* series);
                 void seriesRemoved(QAbstractSeries* series);
             private:
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
                 AbstractDomain::DomainType selectDomain(QList<QAbstractAxis* > axes);
                 AbstractDomain* createDomain(AbstractDomain::DomainType type);
                 void deleteAllAxes();
                 void deleteAllSeries();
+                void findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max);
             private:
                 QList<QAbstractSeries *> m_seriesList;
                 QList<QAbstractAxis *> m_axisList;
                 QChart* m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H */

tests/auto/qchart/tst_qchart.cpp +79 -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 <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qabstractbarseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qvalueaxis.h>
             #include <qbarcategoryaxis.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void plotArea_data();
                 void plotArea();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scroll_right_data();
                 void scroll_right();
                 void scroll_left_data();
                 void scroll_left();
                 void scroll_up_data();
                 void scroll_up();
                 void scroll_down_data();
                 void scroll_down();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
+                void createDefaultAxesForLineSeries_data();
+                void createDefaultAxesForLineSeries();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::createTestData()
             {
                  QLineSeries* series0 = new QLineSeries(this);
                  *series0 << QPointF(0, 0) << QPointF(100, 100);
                  m_chart->addSeries(series0);
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(!m_chart->axisX());
                 QVERIFY(!m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->plotArea().top()==0);
                 QVERIFY(m_chart->plotArea().left()==0);
                 QVERIFY(m_chart->plotArea().right()==0);
                 QVERIFY(m_chart->plotArea().bottom()==0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scroll(0,0);
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
                 m_view->show();
                 QVERIFY(m_chart->plotArea().top()>0);
                 QVERIFY(m_chart->plotArea().left()>0);
                 QVERIFY(m_chart->plotArea().right()>0);
                 QVERIFY(m_chart->plotArea().bottom()>0);
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("lineSeries") << line;
                 QTest::newRow("areaSeries") << area;
                 QTest::newRow("scatterSeries") << scatter;
                 QTest::newRow("splineSeries") << spline;
                 QTest::newRow("pieSeries") << pie;
                 QTest::newRow("barSeries") << bar;
                 QTest::newRow("percentBarSeries") << percent;
                 QTest::newRow("stackedBarSeries") << stacked;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
                 m_chart->addSeries(series);
                 QCOMPARE(m_chart->series().count(), 1);
                 QCOMPARE(m_chart->series().first(), series);
                 QVERIFY(series->chart() == m_chart);
                 m_chart->createDefaultAxes();
                 if(series->type()!=QAbstractSeries::SeriesTypePie){
                     QVERIFY(m_chart->axisY(series));
                     QVERIFY(m_chart->axisX(series));
                 }else{
                     QVERIFY(!m_chart->axisY(series));
                     QVERIFY(!m_chart->axisX(series));
                 }
                 m_chart->removeSeries(series);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::newRow("categories,lineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() <<  (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
             }
             void tst_QChart::axisX()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisX());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisX(axis,series);
                 QVERIFY(m_chart->axisX(series)==axis);
             }
             void tst_QChart::axisY_data()
             {
                 axisX_data();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisY());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QVERIFY(m_chart->axisY(series)==axis);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::plotArea_data()
             {
             }
             void tst_QChart::plotArea()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->plotArea().isValid());
                 QVERIFY(m_chart->plotArea().height() < rect.height());
                 QVERIFY(m_chart->plotArea().width() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->createDefaultAxes();
                 QCOMPARE(m_chart->axes().count(), 2);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QCOMPARE(m_chart->axes().count(), 2);
                 QVERIFY(m_chart->axisX() != 0);
                 QVERIFY(m_chart->axisY() != 0);
                 QCOMPARE(deleteSpy1.count(), 1);
                 QCOMPARE(deleteSpy2.count(), 1);
                 QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 axisX_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractAxis *, axis);
                 QFETCH(QAbstractSeries *, series);
                 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QCOMPARE(m_chart->axes().count(), 1);
                 QVERIFY(m_chart->axisY() != 0);
                 QVERIFY(m_chart->axisY(series)==0);
                 QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scroll_right_data()
             {
                  QTest::addColumn<QAbstractSeries *>("series");
                  QLineSeries* series0 = new QLineSeries(this);
                  *series0 << QPointF(0, 0) << QPointF(100, 100);
                  QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
             }
             void tst_QChart::scroll_right()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisX();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                         QVERIFY(vaxis!=0);
                         qreal min = vaxis->min();
                         qreal max = vaxis->max();
                         QVERIFY(max>min);
                         m_chart->scroll(50, 0);
                         QVERIFY(min<vaxis->min());
                         QVERIFY(max<vaxis->max());
                         break;
                     }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                         QVERIFY(caxis!=0);
                         qreal min = caxis->min().toDouble();
                         qreal max = caxis->max().toDouble();
                         m_chart->scroll(50, 0);
                         QVERIFY(min<caxis->min().toDouble());
                         QVERIFY(max<caxis->max().toDouble());
                         break;
                     }
                     default:
                         qFatal("Unsupported type");
                         break;
                 }
             }
             void tst_QChart::scroll_left_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_left()
             {
                  QFETCH(QAbstractSeries *, series);
                  m_chart->addSeries(series);
                  m_chart->createDefaultAxes();
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
                  QAbstractAxis * axis = m_chart->axisX();
                  QVERIFY(axis!=0);
                  switch(axis->type())
                     {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                             QVERIFY(vaxis!=0);
                             qreal min = vaxis->min();
                             qreal max = vaxis->max();
                             m_chart->scroll(-50, 0);
                             QVERIFY(min>vaxis->min());
                             QVERIFY(max>vaxis->max());
                             break;
                         }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                             QVERIFY(caxis!=0);
                             qreal min = caxis->min().toDouble();
                             qreal max = caxis->max().toDouble();
                             m_chart->scroll(-50, 0);
                             QVERIFY(min>caxis->min().toDouble());
                             QVERIFY(max>caxis->max().toDouble());
                             break;
                         }
                         default:
                             qFatal("Unsupported type");
                             break;
                     }
             }
             void tst_QChart::scroll_up_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_up()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisY();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                     case QAbstractAxis::AxisTypeValue:{
                         QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                         QVERIFY(vaxis!=0);
                         qreal min = vaxis->min();
                         qreal max = vaxis->max();
                         m_chart->scroll(0, 50);
                         QVERIFY(min<vaxis->min());
                         QVERIFY(max<vaxis->max());
                         break;
                     }
                     case QAbstractAxis::AxisTypeBarCategory:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                         QVERIFY(caxis!=0);
                         qreal min = caxis->min().toDouble();
                         qreal max = caxis->max().toDouble();
                         m_chart->scroll(0, 50);
                         QVERIFY(min<caxis->min().toDouble());
                         QVERIFY(max<caxis->max().toDouble());
                         break;
                     }
                     default:
                         qFatal("Unsupported type");
                         break;
                 }
             }
             void tst_QChart::scroll_down_data()
             {
                 scroll_right_data();
             }
             void tst_QChart::scroll_down()
             {
                  QFETCH(QAbstractSeries *, series);
                  m_chart->addSeries(series);
                  m_chart->createDefaultAxes();
                  m_view->show();
                  QTest::qWaitForWindowShown(m_view);
                  QAbstractAxis * axis = m_chart->axisY();
                  QVERIFY(axis!=0);
                  switch(axis->type())
                     {
                         case QAbstractAxis::AxisTypeValue:{
                             QValueAxis* vaxis = qobject_cast<QValueAxis*>(axis);
                             QVERIFY(vaxis!=0);
                             qreal min = vaxis->min();
                             qreal max = vaxis->max();
                             m_chart->scroll(0, -50);
                             QVERIFY(min>vaxis->min());
                             QVERIFY(max>vaxis->max());
                             break;
                         }
                         case QAbstractAxis::AxisTypeBarCategory:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                             QVERIFY(caxis!=0);
                             qreal min = caxis->min().toDouble();
                             qreal max = caxis->max().toDouble();
                             m_chart->scroll(0, -50);
                             QVERIFY(min>caxis->min().toDouble());
                             QVERIFY(max>caxis->max().toDouble());
                             break;
                         }
                         default:
                             qFatal("Unsupported type");
                             break;
                     }
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 m_chart->createDefaultAxes();
                 QRectF marigns = m_chart->plotArea();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<axisX->min());
                     QVERIFY(maxX>axisX->max());
                     QVERIFY(minY<axisY->min());
                     QVERIFY(maxY>axisY->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 m_chart->createDefaultAxes();
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);
                 QValueAxis* axisY = qobject_cast<QValueAxis*>(m_chart->axisY());
                 QVERIFY(axisY!=0);
                 qreal minX = axisX->min();
                 qreal minY = axisY->min();
                 qreal maxX = axisX->max();
                 qreal maxY = axisY->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < axisX->min());
                 QVERIFY(maxX > axisX->max());
                 QVERIFY(minY < axisY->min());
                 QVERIFY(maxY > axisY->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(axisX->min()));
                 else
                     QCOMPARE(minX, axisX->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(axisY->min()));
                 else
                     QCOMPARE(minY, axisY->min());
                 QVERIFY(maxX == axisX->max());
                 QVERIFY(maxY == axisY->max());
             }
+            void tst_QChart::createDefaultAxesForLineSeries_data()
+            {
+                QTest::addColumn<qreal>("series1minX");
+                QTest::addColumn<qreal>("series1midX");
+                QTest::addColumn<qreal>("series1maxX");
+                QTest::addColumn<qreal>("series2minX");
+                QTest::addColumn<qreal>("series2midX");
+                QTest::addColumn<qreal>("series2maxX");
+                QTest::addColumn<qreal>("overallminX");
+                QTest::addColumn<qreal>("overallmaxX");
+                QTest::addColumn<qreal>("series1minY");
+                QTest::addColumn<qreal>("series1midY");
+                QTest::addColumn<qreal>("series1maxY");
+                QTest::addColumn<qreal>("series2minY");
+                QTest::addColumn<qreal>("series2midY");
+                QTest::addColumn<qreal>("series2maxY");
+                QTest::addColumn<qreal>("overallminY");
+                QTest::addColumn<qreal>("overallmaxY");
+                QTest::newRow("series1hasMinAndMax") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0
+                                                     << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0;
+                QTest::newRow("series2hasMinAndMax") << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0
+                                                     << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
+                QTest::newRow("series1hasMinAndMaxX_series2hasMinAndMaxY") << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.1 << (qreal)1.7 << (qreal)2.9 << (qreal)1.0 << (qreal)3.0
+                                                                           << (qreal)1.1 << (qreal)2.0 << (qreal)2.9 << (qreal)1.0 << (qreal)2.0 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
+                QTest::newRow("series1hasMin_series2hasMax") << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0
+                                                             << (qreal)1.0 << (qreal)2.0 << (qreal)2.9 << (qreal)1.1 << (qreal)1.7 << (qreal)3.0 << (qreal)1.0 << (qreal)3.0;
+            }
+            void tst_QChart::createDefaultAxesForLineSeries()
+            {
+                QFETCH(qreal, series1minX);
+                QFETCH(qreal, series1midX);
+                QFETCH(qreal, series1maxX);
+                QFETCH(qreal, series2minX);
+                QFETCH(qreal, series2midX);
+                QFETCH(qreal, series2maxX);
+                QFETCH(qreal, series1minY);
+                QFETCH(qreal, series1midY);
+                QFETCH(qreal, series1maxY);
+                QFETCH(qreal, series2minY);
+                QFETCH(qreal, series2midY);
+                QFETCH(qreal, series2maxY);
+                QFETCH(qreal, overallminX);
+                QFETCH(qreal, overallmaxX);
+                QFETCH(qreal, overallminY);
+                QFETCH(qreal, overallmaxY);
+                QLineSeries* series1 = new QLineSeries(this);
+                series1->append(series1minX, series1minY);
+                series1->append(series1midX, series1midY);
+                series1->append(series1maxX, series1maxY);
+                QLineSeries* series2 = new QLineSeries(this);
+                series2->append(series2minX, series2minY);
+                series2->append(series2midX, series2midY);
+                series2->append(series2maxX, series2maxY);
+                QChart chart;
+                chart.addSeries(series1);
+                chart.addSeries(series2);
+                chart.createDefaultAxes();
+                QValueAxis *xAxis = (QValueAxis *)chart.axisX();
+                QCOMPARE(xAxis->min(), overallminX);
+                QCOMPARE(xAxis->max(), overallmaxX);
+                QValueAxis *yAxis = (QValueAxis *)chart.axisY();
+                QCOMPARE(yAxis->min(), overallminY);
+                QCOMPARE(yAxis->max(), overallmaxY);
+                QLineSeries *series3 = new QLineSeries(this);
+                // Numbers clearly out of existing range
+                series3->append(0, 0);
+                series3->append(100, 100);
+                // Adding a new series should not change the axes as they have not been told to update
+                chart.addSeries(series3);
+                QCOMPARE(xAxis->min(), overallminX);
+                QCOMPARE(xAxis->max(), overallmaxX);
+                QCOMPARE(yAxis->min(), overallminY);
+                QCOMPARE(yAxis->max(), overallmaxY);
+            }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

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