HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1805:3a0e948c9274

renamed QValueAxis related files

Marek Rosa -

r1805:3a0e948c9274

parent child

Context file:

r1805:3a0e948c9274

Expand all files

plugins/declarative/plugin.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 <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #include "qchart.h"
             #include "qabstractaxis.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "qbarcategoriesaxis.h"
             #include "declarativechart.h"
             #include "declarativexypoint.h"
             #include "declarativelineseries.h"
             #include "declarativesplineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativescatterseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "qvxymodelmapper.h"
             #include "qhxymodelmapper.h"
             #include "qhpiemodelmapper.h"
             #include "qvpiemodelmapper.h"
             #include "qhbarmodelmapper.h"
             #include "qvbarmodelmapper.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qmlRegisterType<DeclarativeChart>(uri, 1, 0, "ChartView");
                     qmlRegisterType<DeclarativeXYPoint>(uri, 1, 0, "XYPoint");
                     qmlRegisterType<DeclarativeScatterSeries>(uri, 1, 0, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries>(uri, 1, 0, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries>(uri, 1, 0, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries>(uri, 1, 0, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries>(uri, 1, 0, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries>(uri, 1, 0, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries>(uri, 1, 0, "PercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 0, "PieSeries");
                     qmlRegisterType<QPieSlice>(uri, 1, 0, "PieSlice");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 0, "BarSet");
                     qmlRegisterType<QHXYModelMapper>(uri, 1, 0, "HXYModelMapper");
                     qmlRegisterType<QVXYModelMapper>(uri, 1, 0, "VXYModelMapper");
                     qmlRegisterType<QHPieModelMapper>(uri, 1, 0, "HPieModelMapper");
                     qmlRegisterType<QVPieModelMapper>(uri, 1, 0, "VPieModelMapper");
                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
                     qmlRegisterType<QBarCategoriesAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                       QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                       QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                       QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                       QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                       QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                       QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                       QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                          QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                       QLatin1String("Trying to create uncreatable: AbstractAxis."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))

src/areachart/qareaseries.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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
                 In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \qmlclass AreaSeries QAreaSeries
                 The following QML shows how to create a simple area chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View4.qml 1
                 \beginfloatleft
                 \image demos_qmlchart4.png
                 \endfloat
                 \clearfloat
             */
             /*!
                \property QAreaSeries::upperSeries
                \brief The upper one of the two line series used to define area series boundaries.
             */
             /*!
                \qmlproperty LineSeries AreaSeries::upperSeries
                The upper one of the two line series used to define area series boundaries.
             */
             /*!
                 \property QAreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 QAreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \qmlproperty LineSeries AreaSeries::lowerSeries
                 The lower one of the two line series used to define are series boundaries. Note if
                 AreaSeries was counstucted wihtout a\ lowerSeries this is null.
             */
             /*!
                 \property QAreaSeries::color
                 Fill (brush) color of the series. This is a convenience property for modifying the color of brush.
                 \sa QAreaSeries::brush()
             */
             /*!
                 \qmlproperty color AreaSeries::color
                 Fill (brush) color of the series.
             */
             /*!
                 \property QAreaSeries::borderColor
                 Line (pen) color of the series. This is a convenience property for modifying the color of pen.
                 \sa QAreaSeries::pen()
             */
             /*!
                 \qmlproperty color AreaSeries::borderColor
                 Line (pen) color of the series.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                 \fn void QAreaSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onColorChanged(color color)
                 Signal is emitted when the fill (brush) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::borderColorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal AreaSeries::onBorderColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \qmlsignal AreaSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \qmlsignal AreaSeries::onSelected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of AreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Constructs area series object without upper or lower series with \a parent object.
             */
             QAreaSeries::QAreaSeries(QObject *parent)
                 : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent)
             {
             }
             /*!
                 Destroys the object.
             */
             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
                 if(d->m_dataset){
                        d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             */
             QAbstractSeries::SeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
             void QAreaSeries::setUpperSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
             void QAreaSeries::setLowerSeries(QLineSeries* series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             void QAreaSeries::setColor(const QColor &color)
             {
                 QBrush b = brush();
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QAreaSeries::color() const
             {
                 return brush().color();
             }
             void QAreaSeries::setBorderColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QAreaSeries::borderColor() const
             {
                 return pen().color();
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++)
                     {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if(q->lowerSeries())  {
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                     }
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             void QAreaSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValues;
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/axis.pri +9 -9

             #Subdirectiores are defined here, because qt creator doesn't handle nested include(foo.pri) chains very well.
             INCLUDEPATH += $$PWD \
-                $$PWD/valuesaxis \
+                $$PWD/valueaxis \
                 $$PWD/categoriesaxis \
                 $$PWD/intervalsaxis \
                 $$PWD/datetimeaxis
             DEPENDPATH += $$PWD \
-                $$PWD/valuesaxis \
+                $$PWD/valueaxis \
                 $$PWD/categoriesaxis \
                 $$PWD/intervalsaxis \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/chartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
-                $$PWD/valuesaxis/chartvaluesaxisx.cpp \
+                $$PWD/valueaxis/chartvalueaxisx.cpp \
-                $$PWD/valuesaxis/chartvaluesaxisy.cpp \
+                $$PWD/valueaxis/chartvalueaxisy.cpp \
-                $$PWD/valuesaxis/qvaluesaxis.cpp \
+                $$PWD/valueaxis/qvalueaxis.cpp \
                 $$PWD/categoriesaxis/chartcategoriesaxisx.cpp \
                 $$PWD/categoriesaxis/chartcategoriesaxisy.cpp \
                 $$PWD/categoriesaxis/qbarcategoriesaxis.cpp \
                 $$PWD/intervalsaxis/chartintervalsaxisx.cpp \
                 $$PWD/intervalsaxis/chartintervalsaxisy.cpp \
                 $$PWD/intervalsaxis/qintervalsaxis.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisx.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisy.cpp \
                 $$PWD/datetimeaxis/qdatetimeaxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxis_p.h \
                 $$PWD/qabstractaxis_p.h \
-                $$PWD/valuesaxis/chartvaluesaxisx_p.h \
+                $$PWD/valueaxis/chartvalueaxisx_p.h \
-                $$PWD/valuesaxis/chartvaluesaxisy_p.h \
+                $$PWD/valueaxis/chartvalueaxisy_p.h \
-                $$PWD/valuesaxis/qvaluesaxis_p.h \
+                $$PWD/valueaxis/qvalueaxis_p.h \
                 $$PWD/categoriesaxis/chartcategoriesaxisx_p.h \
                 $$PWD/categoriesaxis/chartcategoriesaxisy_p.h \
                 $$PWD/categoriesaxis/qbarcategoriesaxis_p.h \
                 $$PWD/intervalsaxis/chartintervalsaxisx_p.h \
                 $$PWD/intervalsaxis/chartintervalsaxisy_p.h \
                 $$PWD/intervalsaxis/qintervalsaxis_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisx_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisy_p.h \
                 $$PWD/datetimeaxis/qdatetimeaxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qabstractaxis.h \
-                $$PWD/valuesaxis/qvaluesaxis.h \
+                $$PWD/valueaxis/qvalueaxis.h \
                 $$PWD/categoriesaxis/qbarcategoriesaxis.h \
                 $$PWD/intervalsaxis/qintervalsaxis.h \
                 $$PWD/datetimeaxis/qdatetimeaxis.h

src/axis/intervalsaxis/qintervalsaxis.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 QCATEGORIESAXIS_H
             #define QCATEGORIESAXIS_H
             #include "qabstractaxis.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QIntervalsAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QIntervalsAxis : public QValueAxis
             {
                 Q_OBJECT
             public:
                 explicit QIntervalsAxis(QObject *parent = 0);
                 ~QIntervalsAxis();
             protected:
                 QIntervalsAxis(QIntervalsAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
                 void append(const QString& label, qreal intervalEnd);
                 void remove(const QString& label);
                 void replaceLabel(const QString& oldLabel, const QString& newLabel);
                 void setFisrtIntervalMinimum(qreal min);
                 qreal intervalMin(const QString& intervalLabel) const;
                 qreal intervalMax(const QString& intervalLabel) const;
                 QStringList intervalsLabels();
                 int count() const;
             private:
                 Q_DECLARE_PRIVATE(QIntervalsAxis)
                 Q_DISABLE_COPY(QIntervalsAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_H

src/axis/intervalsaxis/qintervalsaxis_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 QIntervalsAxis_P_H
             #define QIntervalsAxis_P_H
             #include "qintervalsaxis.h"
-            #include "qvaluesaxis_p.h"
+            #include "qvalueaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QPair<qreal, qreal> Range;
             class QIntervalsAxisPrivate : public QValueAxisPrivate
             {
                 Q_OBJECT
             public:
                 QIntervalsAxisPrivate(QIntervalsAxis *q);
                 ~QIntervalsAxisPrivate();
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 int ticksCount() const;
             Q_SIGNALS:
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 QMap<QString , Range> m_intervalsMap;
                 QStringList m_intervals;
                 qreal m_categoryMinimum;
             private:
                 Q_DECLARE_PUBLIC(QIntervalsAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_P_H

src/axis/valueaxis/chartvalueaxisx.cpp ~~src/axis/valuesaxis/chartvaluesaxisx.cpp~~ renamed +7 -7

             /****************************************************************************
             **
             ** 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 "chartvaluesaxisx_p.h"
+            #include "chartvalueaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValuesAxisX::ChartValuesAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
-            ChartValuesAxisX::~ChartValuesAxisX()
+            ChartValueAxisX::~ChartValueAxisX()
             {
             }
-            QVector<qreal> ChartValuesAxisX::calculateLayout() const
+            QVector<qreal> ChartValueAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaX = m_rect.width()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
-            void ChartValuesAxisX::updateGeometry()
+            void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         m_minWidth+=rect.width();
                         m_minHeight=qMax(rect.height(),m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
             }
-            void ChartValuesAxisX::handleAxisUpdated()
+            void ChartValueAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisx_p.h ~~src/axis/valuesaxis/chartvaluesaxisx_p.h~~ renamed +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTVALUESAXISX_H
             #define CHARTVALUESAXISX_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
-            class ChartValuesAxisX : public ChartAxis
+            class ChartValueAxisX : public ChartAxis
             {
             public:
-                ChartValuesAxisX(QAbstractAxis *axis, ChartPresenter *presenter);
+                ChartValueAxisX(QAbstractAxis *axis, ChartPresenter *presenter);
-                ~ChartValuesAxisX();
+                ~ChartValueAxisX();
                 AxisType axisType() const { return X_AXIS;}
             protected:
                 void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
             private:
                 int m_tickCount;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTVALUESAXISX_H */

src/axis/valueaxis/chartvalueaxisy.cpp ~~src/axis/valuesaxis/chartvaluesaxisy.cpp~~ renamed +7 -7

             /****************************************************************************
             **
             ** 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 "chartvaluesaxisy_p.h"
+            #include "chartvalueaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValuesAxisY::ChartValuesAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_tickCount(0)
             {
             }
-            ChartValuesAxisY::~ChartValuesAxisY()
+            ChartValueAxisY::~ChartValueAxisY()
             {
             }
-            QVector<qreal> ChartValuesAxisY::calculateLayout() const
+            QVector<qreal> ChartValueAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_tickCount>=2);
                 QVector<qreal> points;
                 points.resize(m_tickCount);
                 const qreal deltaY = m_rect.height()/(m_tickCount-1);
                 for (int i = 0; i < m_tickCount; ++i) {
                     int y = i * -deltaY + m_rect.bottom();
                     points[i] = y;
                 }
                 return points;
             }
-            void ChartValuesAxisY::updateGeometry()
+            void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createNumberLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                         if(labelItem->pos().y()+rect.height()>height) {
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }
                         else {
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             height=labelItem->pos().y();
                         }
                         m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
                         m_minHeight+=rect.height();
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
-            void ChartValuesAxisY::handleAxisUpdated()
+            void ChartValueAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
                 QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
                 m_tickCount = axis->ticksCount();
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/chartvalueaxisy_p.h ~~src/axis/valuesaxis/chartvaluesaxisy_p.h~~ renamed +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTVALUESAXISY_H
             #define CHARTVALUESAXISY_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
-            class ChartValuesAxisY : public ChartAxis
+            class ChartValueAxisY : public ChartAxis
             {
             public:
-                ChartValuesAxisY(QAbstractAxis *axis, ChartPresenter *presenter);
+                ChartValueAxisY(QAbstractAxis *axis, ChartPresenter *presenter);
-                ~ChartValuesAxisY();
+                ~ChartValueAxisY();
                 AxisType axisType() const { return Y_AXIS;}
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
                 void handleAxisUpdated();
             private:
                 int m_tickCount;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTVALUESAXISY_H */

src/axis/valueaxis/qvalueaxis.cpp ~~src/axis/valuesaxis/qvaluesaxis.cpp~~ renamed +8 -8

             /****************************************************************************
             **
             ** 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 "qvaluesaxis.h"
+            #include "qvalueaxis.h"
-            #include "qvaluesaxis_p.h"
+            #include "qvalueaxis_p.h"
-            #include "chartvaluesaxisx_p.h"
+            #include "chartvalueaxisx_p.h"
-            #include "chartvaluesaxisy_p.h"
+            #include "chartvalueaxisy_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValueAxis
                 \brief The QValueAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValuesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
             */
             /*!
                 \qmlclass ValuesAxis QValueAxis
                 \brief The ValuesAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValuesAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValueAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
               When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \property QValueAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
               When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
             */
             /*!
               \fn void QValueAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMinChanged(real min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValueAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal ValuesAxis::onMaxChanged(real max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValueAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValueAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValueAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool ValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValueAxis::QValueAxis(QObject *parent) :
                 QAbstractAxis(*new QValueAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QValueAxis::QValueAxis(QValueAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValueAxis::~QValueAxis()
             {
                 Q_D(QValueAxis);
                 if(d->m_dataset) {
                     d->m_dataset->removeAxis(this);
                 }
             }
             void QValueAxis::setMin(qreal min)
             {
                 Q_D(QValueAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QValueAxis::min() const
             {
                 Q_D(const QValueAxis);
                 return d->m_min;
             }
             void QValueAxis::setMax(qreal max)
             {
                 Q_D(QValueAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QValueAxis::max() const
             {
                 Q_D(const QValueAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
               If min is greater than max then this function returns without making any changes.
             */
             void QValueAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValueAxis);
                 bool changed = false;
                 if (min > max) return;
                 if(d->m_niceNumbers) {
                     int ticks = d->m_tickCount;
                     d->looseNiceNumbers(min, max, ticks);
                     if(ticks!=d->m_tickCount) setTicksCount(ticks);
                 }
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(min,max);
                     d->emitUpdated();
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValueAxis::setTicksCount(int count)
             {
                 Q_D(QValueAxis);
                 if (d->m_tickCount != count && count >=2) {
                     d->m_tickCount = count;
                     d->emitUpdated();
                 }
             }
             /*!
               \fn int QValueAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValueAxis::ticksCount() const
             {
                 Q_D(const QValueAxis);
                 return d->m_tickCount;
             }
             void QValueAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValueAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     if(enable && !qFuzzyIsNull(d->m_max - d->m_min)) {
                         setRange(d->m_min,d->m_max);
                     }
                 }
             }
             bool  QValueAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValueAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValueAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValueAxisPrivate::QValueAxisPrivate(QValueAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0),
                 m_max(0),
                 m_tickCount(5),
                 m_niceNumbers(false)
             {
             }
             QValueAxisPrivate::~QValueAxisPrivate()
             {
             }
             void QValueAxisPrivate::handleDomainUpdated()
             {
                Q_Q(QValueAxis);
                Domain* domain = qobject_cast<Domain*>(sender());
                Q_ASSERT(domain);
                if(orientation()==Qt::Horizontal){
                    q->setRange(domain->minX(),domain->maxX());
                }else if(orientation()==Qt::Vertical){
                    q->setRange(domain->minY(),domain->maxY());
                }
             }
             void QValueAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValueAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValueAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             ChartAxis* QValueAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValueAxis);
                 if(m_orientation == Qt::Vertical){
-                    return new ChartValuesAxisY(q,presenter);
+                    return new ChartValueAxisY(q,presenter);
                 }else{
-                    return new ChartValuesAxisX(q,presenter);
+                    return new ChartValueAxisX(q,presenter);
                 }
             }
             void QValueAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QValueAxis);
                 if(qFuzzyCompare(m_max,m_min)) {
                     if(m_orientation==Qt::Vertical){
                         q->setRange(domain->minY(),domain->maxY());
                     }else{
                         q->setRange(domain->minX(), domain->maxX());
                     }
                 } else {
                     if(m_orientation==Qt::Vertical){
                         domain->setRangeY(m_min, m_max);
                     }else{
                         domain->setRangeX(m_min, m_max);
                     }
                 }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void QValueAxisPrivate::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 = qFloor(min/step);
                 max = qCeil(max/step);
                 ticksCount = int(max-min) +1;
                 min*=step;
                 max*=step;
             }
             //nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
             qreal QValueAxisPrivate::niceNumber(qreal x,bool ceiling) const
             {
                 qreal z = qPow(10,qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x/z;//q<10 && q>=1;
                 if(ceiling) {
                     if(q <= 1.0) q=1;
                     else if(q <= 2.0) q=2;
                     else if(q <= 5.0) q=5;
                     else q=10;
                 }
                 else {
                     if(q < 1.5) q=1;
                     else if(q < 3.0) q=2;
                     else if(q < 7.0) q=5;
                     else q=10;
                 }
                 return q*z;
             }
-            #include "moc_qvaluesaxis.cpp"
+            #include "moc_qvalueaxis.cpp"
-            #include "moc_qvaluesaxis_p.cpp"
+            #include "moc_qvalueaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/valueaxis/qvalueaxis.h ~~src/axis/valuesaxis/qvaluesaxis.h~~ renamed 0 0

NO CONTENT: file renamed from src/axis/valuesaxis/qvaluesaxis.h to src/axis/valueaxis/qvalueaxis.h

src/axis/valueaxis/qvalueaxis_p.h ~~src/axis/valuesaxis/qvaluesaxis_p.h~~ renamed +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 QVALUESAXIS_P_H
             #define QVALUESAXIS_P_H
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValueAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
                 QValueAxisPrivate(QValueAxis *q);
                 ~QValueAxisPrivate();
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 void intializeDomain(Domain* domain);
                 void handleDomainUpdated();
                 qreal min(){ return m_min; };
                 qreal max(){ return m_max; };
                 int count() const { return m_tickCount;}
             protected:
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             private:
                 void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount) const;
                 qreal niceNumber(qreal x,bool ceiling) const;
             private:
                 qreal m_min;
                 qreal m_max;
                 int m_tickCount;
                 bool m_niceNumbers;
                 Q_DECLARE_PUBLIC(QValueAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUESAXIS_P_H

src/barchart/qabstractbarseries.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 "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "qbarcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass AbstractBarSeries QAbstractBarSeries
                 \inherits QAbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QAbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QBarSeries
             */
             /*!
                 \qmlproperty real AbstractBarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QAbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int AbstractBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QAbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool AbstractBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QAbstractBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal AbstractBarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QAbstractBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal AbstractBarSeries::onRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                     myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa AbstractBarSeries::append()
             */
             /*!
                 \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successfull, false otherwise.
             */
             /*!
                 \qmlmethod AbstractBarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 This is depreciated constructor.
             */
             QAbstractBarSeries::QAbstractBarSeries(QObject *parent) :
                 QAbstractSeries(*(QAbstractBarSeriesPrivate*)(0),parent)
             {
             }
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
             }
             /*!
                 \internal
             */
             QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
             void QAbstractBarSeries::setBarWidth(qreal width)
             {
                 Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
             /*!
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
             qreal QAbstractBarSeries::barWidth() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->barWidth();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QAbstractBarSeries::append(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if set was removed.
             */
             bool QAbstractBarSeries::remove(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the barset object.
                 NOTE: The series remains as the barset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successfull.
             */
             bool QAbstractBarSeries::take(QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QAbstractBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all barsets from the series. Deletes removed sets.
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBarSet* set, sets) {
                         delete set;
                     }
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QAbstractBarSeries::count() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
                 }
             }
             /*!
                 Returns the visibility of labels
             */
             bool QAbstractBarSeries::isLabelsVisible() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             void QAbstractBarSeries::setGrouping(bool grouping)
             {
                 Q_D(QAbstractBarSeries);
                 d->setGrouping(grouping);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true),
                 m_grouping(true)
             {
             }
             int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 emit updatedBars();
             }
             qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
             QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
             void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
             void QAbstractBarSeriesPrivate::setGrouping(bool grouping)
             {
                 if (m_grouping != grouping) {
                     m_grouping = grouping;
                     emit updatedBars();
                 }
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_UNUSED(presenter);
                 qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
                 return 0;
             }
             QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAbstractBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QAbstractBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QAbstractBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
                 Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_Q(QAbstractBarSeries);
                 if(axis->type()==QAbstractAxis::AxisTypeCategories) {
                     switch(q->type()) {
                         case QAbstractSeries::SeriesTypeHorizontalBar:
                         case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                         case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
                             if(axis->orientation()==Qt::Vertical)
                             {
                                 populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
                             }
                             break;
                         }
                         case QAbstractSeries::SeriesTypeBar:
                         case QAbstractSeries::SeriesTypePercentBar:
                         case QAbstractSeries::SeriesTypeStackedBar: {
                             if(axis->orientation()==Qt::Horizontal)
                             {
                                 populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
                             }
                             break;
                         }
                         default:
                         qWarning()<<"Unexpected series type";
                         break;
                     }
                 }
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_Q(const QAbstractBarSeries);
                 switch(q->type()) {
                     case QAbstractSeries::SeriesTypeHorizontalBar:
                     case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                     case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
                         if(orientation==Qt::Vertical)
                         {
                             return QAbstractAxis::AxisTypeCategories;
                         }
                         break;
                     }
                     case QAbstractSeries::SeriesTypeBar:
                     case QAbstractSeries::SeriesTypePercentBar:
                     case QAbstractSeries::SeriesTypeStackedBar: {
                         if(orientation==Qt::Horizontal)
                         {
                             return QAbstractAxis::AxisTypeCategories;
                         }
                         break;
                     }
                     default:
                     qWarning()<<"Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValues;
             }
             void QAbstractBarSeriesPrivate::populateCategories(QBarCategoriesAxis* axis)
             {
                 QStringList categories;
                 if(axis->categories().isEmpty()) {
                     for (int i(1); i < categoryCount()+1; i++)
                     categories << QString::number(i);
                     axis->append(categories);
                 }
             }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/bar/qbarseries.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 "qbarseries.h"
             #include "qbarseries_p.h"
             #include "barchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "baranimation_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "qbarcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a grouped bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeBar.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, min());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, max());
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new BarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/percent/qpercentbarseries.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 "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "percentbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief Series for creating percent bar chart
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
                 \sa QBarSet, QStackedBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits QAbstractBarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 minY = 0;
                 maxY = 100;
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem* bar = new PercentBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new PercentBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/vertical/stacked/qstackedbarseries.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 "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "stackedbaranimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
                 : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal x = categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, y);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem* bar = new StackedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new StackedBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +2 -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 "qchart.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include "qbarcategoriesaxis.h"
-            #include "qvaluesaxis_p.h"
+            #include "qvalueaxis_p.h"
             #include "qintervalsaxis.h"
             #include "qdatetimeaxis.h"
             #include "qabstractseries_p.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 removeAllSeries();
             }
             void ChartDataSet::addSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(domain) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 createSeriesIndex(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 if(!m_seriesDomainMap.contains(series)) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 Domain* domain = m_seriesDomainMap.take(series);
                 delete domain;
                 domain = 0;
                 removeSeriesIndex(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 removeAxes(series);
             }
             void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
             {
                 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);
             }
             void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
             {
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if(m_seriesDomainMap.isEmpty()) return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     removeAxes(i.key());
                 }
                 i.toFront();
                 while (i.hasNext()) {
                     i.next();
                     QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                     QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                     if(axisX) typeX&=axisX->type();
                     else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
                     if(axisY) typeY&=axisY->type();
                     else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 createAxes(typeX,Qt::Horizontal);
                 createAxes(typeY,Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     while (i.hasNext()) {
                         i.next();
                         QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation);
                         if(!axis) continue;
                         initializeAxis(axis,i.key());
                         emit axisAdded(axis,i.value());
                     }
                 }
                 else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation);
                     i.toFront();
                     while (i.hasNext()) {
                         i.next();
                         initializeAxis(axis,i.key());
                     }
                     emit axisAdded(axis,i.value());
                 }
             }
             QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation)
             {
                 QAbstractAxis* axis =0;
                 switch(type) {
                 case QAbstractAxis::AxisTypeValues:
                     axis = new QValueAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeCategories:
                     axis = new QBarCategoriesAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeIntervals:
                     axis = new QIntervalsAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
                 default:
                     axis = 0;
                     break;
                 }
                 if(axis)
                     axis->d_ptr->setOrientation(orientation);
                 return axis;
             }
             void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.value(series);
                 axis->d_ptr->m_dataset = this;
                 series->d_ptr->initializeAxis(axis);
                 axis->d_ptr->intializeDomain(domain);
                 if(axis->orientation()==Qt::Horizontal) {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisXMap.insert(series,axis);
                 }
                 else {
                     QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                     QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                     m_seriesAxisYMap.insert(series,axis);
                 }
                 axis->d_ptr->emitUpdated();
             }
             void ChartDataSet::removeAxes(QAbstractSeries* series)
             {
                 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
                 if(axisX) {
                     QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                     int x = axesX.indexOf(axisX);
                     if(x==-1) {
                         emit axisRemoved(axisX);
                         axisX->d_ptr->m_dataset=0;
                         axisX->deleteLater();
                     }
                 }
                 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
                 if(axisY) {
                     QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                     int y = axesY.indexOf(axisY);
                     if(y==-1) {
                         emit axisRemoved(axisY);
                         axisY->d_ptr->m_dataset=0;
                         axisY->deleteLater();
                     }
                 }
             }
             void ChartDataSet::removeAxis(QAbstractAxis* axis)
             {
                 if(!axis->d_ptr->m_dataset) {
                     qWarning()<<"UnBound axis found !";
                     return;
                 }
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(axis->orientation()==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }
                 else {
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
                     if(i.value()==axis) {
                         removeSeries(i.key());
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
                 foreach(QAbstractSeries *s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesAxisXMap.count()==0);
                 Q_ASSERT(m_seriesDomainMap.count()==0);
                 qDeleteAll(series);
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
                 blockAxisSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
                 blockAxisSignals(false);
             }
             void ChartDataSet::blockAxisSignals(bool enabled)
             {
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                     QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                     if(axisX) {
                         axisX->d_ptr->blockSignals(enabled);
                         if(!enabled) {
                             axisX->d_ptr->setDirty(false);
                             axisX->d_ptr->emitUpdated();
                         }
                     }
                     if(axisY) {
                         axisY->d_ptr->blockSignals(enabled);
                         if(!enabled) {
                             axisY->d_ptr->setDirty(false);
                             axisY->d_ptr->emitUpdated();
                         }
                     }
                 }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 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;
             }
             QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
             {
                 if(series == 0) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) {
                     QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
                     while (i.hasNext()) {
                         i.next();
                         if(i.value()->isVisible()) return i.value();
                     }
                     return 0;
                 }
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
             {
                 Q_ASSERT(axis);
                 if(!series) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 axis->d_ptr->setOrientation(orientation);
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                 if(orientation==Qt::Vertical) {
                     seriesAxisMap= &m_seriesAxisYMap;
                 }else{
                     seriesAxisMap= &m_seriesAxisXMap;
                 }
                 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
                 QList<QAbstractAxis*> axes = seriesAxisMap->values();
                 if(oldAxis) {
                     if(axes.indexOf(oldAxis)==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->disconnect();
                         QObject::disconnect(domain,0,oldAxis,0);
                         oldAxis->d_ptr->m_dataset=0;
                         oldAxis->deleteLater();
                     }
                 }
                 if(axes.indexOf(axis)==-1) {
                     initializeAxis(axis,series);
                     emit axisAdded(axis,domain);
                 }else{
                     initializeAxis(axis,series);
                 }
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
                 return m_seriesDomainMap.value(series);
             }
             void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
             {
                 blockAxisSignals(true);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->move(dx,dy,size);
                 }
                 blockAxisSignals(false);
             }
             QList<QAbstractSeries*> ChartDataSet::series() const
             {
                 return m_seriesDomainMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                 \qmlclass XYSeries
                 \inherits AbstractSeries
                 The XYSeries class is a base class for line, spline and scatter series.
                 The class cannot be instantiated directly.
             */
             /*!
                 \property QXYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                 \qmlproperty bool XYSeries::pointsVisible
                 Controls if the data points are visible and should be drawn.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \property QXYSeries::color
                 The color of the series. This is line (pen) color in case of QLineSeries or QSplineSeries and
                 fill (brush) color in case of QScatterSeries or QAreaSeries.
                 \sa QXYSeries::pen(), QXYSeries::brush()
             */
             /*!
                 \qmlproperty color XYSeries::color
                 The color of the series. This is line (pen) color in case of LineSeries or SplineSeries and
                 fill (brush) color in case of ScatterSeries or AreaSeries.
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \qmlsignal XYSeries::onClicked(QPointF point)
                 Signal is emitted when user clicks the \a point on chart. For example:
                 \code
                 LineSeries {
                     XYPoint { x: 0; y: 0 }
                     XYPoint { x: 1.1; y: 2.1 }
                     onClicked: console.log("onClicked: " + point.x + ", " + point.y);
                 }
                 \endcode
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointReplaced(int index)
                 Signal is emitted when a point has been replaced at \a index.
             */
             /*!
                 \fn void QXYSeries::pointsReplaced()
                 Signal is emitted when all points have been replaced with another points.
                 \sa replace()
             */
             /*!
                 \qmlsignal XYSeries::onPointsReplaced()
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal XYSeries::onPointAdded(int index)
                 Signal is emitted when a point has been added at \a index.
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
                 \sa remove()
             */
             /*!
                 \qmlsignal XYSeries::onPointRemoved(int index)
                 Signal is emitted when a point has been removed from \a index.
             */
             /*!
                 \fn void QXYSeries::colorChanged(QColor color)
                 \brief Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \qmlsignal XYSeries::onColorChanged(color color)
                 Signal is emitted when the line (pen) color has changed to \a color.
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \qmlmethod XYSeries::append(real x, real y)
                 Append point (\a x, \a y) to the series
             */
             /*!
                 \qmlmethod XYSeries::replace(real oldX, real oldY, real newX, real newY)
                 Replaces point (\a oldX, \a oldY) with point (\a newX, \a newY). Does nothing, if point (oldX, oldY) does not
                 exist.
             */
             /*!
                 \qmlmethod XYSeries::remove(real x, real y)
                 Removes point (\a x, \a y) from the series. Does nothing, if point (x, y) does not exist.
             */
             /*!
                 \qmlmethod XYSeries::insert(int index, real x, real y)
                 Inserts point (\a x, \a y) to the \a index. If index is 0 or smaller than 0 the point is prepended to the list of
                 points. If index is the same as or bigger than count, the point is appended to the list of points.
             */
             /*!
                 \qmlmethod QPointF XYSeries::at(int index)
                 Returns point at \a index. Returns (0, 0) if the index is not valid.
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
                 emit pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
                     append(point);
                 }
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             /*!
               Replaces \a oldPoint with \a newPoint.
               \sa QXYSeries::pointReplaced()
             */
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
                 emit pointReplaced(index);
             }
             /*!
               Replaces the current points with \a points. This is faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced.
               \sa QXYSeries::pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             {
                 Q_D(QXYSeries);
                 d->m_points = points.toVector();
                 emit pointsReplaced();
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value.
               Note: point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }
             /*!
                Inserts a \a point in the series at \a index position.
             */
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points.insert(index, point);
                 emit pointAdded(index);
             }
             /*!
                 Removes all points from the series.
             */
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 Returns list of points in the series.
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen != pen) {
                     bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             void QXYSeries::setColor(const QColor &color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QXYSeries::color() const
             {
                 return pen().color();
             }
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(0);
                 qreal minY(0);
                 qreal maxX(1);
                 qreal maxY(1);
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if (!points.isEmpty()){
                     minX = points[0].x();
                     minY = points[0].y();
                     maxX = minX;
                     maxY = minY;
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }
                 }
                 domain.setRange(minX,maxX,minY,maxY);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::initializeAxis(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QXYSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValues;
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart_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 XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include "xyanimation_p.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChart :  public ChartElement
             {
                  Q_OBJECT
             public:
                  explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
                 ~XYChart() {}
                 void setGeometryPoints(const QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setClipRect(const QRectF &rect);
                 QRectF clipRect() const { return m_clipRect; }
                 QSizeF size() const { return m_size; }
                 QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 bool isDirty() const { return m_dirty; }
                 void setDirty(bool dirty);
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handlePointsReplaced();
                 void handleDomainUpdated();
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF& point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = -1);
                 QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             protected:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation* m_animation;
                 bool m_dirty;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

tests/auto/auto.pro +1 -1

             !include( ../tests.pri ) {
              error( "Couldn't find the tests.pri file!" )
             }
             TEMPLATE = subdirs
             SUBDIRS += \
                        qchartview \
                        qchart \
                        qlineseries \
                        qbarset \
                        qbarseries \
                        qstackedbarseries \
                        qpercentbarseries \
                        qpieslice qpieseries \
                        qpiemodelmapper \
                        qsplineseries \
                        qscatterseries \
                        qxymodelmapper \
                        qbarmodelmapper \
                        qhorizontalbarseries \
                        qhorizontalstackedbarseries \
                        qhorizontalpercentbarseries \
-                       qvaluesaxis \
+                       qvalueaxis \
                        qintervalsaxis \
                        qdatetimeaxis \
                        qbarcategoriesaxis
             test_private:{
                 SUBDIRS += domain chartdataset
             }

tests/auto/chartdataset/tst_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 <QtTest/QtTest>
             #include <qabstractaxis.h>
-            #include <qvaluesaxis.h>
+            #include <qvalueaxis.h>
             #include <qbarcategoriesaxis.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public Q_SLOTS:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private Q_SLOTS:
             	void chartdataset_data();
             	void chartdataset();
             	void addSeries_data();
             	void addSeries();
                 void setAxisX_data();
                 void setAxisX();
                 void setAxisY_data();
                 void setAxisY();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
                 void seriesCount_data();
             	void seriesCount();
                 void seriesIndex_data();
             	void seriesIndex();
             	void domain_data();
             	void domain();
                 void zoomInDomain_data();
             	void zoomInDomain();
                 void zoomOutDomain_data();
                 void zoomOutDomain();
                 void scrollDomain_data();
                 void scrollDomain();
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
                 m_dataset = new ChartDataSet();
             }
             void tst_ChartDataSet::cleanup()
             {
                 QList<QAbstractSeries*> series = m_dataset->series();
                 foreach(QAbstractSeries* serie, series)
                 {
                     m_dataset->removeSeries(serie);
                 }
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axisX(0) == 0);
             	QVERIFY(m_dataset->axisY(0) == 0);
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(m_dataset->seriesIndex(series),-1);
             	QVERIFY(m_dataset->domain(series) == 0);
             	QVERIFY(m_dataset->axisX(series) == 0);
             	QVERIFY(m_dataset->axisY(series) == 0);
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::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("line") << line;
             	QTest::newRow("area") << area;
             	QTest::newRow("scatter") << scatter;
             	QTest::newRow("spline") << spline;
             	QTest::newRow("pie") << pie;
                 QTest::newRow("bar") << bar;
             	QTest::newRow("percent") << percent;
             	QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 if(series->type()==QAbstractSeries::SeriesTypePie){
                     TRY_COMPARE(spy0.count(), 0);
                 }else{
                     TRY_COMPARE(spy0.count(), 2);
                 }
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::setAxisX_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 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("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << (QList<QAbstractAxis*>() << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this)) << 3;
                 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
                     << (QList<QAbstractAxis*>() << new QValueAxis(this)) << 1;
                 QList<QAbstractAxis*> axes0;
                 axes0 << new QValueAxis(this) << new QValueAxis(this);
                 axes0 << axes0.last();
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << axes0 << 2;
                 //TODO: add more test cases
             }
             void tst_ChartDataSet::setAxisX()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxis(seriesList.at(i),axisList.at(i),Qt::Horizontal);
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::setAxisY_data()
             {
                 setAxisX_data();
             }
             void tst_ChartDataSet::setAxisY()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxis(seriesList.at(i),axisList.at(i),Qt::Vertical);
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeSeries(series);
                 TRY_COMPARE(spy0.count(), 0);
                 if (series->type() == QAbstractSeries::SeriesTypePie) {
                     TRY_COMPARE(spy1.count(), 0);
                 }
                 else {
                     TRY_COMPARE(spy1.count(), 2);
                 }
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
                         << new QScatterSeries(this))
                     << (QList<QAbstractAxis*>() << new QValueAxis(this) << new QValueAxis(this)
                         << new QValueAxis(this)) << 3;
                 //TODO:
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxis(seriesList.at(i), axisList.at(i),Qt::Horizontal);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeAllSeries();
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), axisCount);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), seriesList.count());
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<int>("seriesCount");
                 QTest::newRow("line,line, line, spline  3") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) ) << 3;
                 QTest::newRow("scatter,scatter, line, line  2") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(int, seriesCount);
                 foreach(QAbstractSeries* series, seriesList){
                       m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
                 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->removeSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 1)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(2));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->removeSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2 && i != 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(2));
                 m_dataset->addSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i == 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
                     else if (i == 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 QVERIFY(m_dataset->domain(series));
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 QList<QVariant> arguments = spy2.takeFirst();
                 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
                 QVERIFY(m_dataset->domain(series) == domain);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 QTest::addColumn<bool >("sameAxis");
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
                 QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(bool, sameAxis);
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 if(sameAxis) m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(updated()));
                 }
                 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll(spyList);
             }
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 zoomInDomain_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(bool, sameAxis);
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 if (sameAxis)
                     m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(updated()));
                 }
                 m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll (spyList);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 zoomInDomain_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(bool, sameAxis);
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 if (sameAxis)
                     m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList
                         << new QSignalSpy(m_dataset->domain(series),
                             SIGNAL(updated()));
                 }
                 m_dataset->scrollDomain(10, 10, QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll(spyList);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

tests/auto/qchart/tst_qchart.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 <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 <qvaluesaxis.h>
+            #include <qvalueaxis.h>
             #include <qbarcategoriesaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoriesAxis *)
             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 margins_data();
                 void margins();
                 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();
             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->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().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();
             }
             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 QBarCategoriesAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (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::margins_data()
             {
             }
             void tst_QChart::margins()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < 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();
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==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);
                 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::AxisTypeValues:{
                         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::AxisTypeCategories:{
                 	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(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::AxisTypeValues:{
                             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::AxisTypeCategories:{
             	    	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(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::AxisTypeValues:{
                         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::AxisTypeCategories:{
                 	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(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::AxisTypeValues:{
                             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::AxisTypeCategories:{
             	    	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(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->margins();
                 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());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

tests/auto/qchartview/tst_qchartview.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 <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <cmath>
             #include <tst_definitions.h>
-            #include <qvaluesaxis.h>
+            #include <qvalueaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QChart*)
             Q_DECLARE_METATYPE(QChartView::RubberBands)
             Q_DECLARE_METATYPE(Qt::Key)
             class tst_QChartView : public QObject
             {
                 Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void qchartview_data();
                 void qchartview();
                 void chart_data();
                 void chart();
                 void rubberBand_data();
                 void rubberBand();
             private:
                 QChartView* m_view;
             };
             void tst_QChartView::initTestCase()
             {
                 //test tracks mouse, give a while to user to relese it
                 QTest::qWait(1000);
             }
             void tst_QChartView::cleanupTestCase()
             {
             }
             void tst_QChartView::init()
             {
                 m_view = new QChartView(new QChart());
                 m_view->chart()->legend()->setVisible(false);
             }
             void tst_QChartView::cleanup()
             {
                 delete m_view;
                 m_view =0;
             }
             void tst_QChartView::qchartview_data()
             {
             }
             void tst_QChartView::qchartview()
             {
                 QVERIFY(m_view->chart());
                 QCOMPARE(m_view->rubberBand(), QChartView::NoRubberBand);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 delete(new QChartView());
                 QChartView view;
                 QVERIFY(view.chart());
             }
             void tst_QChartView::chart_data()
             {
                 QTest::addColumn<QChart*>("chart");
                 QTest::newRow("qchart") << new QChart();
             }
             void tst_QChartView::chart()
             {
                 QFETCH(QChart*, chart);
                 QChartView* view = new QChartView(chart);
                 QCOMPARE(view->chart(), chart);
                 delete view;
             }
             void tst_QChartView::rubberBand_data()
             {
                 QTest::addColumn<QChartView::RubberBands>("rubberBand");
                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
                 QTest::addColumn<int>("minX");
                 QTest::addColumn<int>("maxX");
                 QTest::addColumn<int>("minY");
                 QTest::addColumn<int>("maxY");
                 QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << 20 << 180 << 0<< 200;
                 QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << 0 << 200 << 20<< 180;
                 QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 <<20 << 180 << 20<< 180;
             }
             void tst_QChartView::rubberBand()
             {
                 QFETCH(QChartView::RubberBands, rubberBand);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
                 QFETCH(int, minX);
                 QFETCH(int, maxX);
                 QFETCH(int, minY);
                 QFETCH(int, maxY);
                 m_view->setRubberBand(rubberBand);
                 QRectF padding = m_view->chart()->margins();
                 QCOMPARE(m_view->rubberBand(), rubberBand);
                 QLineSeries* line = new QLineSeries();
                 *line << QPointF(0, 0) << QPointF(200, 200);
                 m_view->chart()->addSeries(line);
                 m_view->chart()->createDefaultAxes();
                 m_view->resize(200 + padding.left() + padding.right(), 200 +  padding.top()+ padding.bottom());
                 m_view->show();
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(true);
                 QAbstractAxis* axisY = m_view->chart()->axisY();
                 QSignalSpy spy0(axisY, SIGNAL(rangeChanged(qreal,qreal)));
                 QAbstractAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal,qreal)));
                 QTest::qWaitForWindowShown(m_view);
                 QTest::mouseMove(m_view->viewport(),  QPoint(minX, minY) + padding.topLeft().toPoint());
                 QTest::mousePress(m_view->viewport(), Qt::LeftButton, 0,  QPoint(minX, minY) + padding.topLeft().toPoint());
                 QTest::mouseMove(m_view->viewport(), QPoint(maxX, maxY) + padding.topLeft().toPoint());
                 QTest::mouseRelease(m_view->viewport(), Qt::LeftButton, 0, QPoint(maxX, maxY)+ padding.topLeft().toPoint());
                 TRY_COMPARE(spy0.count(), Xcount);
                 TRY_COMPARE(spy1.count(), Ycount);
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(false);
                 QValueAxis* vaxisX = qobject_cast<QValueAxis*>(axisX);
                 QValueAxis* vaxisY = qobject_cast<QValueAxis*>(axisY);
                 QVERIFY(vaxisX->min() - minX < 1);
                 QVERIFY(vaxisX->max() - maxX < 1);
                 QVERIFY(vaxisY->min() - minY < 1);
                 QVERIFY(vaxisY->max() - maxY < 1);
             }
             QTEST_MAIN(tst_QChartView)
             #include "tst_qchartview.moc"

tests/auto/qvalueaxis/qvalueaxis.pro ~~tests/auto/qvaluesaxis/qvaluesaxis.pro~~ renamed +1 -1

             !include( ../auto.pri ) {
                 error( "Couldn't find the auto.pri file!" )
             }
             HEADERS += ../qabstractaxis/tst_qabstractaxis.h
-            SOURCES += tst_qvaluesaxis.cpp ../qabstractaxis/tst_qabstractaxis.cpp
+            SOURCES += tst_qvalueaxis.cpp ../qabstractaxis/tst_qabstractaxis.cpp

tests/auto/qvalueaxis/tst_qvalueaxis.cpp ~~tests/auto/qvaluesaxis/tst_qvaluesaxis.cpp~~ renamed +6 -6

             /****************************************************************************
              **
              ** 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 "../qabstractaxis/tst_qabstractaxis.h"
-            #include "qvaluesaxis.h"
+            #include "qvalueaxis.h"
             #include <qlineseries.h>
             class tst_QValueAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
-                void qvaluesaxis_data();
+                void qvalueaxis_data();
-                void qvaluesaxis();
+                void qvalueaxis();
                 void max_raw_data();
                 void max_raw();
                 void max_data();
                 void max();
                 void max_animation_data();
                 void max_animation();
                 void min_raw_data();
                 void min_raw();
                 void min_data();
                 void min();
                 void min_animation_data();
                 void min_animation();
                 void niceNumbersEnabled_data();
                 void niceNumbersEnabled();
                 void range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void ticksCount_data();
                 void ticksCount();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
             private:
                 QValueAxis* m_valuesaxis;
                 QLineSeries* m_series;
             };
             void tst_QValueAxis::initTestCase()
             {
             }
             void tst_QValueAxis::cleanupTestCase()
             {
             }
             void tst_QValueAxis::init()
             {
                 m_valuesaxis = new QValueAxis();
                 m_series = new QLineSeries();
                 *m_series << QPointF(-100, -100) << QPointF(0, 0) << QPointF(100, 100);
                 tst_QAbstractAxis::init(m_valuesaxis,m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QValueAxis::cleanup()
             {
                 delete m_series;
                 delete m_valuesaxis;
                 m_series = 0;
                 m_valuesaxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
-            void tst_QValueAxis::qvaluesaxis_data()
+            void tst_QValueAxis::qvalueaxis_data()
             {
             }
-            void tst_QValueAxis::qvaluesaxis()
+            void tst_QValueAxis::qvalueaxis()
             {
                 qabstractaxis();
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->ticksCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValues);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
                 QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->ticksCount(), 5);
             }
             void tst_QValueAxis::max_raw_data()
             {
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0") << 1.0;
                 QTest::newRow("50.0") << 50.0;
                 QTest::newRow("101.0") << 101.0;
             }
             void tst_QValueAxis::max_raw()
             {
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMax(max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QValueAxis::max()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QValueAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QValueAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QValueAxis::min_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::newRow("-1.0") << -1.0;
                 QTest::newRow("-50.0") << -50.0;
                 QTest::newRow("-101.0") << -101.0;
             }
             void tst_QValueAxis::min_raw()
             {
                 QFETCH(qreal, min);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setMin(min);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QValueAxis::min()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QValueAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QValueAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QValueAxis::niceNumbersEnabled_data()
             {
                 QTest::addColumn<bool>("niceNumbersEnabled");
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("ticks");
                 QTest::addColumn<qreal>("expectedMin");
                 QTest::addColumn<qreal>("expectedMax");
                 QTest::addColumn<int>("expectedTicks");
                 QTest::newRow("true 0.1 , 99.0 , 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 1 , 10.0 , 5") << true << 1.0 << 10.0 << 5 << 0.0 << 10.0 << 6;
                 QTest::newRow("true 0.1 , 6.6 , 5") << true << 0.1 << 6.6 << 5 << 0.0 << 8.0 << 5;
                 QTest::newRow("false 0.1 , 6.6 , 5") << false << 0.1 << 6.6 << 5 << 0.1 << 6.6 << 5;
                 QTest::newRow("true 0.1, 99, 5") << true << 0.1 << 99.0 << 5 << 0.0 << 100.0 << 6;
                 QTest::newRow("true 5, 93.5 , 5") << true << 5.0 << 93.5 << 5 << 0.0 << 100.0 << 6;
             }
             void tst_QValueAxis::niceNumbersEnabled()
             {
                 QFETCH(bool, niceNumbersEnabled);
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, ticks);
                 QFETCH(qreal, expectedMin);
                 QFETCH(qreal, expectedMax);
                 QFETCH(int, expectedTicks);
                 m_valuesaxis->setRange(min, max);
                 m_valuesaxis->setTicksCount(ticks);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
                 if(!qFuzzyIsNull(expectedMin - min))
                     QCOMPARE(spy1.count(), 1);
                 if(!qFuzzyIsNull(expectedMax - max))
                     QCOMPARE(spy0.count(), 1);
                 if((!qFuzzyIsNull(expectedMin - min)) || (!qFuzzyIsNull(expectedMax - max)))
                     QCOMPARE(spy2.count(), 1);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - expectedMin), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - expectedMax), "Max not equal");
                 QCOMPARE(m_valuesaxis->ticksCount(), expectedTicks);
             }
             void tst_QValueAxis::range_raw_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << -1.0 << 101.0;
                 QTest::newRow("25.0 - 75.0") << 25.0 << 75.0;
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
             void tst_QValueAxis::range_raw()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_QValueAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QValueAxis::range()
             {
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QValueAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QValueAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QValueAxis::ticksCount_data()
             {
                 QTest::addColumn<int>("ticksCount");
                 QTest::addColumn<int>("expectedCount");
                 QTest::newRow("0") << 2;
                 QTest::newRow("1") << 2;
                 QTest::newRow("2") << 2;
                 QTest::newRow("3") << 3;
                 QTest::newRow("-1") << 2;
             }
             void tst_QValueAxis::ticksCount()
             {
                 QFETCH(int, ticksCount);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setTicksCount(ticksCount);
                 QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_valuesaxis->ticksCount(), ticksCount);
             }
             void tst_QValueAxis::noautoscale_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("1.0 - 101.0") << -1.0 << 101.0;
                 QTest::newRow("25.0 - 75.0") << 25.0 << 75.0;
                 QTest::newRow("101.0") << 40.0 << 60.0;
             }
             void tst_QValueAxis::noautoscale()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 m_valuesaxis->setRange(min, max);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
             }
             void tst_QValueAxis::autoscale_data()
             {
             }
             void tst_QValueAxis::autoscale()
             {
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal, qreal)));
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min()), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max()), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() + 100), "Min not equal");
                 QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - 100), "Max not equal");
             }
             QTEST_MAIN(tst_QValueAxis)
-            #include "tst_qvaluesaxis.moc"
+            #include "tst_qvalueaxis.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