HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1810:62c8384299b9

renamed QBarCategoryAxis related files

Marek Rosa -

r1810:62c8384299b9

parent child

Context file:

r1810:62c8384299b9

Collapse all files

plugins/declarative/declarativechart.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 "declarativechart.h"
             #include <QPainter>
             #include "declarativelineseries.h"
             #include "declarativeareaseries.h"
             #include "declarativebarseries.h"
             #include "declarativepieseries.h"
             #include "declarativesplineseries.h"
             #include "declarativescatterseries.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \qmlclass ChartView DeclarativeChart
                 ChartView element is the parent that is responsible for showing different chart series types.
                 The following QML shows how to create a simple chart with one pie series:
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 1
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 2
                 \snippet ../examples/qmlpiechart/qml/qmlpiechart/main.qml 3
                 \beginfloatleft
                 \image examples_qmlpiechart.png
                 \endfloat
                 \clearfloat
             */
             /*!
               \qmlproperty Theme ChartView::theme
               Theme defines the visual appearance of the chart, including for example colors, fonts, line
               widths and chart background.
             */
             /*!
               \qmlproperty Animation ChartView::animation
               Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations,
               ChartView.SeriesAnimations or ChartView.AllAnimations.
             */
             /*!
               \qmlproperty Font ChartView::titleFont
               The title font of the chart
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \qmlproperty string ChartView::title
               The title of the chart, shown on top of the chart.
               \sa ChartView::titleColor
             */
             /*!
               \qmlproperty string ChartView::titleColor
               The color of the title text.
             */
             /*!
               \qmlproperty Axis ChartView::axisX
               The x-axis of the chart.
             */
             /*!
               \qmlproperty Axis ChartView::axisY
               The default y-axis of the chart.
             */
             /*!
               \qmlproperty Legend ChartView::legend
               The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart.
             */
             /*!
               \qmlproperty int ChartView::count
               The count of series added to the chart.
             */
             /*!
               \qmlproperty color ChartView::backgroundColor
               The color of the chart's background. By default background color is defined by chart theme.
               \sa ChartView::theme
             */
             /*!
               \qmlproperty bool ChartView::dropShadowEnabled
               The chart's border drop shadow. Set to true to enable drop shadow.
             */
             /*!
               \qmlproperty real ChartView::topMargin
               The space between the top of chart view and the top of the plot area. The title (if non-empty) is drawn on top margin
               area of the chart view. Top margin area is also used by legend, if aligned to top.
             */
             /*!
               \qmlproperty real ChartView::bottomMargin
               The space between the bottom of chart view and the bottom of the plot area. The bottom margin area may be used by
               legend (if aligned to bottom), x-axis, x-axis labels and x-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::leftMargin
               The space between the left side of chart view and the left side of the plot area. The left margin area may be used by
               legend (if aligned to left), y-axis, y-axis labels and y-axis tick marks.
             */
             /*!
               \qmlproperty real ChartView::rightMargin
               The space between the right side of chart view and the right side of the plot area. The right margin area may be used
               by legend (if aligned to right).
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(int index)
               Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with
               the count property of the chart.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::series(string name)
               Returns the first series on the chart with \a name. If there is no series with that name, returns null.
             */
             /*!
               \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name)
               Creates a series object of \a type to the chart. For example:
               \code
                 var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series");
                 scatter.markerSize = 22;
                 scatter.append(1.1, 2.0);
               \endcode
             */
             /*!
               \qmlmethod Axis ChartView::axisY(QAbstractSeries *series)
               The y-axis of the series. This is the same as the default y-axis of the chart as multiple y-axes are not yet supported.
             */
             /*!
               \qmlmethod ChartView::zoomY(real factor)
               Zooms in by \a factor on the center of the chart.
             */
             /*!
               \qmlmethod ChartView::scrollLeft(real pixels)
               Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValuesAxis::min, ValuesAxis::max, BarCategoriesAxis::min, BarCategoriesAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollRight(real pixels)
               Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValuesAxis::min, ValuesAxis::max, BarCategoriesAxis::min, BarCategoriesAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollUp(real pixels)
               Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValuesAxis::min, ValuesAxis::max, BarCategoriesAxis::min, BarCategoriesAxis::max
             */
             /*!
               \qmlmethod ChartView::scrollDown(real pixels)
               Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation.
               \sa ValuesAxis::min, ValuesAxis::max, BarCategoriesAxis::min, BarCategoriesAxis::max
             */
             /*!
               \qmlsignal ChartView::onTopMarginChanged(real margin)
               The top margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onBottomMarginChanged(real margin)
               The bottom margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onLeftMarginChanged(real margin)
               The left margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             /*!
               \qmlsignal ChartView::onRightMarginChanged(real margin)
               The right margin of the chart view has changed to \a margin. This may happen for example if you modify font size
               related properties of the legend or chart title.
             */
             DeclarativeChart::DeclarativeChart(QDeclarativeItem *parent)
                 : QDeclarativeItem(parent),
                   m_chart(new QChart(this))
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
                 m_chartMargins = m_chart->margins();
                 connect(m_chart, SIGNAL(marginsChanged(QRectF)), this, SLOT(handleMarginsChanged(QRectF)));
             }
             void DeclarativeChart::handleMarginsChanged(QRectF newMargins)
             {
                 if (m_chartMargins.top() != newMargins.top())
                     topMarginChanged(m_chart->margins().top());
                 if (m_chartMargins.bottom() != newMargins.bottom())
                     bottomMarginChanged(m_chart->margins().bottom());
                 if (m_chartMargins.left() != newMargins.left())
                     leftMarginChanged(m_chart->margins().left());
                 if (m_chartMargins.right() != newMargins.right())
                     rightMarginChanged(m_chart->margins().right());
                 m_chartMargins = m_chart->margins();
             }
             DeclarativeChart::~DeclarativeChart()
             {
                 delete m_chart;
             }
             void DeclarativeChart::childEvent(QChildEvent *event)
             {
                 if (event->type() == QEvent::ChildAdded) {
                     if (qobject_cast<QAbstractSeries *>(event->child())) {
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child()));
                     }
                 }
             }
             void DeclarativeChart::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QAbstractSeries *>(child)) {
             //            qDebug() << "DeclarativeChart::componentComplete(), add: " << child;
                         // TODO: how about optional y-axis?
                         m_chart->addSeries(qobject_cast<QAbstractSeries *>(child));
                     }else if(qobject_cast<QAbstractAxis *>(child)){
                     }
                 }
                 QDeclarativeItem::componentComplete();
             }
             void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
             {
             //    qDebug() << "DeclarativeChart::geometryChanged" << newGeometry.width() << newGeometry.height();
                 if (newGeometry.isValid()) {
                     if (newGeometry.width() > 0 && newGeometry.height() > 0) {
                         m_chart->resize(newGeometry.width(), newGeometry.height());
                     }
                 }
                 QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
             }
             void DeclarativeChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 // TODO: optimized?
                 painter->setRenderHint(QPainter::Antialiasing, true);
             }
             void DeclarativeChart::setTheme(DeclarativeChart::Theme theme)
             {
                 QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme;
                 if (chartTheme != m_chart->theme())
                     m_chart->setTheme(chartTheme);
             }
             DeclarativeChart::Theme DeclarativeChart::theme()
             {
                 return (DeclarativeChart::Theme) m_chart->theme();
             }
             void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations)
             {
                 QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations;
                 if (animationOptions != m_chart->animationOptions())
                     m_chart->setAnimationOptions(animationOptions);
             }
             DeclarativeChart::Animation DeclarativeChart::animationOptions()
             {
                 if (m_chart->animationOptions().testFlag(QChart::AllAnimations))
                     return DeclarativeChart::AllAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations))
                     return DeclarativeChart::GridAxisAnimations;
                 else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations))
                     return DeclarativeChart::SeriesAnimations;
                 else
                     return DeclarativeChart::NoAnimation;
             }
             void DeclarativeChart::setTitle(QString title)
             {
                 if (title != m_chart->title())
                     m_chart->setTitle(title);
             }
             QString DeclarativeChart::title()
             {
                 return m_chart->title();
             }
             QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series)
             {
                 return m_chart->axisX(series);
             }
             QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series)
             {
                 return m_chart->axisY(series);
             }
             QLegend *DeclarativeChart::legend()
             {
                 return m_chart->legend();
             }
             void DeclarativeChart::setTitleColor(QColor color)
             {
                 QBrush b = m_chart->titleBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     m_chart->setTitleBrush(b);
                     emit titleColorChanged(color);
                 }
             }
             QFont DeclarativeChart::titleFont() const
             {
                 return m_chart->titleFont();
             }
             void DeclarativeChart::setTitleFont(const QFont& font)
             {
                 m_chart->setTitleFont(font);
             }
             QColor DeclarativeChart::titleColor()
             {
                 return m_chart->titleBrush().color();
             }
             void DeclarativeChart::setBackgroundColor(QColor color)
             {
                 QBrush b = m_chart->backgroundBrush();
                 if (b.style() != Qt::SolidPattern || color != b.color()) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     m_chart->setBackgroundBrush(b);
                     emit backgroundColorChanged();
                 }
             }
             QColor DeclarativeChart::backgroundColor()
             {
                 return m_chart->backgroundBrush().color();
             }
             int DeclarativeChart::count()
             {
                 return m_chart->series().count();
             }
             void DeclarativeChart::setDropShadowEnabled(bool enabled)
             {
                 if (enabled != m_chart->isDropShadowEnabled()) {
                     m_chart->setDropShadowEnabled(enabled);
                     dropShadowEnabledChanged(enabled);
                 }
             }
             bool DeclarativeChart::dropShadowEnabled()
             {
                 return m_chart->isDropShadowEnabled();
             }
             qreal DeclarativeChart::topMargin()
             {
                 return m_chart->margins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
                 return m_chart->margins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
                 return m_chart->margins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
                 return m_chart->margins().right();
             }
             void DeclarativeChart::zoom(qreal factor)
             {
                 m_chart->zoom(factor);
             }
             void DeclarativeChart::scrollLeft(qreal pixels)
             {
                 m_chart->scroll(pixels, 0);
             }
             void DeclarativeChart::scrollRight(qreal pixels)
             {
                 m_chart->scroll(-pixels, 0);
             }
             void DeclarativeChart::scrollUp(qreal pixels)
             {
                 m_chart->scroll(0, pixels);
             }
             void DeclarativeChart::scrollDown(qreal pixels)
             {
                 m_chart->scroll(0, -pixels);
             }
             QAbstractSeries *DeclarativeChart::series(int index)
             {
                 if (index < m_chart->series().count()) {
                     return m_chart->series().at(index);
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::series(QString seriesName)
             {
                 foreach(QAbstractSeries *series, m_chart->series()) {
                     if (series->name() == seriesName)
                         return series;
                 }
                 return 0;
             }
             QAbstractSeries *DeclarativeChart::createSeries(DeclarativeChart::SeriesType type, QString name)
             {
                 QAbstractSeries *series = 0;
                 switch (type) {
                 case DeclarativeChart::SeriesTypeLine:
                     series = new DeclarativeLineSeries();
                     break;
                 case DeclarativeChart::SeriesTypeArea:
                     series = new DeclarativeAreaSeries();
                     break;
                 case DeclarativeChart::SeriesTypeStackedBar:
                     series = new DeclarativeStackedBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePercentBar:
                     series = new DeclarativePercentBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypeBar:
                     series = new DeclarativeBarSeries();
                     break;
                 case DeclarativeChart::SeriesTypePie:
                     series = new DeclarativePieSeries();
                     break;
                 case DeclarativeChart::SeriesTypeScatter:
                     series = new DeclarativeScatterSeries();
                     break;
                 case DeclarativeChart::SeriesTypeSpline:
                     series = new DeclarativeSplineSeries();
                     break;
                 default:
                     qWarning() << "Illegal series type";
                 }
                 series->setName(name);
                 m_chart->addSeries(series);
                 return series;
             }
             void DeclarativeChart::setAxisX(QAbstractAxis* axis, QAbstractSeries *series)
             {
                 m_chart->setAxisX(axis,series);
             }
             void DeclarativeChart::setAxisY(QAbstractAxis* axis, QAbstractSeries *series)
             {
                 m_chart->setAxisY(axis,series);
             }
             void DeclarativeChart::createDefaultAxes()
             {
                 m_chart->createDefaultAxes();
             }
             #include "moc_declarativechart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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 "qvalueaxis.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.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<QBarCategoryAxis>(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/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/valueaxis \
-                $$PWD/categoriesaxis \
+                $$PWD/barcategoryaxis \
                 $$PWD/intervalsaxis \
                 $$PWD/datetimeaxis
             DEPENDPATH += $$PWD \
                 $$PWD/valueaxis \
-                $$PWD/categoriesaxis \
+                $$PWD/barcategoryaxis \
                 $$PWD/intervalsaxis \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/chartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
                 $$PWD/valueaxis/chartvalueaxisx.cpp \
                 $$PWD/valueaxis/chartvalueaxisy.cpp \
                 $$PWD/valueaxis/qvalueaxis.cpp \
-                $$PWD/categoriesaxis/chartcategoriesaxisx.cpp \
+                $$PWD/barcategoryaxis/chartbarcategoryaxisx.cpp \
-                $$PWD/categoriesaxis/chartcategoriesaxisy.cpp \
+                $$PWD/barcategoryaxis/chartbarcategoryaxisy.cpp \
-                $$PWD/categoriesaxis/qbarcategoriesaxis.cpp \
+                $$PWD/barcategoryaxis/qbarcategoryaxis.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/valueaxis/chartvalueaxisx_p.h \
                 $$PWD/valueaxis/chartvalueaxisy_p.h \
                 $$PWD/valueaxis/qvalueaxis_p.h \
-                $$PWD/categoriesaxis/chartcategoriesaxisx_p.h \
+                $$PWD/barcategoryaxis/chartbarcategoryaxisx_p.h \
-                $$PWD/categoriesaxis/chartcategoriesaxisy_p.h \
+                $$PWD/barcategoryaxis/chartbarcategoryaxisy_p.h \
-                $$PWD/categoriesaxis/qbarcategoriesaxis_p.h \
+                $$PWD/barcategoryaxis/qbarcategoryaxis_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/valueaxis/qvalueaxis.h \
-                $$PWD/categoriesaxis/qbarcategoriesaxis.h \
+                $$PWD/barcategoryaxis/qbarcategoryaxis.h \
                 $$PWD/intervalsaxis/qintervalsaxis.h \
                 $$PWD/datetimeaxis/qdatetimeaxis.h

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp ~~src/axis/categoriesaxis/chartcategoriesaxisx.cpp~~ renamed +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 "chartcategoriesaxisx_p.h"
+            #include "chartbarcategoryaxisx_p.h"
             #include "chartpresenter_p.h"
-            #include "qbarcategoriesaxis_p.h"
+            #include "qbarcategoryaxis_p.h"
             #include <QDebug>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisX::~ChartCategoriesAxisX()
             {
             }
             QVector<qreal> ChartCategoriesAxisX::calculateLayout() const
             {
                 int count = m_categoriesAxis->d_ptr->count();
                 Q_ASSERT(count>=1);
                 QVector<qreal> points;
                 points.resize(count+2);
                 const qreal delta = m_rect.width()/(count);
                 qreal offset =-m_min-0.5;
                 if(offset<=0) {
                     offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta) + delta;
                 }
                 else {
                     offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta);
                 }
                 points[0] = m_rect.left();
                 points[count+1] = m_rect.right();
                 for (int i = 0; i < count; ++i) {
                     qreal x = offset + i * delta + m_rect.left();
                     points[i+1] = x;
                 }
                 return points;
             }
             QStringList ChartCategoriesAxisX::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
                 qreal d = (m_max - m_min)/m_rect.width();
                 for (int i = 0;i < layout.count()-1; ++i) {
                     qreal x = qFloor((((layout[i+1] + layout[i])/2-m_rect.left())*d + m_min+0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
                     else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartCategoriesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 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());
                 const qreal delta = m_rect.width()/(m_categoriesAxis->d_ptr->count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = m_rect.left();
                 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());
                     if(i==0){
                         labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }else{
                         labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }
                     if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()>m_rect.right()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         width=rect.width()+labelItem->pos().x();
                     }
                     m_minWidth+=rect.width();
                     m_minHeight=qMax(rect.height()+label_padding,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 ChartCategoriesAxisX::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
                     if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisx_p.h ~~src/axis/categoriesaxis/chartcategoriesaxisx_p.h~~ renamed 0 0

NO CONTENT: file renamed from src/axis/categoriesaxis/chartcategoriesaxisx_p.h to src/axis/barcategoryaxis/chartbarcategoryaxisx_p.h

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp ~~src/axis/categoriesaxis/chartcategoriesaxisy.cpp~~ renamed +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 "chartcategoriesaxisy_p.h"
+            #include "chartbarcategoryaxisy_p.h"
             #include "chartpresenter_p.h"
-            #include "qbarcategoriesaxis_p.h"
+            #include "qbarcategoryaxis_p.h"
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisY::~ChartCategoriesAxisY()
             {
             }
             QVector<qreal> ChartCategoriesAxisY::calculateLayout() const
             {
                 int count = m_categoriesAxis->d_ptr->count();
                 Q_ASSERT(count>=1);
                 QVector<qreal> points;
                 points.resize(count+2);
                 const qreal delta = m_rect.height()/(count);
                 qreal offset = - m_min - 0.5;
                 if(offset<=0) {
                     offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta) + delta;
                 }
                 else {
                     offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta);
                 }
                 points[0] = m_rect.bottom();
                 points[count+1] = m_rect.top();
                 for (int i = 0; i < count; ++i) {
                     int y = m_rect.bottom() - i * delta - offset;
                     points[i+1] = y;
                 }
                 return points;
             }
             QStringList ChartCategoriesAxisY::createCategoryLabels(const QVector<qreal>& layout) const
             {
                 QStringList result;
                 qreal d = (m_max - m_min)/m_rect.height();
                 for (int i = 0;i < layout.count()-1; ++i) {
                     qreal x = qFloor(((m_rect.height()- (layout[i+1] + layout[i])/2 + m_rect.top())*d + m_min+0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
                     }
                     else {
                         // No label for x coordinate
                         result << "";
                     }
                 }
                 result << "";
                 return result;
             }
             void ChartCategoriesAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList = createCategoryLabels(layout);
                 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());
                 const qreal delta = m_rect.height()/(m_categoriesAxis->d_ptr->count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 qreal height = 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());
                     if(i==0) {
                        labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
                     }
                     else {
                         labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
                     }
                     if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_rect.top()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     m_minWidth+=rect.width();
                     m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
                     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 ChartCategoriesAxisY::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
                     if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) {
                         updateGeometry();
                     }
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/chartbarcategoryaxisy_p.h ~~src/axis/categoriesaxis/chartcategoriesaxisy_p.h~~ renamed 0 0

NO CONTENT: file renamed from src/axis/categoriesaxis/chartcategoriesaxisy_p.h to src/axis/barcategoryaxis/chartbarcategoryaxisy_p.h

src/axis/barcategoryaxis/qbarcategoryaxis.cpp ~~src/axis/categoriesaxis/qbarcategoriesaxis.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 "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.h"
-            #include "qbarcategoriesaxis_p.h"
+            #include "qbarcategoryaxis_p.h"
-            #include "chartcategoriesaxisx_p.h"
+            #include "chartbarcategoryaxisx_p.h"
-            #include "chartcategoriesaxisy_p.h"
+            #include "chartbarcategoryaxisy_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarCategoryAxis
                 \brief The QBarCategoryAxis class is used for manipulating chart's axis.
                 \mainclass
                 BarCategoriesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 See the \l {Line and BarChart Example} {Line and BarChart Example} to learn how to do that.
             */
             /*!
                 \qmlclass BarCategoriesAxis QBarCategoryAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 To access BarCategoriesAxis you can use ChartView API. For example:
                 \code
                     ChartView {
                         BarCategoriesAxis {
                             id: categoryAxis
                             categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoryAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList BarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoryAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoryAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QBarCategoryAxis::categoriesChanged()
               Axis emits signal when the categories of the axis has changed.
             */
             /*!
               \fn void QBarCategoryAxis::minChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \qmlsignal BarCategoriesAxis::onMinChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QBarCategoryAxis::maxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \qmlsignal BarCategoriesAxis::onMaxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QBarCategoryAxis::rangeChanged(const QString &min, const QString &max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QBarCategoryAxis::QBarCategoryAxis(QObject *parent):
                 QAbstractAxis(*new QBarCategoryAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QBarCategoryAxis::~QBarCategoryAxis()
             {
                 Q_D(QBarCategoryAxis);
                 if(d->m_dataset){
                        d->m_dataset->removeAxis(this);
                 }
             }
             /*!
                 \internal
             */
             QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QBarCategoryAxis::append(const QStringList &categories)
             {
                 if(categories.isEmpty()) return;
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.append(categories);
                     setRange(categories.first(),categories.last());
                 }else{
                     d->m_categories.append(categories);
                     d->emitUpdated();
                 }
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QBarCategoryAxis::append(const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.append(category);
                     setRange(category,category);
                 }else{
                     d->m_categories.append(category);
                     d->emitUpdated();
                 }
                 emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QBarCategoryAxis::remove(const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     if(!d->m_categories.isEmpty())
                         setRange(d->m_categories.first(),d->m_categories.last());
                     else
                         setRange(QString::null,QString::null);
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QBarCategoryAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.insert(index,category);
                     setRange(category,category);
                 }else{
                     d->m_categories.insert(index,category);
                     d->emitUpdated();
                 }
                 emit categoriesChanged();
             }
             /*!
                 Replaces \a oldCategory with \a newCategory.
                 If \a oldCategory does not exits on the axis nothing is done.
             */
             void QBarCategoryAxis::replace(const QString &oldCategory, const QString &newCategory)
             {
                 Q_D(QBarCategoryAxis);
                 int pos = d->m_categories.indexOf(oldCategory);
                 if (pos != -1) {
                     d->m_categories.replace(pos, newCategory);
                     d->emitUpdated();
                     emit categoriesChanged();
                 }
             }
             /*!
               Removes all categories.
              */
             void QBarCategoryAxis::clear()
             {
                 Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit categoriesChanged();
             }
             void QBarCategoryAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoryAxis);
                 if(d->m_categories!=categories) {
                     d->m_categories = categories;
                     setRange(categories.first(),categories.last());
                     emit categoriesChanged();
                 }
             }
             QStringList QBarCategoryAxis::categories()
             {
                 Q_D(QBarCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QBarCategoryAxis::count() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QBarCategoryAxis::at(int index) const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
             void QBarCategoryAxis::setMin(const QString& min)
             {
                 Q_D(QBarCategoryAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QBarCategoryAxis::min() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
             void QBarCategoryAxis::setMax(const QString& max)
             {
                 Q_D(QBarCategoryAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
             QString QBarCategoryAxis::max() const
             {
                 Q_D(const QBarCategoryAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QBarCategoryAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
                 Q_D(QBarCategoryAxis);
                 bool changed = false;
                 //special case
                 if(minCategory.isNull() && maxCategory.isNull()){
                     d->m_minCategory = minCategory;
                     d->m_maxCategory = maxCategory;
                     d->m_min = 0;
                     d->m_max = 0;
                     emit minChanged(minCategory);
                     emit maxChanged(maxCategory);
                     d->m_count=0;
                     emit rangeChanged(d->m_minCategory,d->m_maxCategory);
                     d->emitUpdated();
                 }
                 if(d->m_categories.indexOf(d->m_maxCategory)<d->m_categories.indexOf(d->m_minCategory)) return;
                 if (!minCategory.isEmpty() && d->m_minCategory!=minCategory && d->m_categories.contains(minCategory)) {
                     d->m_minCategory = minCategory;
                     d->m_min = d->m_categories.indexOf(d->m_minCategory) - 0.5;
                     changed = true;
                     emit minChanged(minCategory);
                 }
                 if (!maxCategory.isEmpty() && d->m_maxCategory!=maxCategory && d->m_categories.contains(maxCategory)) {
                     d->m_maxCategory = maxCategory;
                     d->m_max = d->m_categories.indexOf(d->m_maxCategory) + 0.5;
                     changed = true;
                     emit maxChanged(maxCategory);
                 }
                 if (changed) {
                     d->m_count=d->m_max - d->m_min;
                     emit rangeChanged(d->m_minCategory,d->m_maxCategory);
                     d->emitUpdated();
                 }
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QBarCategoryAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0.0),
                 m_max(0.0),
                 m_count(0)
             {
             }
             QBarCategoryAxisPrivate::~QBarCategoryAxisPrivate()
             {
             }
             void QBarCategoryAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
             void QBarCategoryAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
             void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QBarCategoryAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
             void QBarCategoryAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QBarCategoryAxis);
                 Domain* domain = qobject_cast<Domain*>(sender());
                 if(m_orientation==Qt::Horizontal) {
                     m_min = domain->minX();
                     m_max = domain->maxX();
                 }
                 else if(m_orientation==Qt::Vertical) {
                     m_min = domain->minY();
                     m_max = domain->maxY();
                 }
                 bool changed = false;
                 int min = m_min + 0.5;
                 if(min>=0 && min<m_categories.count()) {
                     QString minCategory = m_categories.at(min);
                     if(m_minCategory!=minCategory && !minCategory.isEmpty()) {
                         m_minCategory=minCategory;
                         changed=true;
                         emit q->minChanged(minCategory);
                     }
                 }
                 int max = m_max - 0.5;
                 if(max>=0 && max<m_categories.count()) {
                     QString maxCategory = m_categories.at(max);
                     if(m_maxCategory!=maxCategory && !maxCategory.isEmpty()) {
                         m_maxCategory=maxCategory;
                         emit q->maxChanged(maxCategory);
                     }
                 }
                 if (changed) {
                     emit q->rangeChanged(m_minCategory,m_maxCategory);
                 }
             }
             ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarCategoryAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             void QBarCategoryAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QBarCategoryAxis);
                 if(m_max==m_min) {
                     int min;
                     int max;
                     if(m_orientation==Qt::Vertical) {
                         min = domain->minY() + 0.5;
                         max = domain->maxY() - 0.5;
                     }
                     else {
                         min = domain->minX() + 0.5;
                         max = domain->maxX() - 0.5;
                     }
                     if(min>0 && min<m_categories.count() && max>0 && max<m_categories.count())
                         q->setRange(m_categories.at(min),m_categories.at(max));
                 }
                 else {
                     if(m_orientation==Qt::Vertical) {
                         domain->setRangeY(m_min, m_max);
                     }
                     else {
                         domain->setRangeX(m_min, m_max);
                     }
                 }
             }
-            #include "moc_qbarcategoriesaxis.cpp"
+            #include "moc_qbarcategoryaxis.cpp"
-            #include "moc_qbarcategoriesaxis_p.cpp"
+            #include "moc_qbarcategoryaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/qbarcategoryaxis.h ~~src/axis/categoriesaxis/qbarcategoriesaxis.h~~ renamed 0 0

NO CONTENT: file renamed from src/axis/categoriesaxis/qbarcategoriesaxis.h to src/axis/barcategoryaxis/qbarcategoryaxis.h

src/axis/barcategoryaxis/qbarcategoryaxis_p.h ~~src/axis/categoriesaxis/qbarcategoriesaxis_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 QBARCATEGORIESAXIS_P_H
             #define QBARCATEGORIESAXIS_P_H
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class QBarCategoryAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
                 QBarCategoryAxisPrivate(QBarCategoryAxis *q);
                 ~QBarCategoryAxisPrivate();
             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_count; }
             private:
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             private:
                 QStringList m_categories;
                 QString m_minCategory;
                 QString m_maxCategory;
                 qreal m_min;
                 qreal m_max;
                 int m_count;
             private:
                 Q_DECLARE_PUBLIC(QBarCategoryAxis);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARCATEGORIESAXIS_P_H

src/barchart/horizontal/bar/qhorizontalbarseries.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 "qhorizontalbarseries.h"
             #include "qhorizontalbarseries_p.h"
             #include "horizontalbarchartitem_p.h"
             #include "horizontalbaranimation_p.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHorizontalBarSeries
                 \brief Series for creating horizontal bar chart
                 \mainclass
                 QHorizontalBarSeries 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. QHorizontalBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {HorizontalBarChart Example} {horizontal bar chart example} to learn how to create a horizontal bar chart.
                 \image examples_horizontalbarchart.png
                 \sa QBarSet, QBarSeries, QPercentBarSeries, QAbstractBarSeries, QStackedBarSeries, QHorizontalStackedBarSeries, QHorizontalPercentBarSeries
             */
             /*
                 // TODO:
                 \qmlclass Horizontal QHorizontalBarSeries
                 \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 QHorizontalBarSeries.
                 QHorizontalBarSeries is QObject which is a child of a \a parent.
             */
             QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent) :
                 QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor
                 Removes series from chart.
             */
             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
                 if(d->m_dataset) {
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalBar.
             */
             QAbstractSeries::SeriesType QHorizontalBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeHorizontalBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QHorizontalBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 qreal y = categoryCount();
                 minX = qMin(minX, min());
                 minY = qMin(minY, - (qreal)0.5);
                 maxX = qMax(maxX, max());
                 maxY = qMax(maxY, y - (qreal)0.5);
                 domain.setRange(minX,maxX,minY,maxY);
             }
             ChartElement* QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QHorizontalBarSeries);
                 HorizontalBarChartItem* bar = new HorizontalBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     bar->setAnimation(new HorizontalBarAnimation(bar));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qhorizontalbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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 "qvalueaxis.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.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<QBarCategoryAxis*>(axis));
                             }
                             break;
                         }
                         case QAbstractSeries::SeriesTypeBar:
                         case QAbstractSeries::SeriesTypePercentBar:
                         case QAbstractSeries::SeriesTypeStackedBar: {
                             if(axis->orientation()==Qt::Horizontal)
                             {
                                 populateCategories(qobject_cast<QBarCategoryAxis*>(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(QBarCategoryAxis* 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 "qvalueaxis.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.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/chartdataset.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qvalueaxis.h"
-            #include "qbarcategoriesaxis.h"
+            #include "qbarcategoryaxis.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 QBarCategoryAxis(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

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 \
                        qvalueaxis \
                        qintervalsaxis \
                        qdatetimeaxis \
-                       qbarcategoriesaxis
+                       qbarcategoryaxis
             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 <qvalueaxis.h>
-            #include <qbarcategoriesaxis.h>
+            #include <qbarcategoryaxis.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/qbarcategoryaxis/qbarcategoryaxis.pro ~~tests/auto/qbarcategoriesaxis/qbarcategoriesaxis.pro~~ renamed +1 -1

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

tests/auto/qbarcategoryaxis/tst_qbarcategoryaxis.cpp ~~tests/auto/qbarcategoriesaxis/tst_qbarcategoriesaxis.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 <qbarseries.h>
             #include <qbarset.h>
-            #include <qbarcategoriesaxis.h>
+            #include <qbarcategoryaxis.h>
             class tst_QBarCategoriesAxis: public tst_QAbstractAxis
             {
             Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
-                void qbarcategoriesaxis_data();
+                void qbarcategoryaxis_data();
-                void qbarcategoriesaxis();
+                void qbarcategoryaxis();
                 void append_data();
                 void append();
                 void at_data();
                 void at();
                 void categories_data();
                 void categories();
                 void clear_data();
                 void clear();
                 void count_data();
                 void count();
                 void insert_data();
                 void insert();
                 void remove_data();
                 void remove();
                 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 range_raw_data();
                 void range_raw();
                 void range_data();
                 void range();
                 void range_animation_data();
                 void range_animation();
                 void noautoscale_data();
                 void noautoscale();
                 void autoscale_data();
                 void autoscale();
             private:
                 QBarCategoryAxis* m_baraxis;
                 QBarSeries* m_series;
             };
             void tst_QBarCategoriesAxis::initTestCase()
             {
             }
             void tst_QBarCategoriesAxis::cleanupTestCase()
             {
             }
             void tst_QBarCategoriesAxis::init()
             {
                 m_baraxis = new QBarCategoryAxis();
                 m_series = new QBarSeries();
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
                 m_series->append(set0);
                 m_series->append(set1);
                 m_series->append(set2);
                 m_series->append(set3);
                 m_series->append(set4);
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 m_baraxis->append(categories);
                 tst_QAbstractAxis::init(m_baraxis, m_series);
                 m_chart->addSeries(m_series);
                 m_chart->createDefaultAxes();
             }
             void tst_QBarCategoriesAxis::cleanup()
             {
                 delete m_series;
                 delete m_baraxis;
                 m_series = 0;
                 m_baraxis = 0;
                 tst_QAbstractAxis::cleanup();
             }
-            void tst_QBarCategoriesAxis::qbarcategoriesaxis_data()
+            void tst_QBarCategoriesAxis::qbarcategoryaxis_data()
             {
             }
-            void tst_QBarCategoriesAxis::qbarcategoriesaxis()
+            void tst_QBarCategoriesAxis::qbarcategoryaxis()
             {
                 qabstractaxis();
                 QBarCategoryAxis axis;
                 axis.append(QStringList());
                 axis.append(QString());
                 QCOMPARE(axis.at(0), QString());
                 QStringList test;
                 test.append(QString());
                 QCOMPARE(axis.categories(),test);
                 axis.clear();
                 QCOMPARE(axis.count(), 0);
                 axis.insert(-1, QString());
                 QCOMPARE(axis.max(), QString());
                 QCOMPARE(axis.min(), QString());
                 axis.remove(QString());
                 axis.setCategories(QStringList());
                 axis.setMax(QString());
                 axis.setMin(QString());
                 axis.setRange(QString(), QString());
                 QCOMPARE(axis.type(), QAbstractAxis::AxisTypeCategories);
             }
             void tst_QBarCategoriesAxis::append_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::newRow("Jan Feb Mar Apr") << (QStringList() << "Jan" << "Feb" << "Mar" << "Apr");
                 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
             }
             void tst_QBarCategoriesAxis::append()
             {
                 QFETCH(QStringList, categories);
                 QBarCategoryAxis axis;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 axis.append(categories);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(axis.categories(), categories);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
             }
             void tst_QBarCategoriesAxis::at_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::addColumn<int>("index");
                 QTest::addColumn<QString>("string");
                 QTest::newRow("Jul Aug Sep 0 Jul") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 0 << "Jul";
                 QTest::newRow("Jul Aug Sep 2 Sep") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 2 << "Sep";
                 QTest::newRow("Jul Aug Sep 1 Aug") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 1 << "Aug";
             }
             void tst_QBarCategoriesAxis::at()
             {
                 QFETCH(int, index);
                 QFETCH(QString, string);
                 QFETCH(QStringList, categories);
                 QBarCategoryAxis axis;
                 axis.append(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 QCOMPARE(axis.at(index), string);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(axis.at(index), string);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
             }
             void tst_QBarCategoriesAxis::categories_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
             }
             void tst_QBarCategoriesAxis::categories()
             {
                 QFETCH(QStringList, categories);
                 QBarCategoryAxis axis;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 axis.setCategories(categories);
                 QCOMPARE(axis.categories(), categories);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(axis.categories(), categories);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
             }
             void tst_QBarCategoriesAxis::clear_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep");
             }
             void tst_QBarCategoriesAxis::clear()
             {
                 QFETCH(QStringList, categories);
                 QBarCategoryAxis axis;
                 axis.setCategories(categories);
                 QCOMPARE(axis.categories(), categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 axis.clear();
                 QCOMPARE(axis.categories(), QStringList());
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(spy0.count(), 2);
                 QCOMPARE(spy1.count(), 2);
                 QCOMPARE(spy2.count(), 2);
                 QCOMPARE(spy3.count(), 2);
                 axis.clear();
                 QCOMPARE(axis.categories().count(),0);
                 QCOMPARE(spy0.count(), 3);
                 QCOMPARE(spy1.count(), 3);
                 QCOMPARE(spy2.count(), 3);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_QBarCategoriesAxis::count_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::addColumn<int>("count");
                 QTest::newRow("Jul Aug Sep") << (QStringList() << "Jul" << "Aug" << "Sep") << 3;
                 QTest::newRow("Jul Aug ") << (QStringList() << "Jul" << "Aug") << 2;
             }
             void tst_QBarCategoriesAxis::count()
             {
                 QFETCH(QStringList, categories);
                 QFETCH(int, count);
                 QBarCategoryAxis axis;
                 axis.setCategories(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 QCOMPARE(axis.count(), count);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(axis.count(), count);
             }
             void tst_QBarCategoriesAxis::insert_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::addColumn<int>("index");
                 QTest::addColumn<QString>("category");
                 QTest::newRow("Jul Aug Sep 0 Jun") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 0 << "Jun";
                 QTest::newRow("Jul Aug Sep 3 Sep") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 3 << "Sep";
                 QTest::newRow("Jul Aug Sep 2 Summer") <<  (QStringList() << "Jul" << "Aug" << "Sep") << 2 << "Summer";
             }
             void tst_QBarCategoriesAxis::insert()
             {
                 QFETCH(QStringList, categories);
                 QFETCH(int, index);
                 QFETCH(QString, category);
                 QBarCategoryAxis axis;
                 axis.append(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 axis.insert(index, category);
                 QCOMPARE(axis.at(index),category);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QBarCategoriesAxis::remove_data()
             {
                 QTest::addColumn<QStringList>("categories");
                 QTest::addColumn<QString>("category");
                 QTest::addColumn<QStringList>("result");
                 QTest::newRow("Jul Aug Sep 0") << (QStringList() << "Jul" << "Aug" << "Sep") << "Jul" << (QStringList() << "Aug" << "Sep");
                 QTest::newRow("Jul Aug Sep 1") << (QStringList() << "Jul" << "Aug" << "Sep") << "Aug"<< (QStringList() << "Jul" << "Sep");
             }
             void tst_QBarCategoriesAxis::remove()
             {
                 QFETCH(QStringList, categories);
                 QFETCH(QString, category);
                 QFETCH(QStringList, result);
                 QBarCategoryAxis axis;
                 axis.append(categories);
                 int maxCount = axis.max() == category;
                 int minCount = axis.min() == category;
                 int rangeCount = maxCount + minCount;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 axis.remove(category);
                 QCOMPARE(axis.categories(),result);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), maxCount);
                 QCOMPARE(spy2.count(), minCount);
                 QCOMPARE(spy3.count(), rangeCount);
             }
             void tst_QBarCategoriesAxis::max_raw_data()
             {
                 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 QTest::addColumn<QString>("max");
                 QTest::newRow("Feb") << "Feb";
                 QTest::newRow("Apr") << "Apr";
                 QTest::newRow("May") << "May";
             }
             void tst_QBarCategoriesAxis::max_raw()
             {
                 QFETCH(QString, max);
                 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 m_baraxis->setMax(max);
                 QCOMPARE(m_baraxis->max(), max);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 1);
             }
             void tst_QBarCategoriesAxis::max_data()
             {
                 max_raw_data();
             }
             void tst_QBarCategoriesAxis::max()
             {
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 max_raw();
             }
             void tst_QBarCategoriesAxis::max_animation_data()
             {
                 max_data();
             }
             void tst_QBarCategoriesAxis::max_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 max();
             }
             void tst_QBarCategoriesAxis::min_raw_data()
             {
                 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 QTest::addColumn<QString>("min");
                 QTest::newRow("Feb") << "Feb";
                 QTest::newRow("Apr") << "Apr";
                 QTest::newRow("May") << "May";
             }
             void tst_QBarCategoriesAxis::min_raw()
             {
                 QFETCH(QString, min);
                 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 m_baraxis->setMin(min);
                 QCOMPARE(m_baraxis->min(), min);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
             }
             void tst_QBarCategoriesAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QBarCategoriesAxis::min()
             {
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 min_raw();
             }
             void tst_QBarCategoriesAxis::min_animation_data()
             {
                 min_data();
             }
             void tst_QBarCategoriesAxis::min_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 min();
             }
             void tst_QBarCategoriesAxis::range_raw_data()
             {
                 //"Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 QTest::addColumn<QString>("min");
                 QTest::addColumn<QString>("max");
                 QTest::newRow("Feb - Apr") << "Feb" << "Apr";
                 QTest::newRow("Feb - May") << "Feb" << "May";
                 QTest::newRow("Mar - Apr") << "Mar" << "Apr";
             }
             void tst_QBarCategoriesAxis::range_raw()
             {
                 QFETCH(QString, min);
                 QFETCH(QString, max);
                 QSignalSpy spy0(m_baraxis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(m_baraxis, SIGNAL(maxChanged(QString const&)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString const&)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString const&, QString const&)));
                 m_baraxis->setRange(min, max);
                 QCOMPARE(m_baraxis->min(), min);
                 QCOMPARE(m_baraxis->max(), max);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
             }
             void tst_QBarCategoriesAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QBarCategoriesAxis::range()
             {
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 range_raw();
             }
             void tst_QBarCategoriesAxis::range_animation_data()
             {
                 range_data();
             }
             void tst_QBarCategoriesAxis::range_animation()
             {
                 m_chart->setAnimationOptions(QChart::GridAxisAnimations);
                 range();
             }
             void tst_QBarCategoriesAxis::noautoscale_data()
             {
                 QTest::addColumn<QString>("min");
                 QTest::addColumn<QString>("max");
                 QTest::newRow("Feb - Mar") << "Feb" << "Mar";
                 QTest::newRow("Feb - May") << "Feb" << "May";
                 QTest::newRow("Apr - May") << "Apr" << "May";
             }
             void tst_QBarCategoriesAxis::noautoscale()
             {
                 QFETCH(QString, min);
                 QFETCH(QString, max);
                 QSignalSpy spy0(m_baraxis, SIGNAL(maxChanged(QString)));
                 QSignalSpy spy1(m_baraxis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(rangeChanged(QString, QString)));
                 m_baraxis->setRange(min, max);
                 QCOMPARE(m_baraxis->min(),min);
                 QCOMPARE(m_baraxis->max(),max);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_baraxis->min(),min);
                 QCOMPARE(m_baraxis->max(),max);
             }
             void tst_QBarCategoriesAxis::autoscale_data()
             {
             }
             void tst_QBarCategoriesAxis::autoscale()
             {
                 delete m_baraxis;
                 m_baraxis = new QBarCategoryAxis();
                 QSignalSpy spy0(m_baraxis, SIGNAL(maxChanged(QString)));
                 QSignalSpy spy1(m_baraxis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(rangeChanged(QString, QString)));
                 QCOMPARE(m_baraxis->min(),QString());
                 QCOMPARE(m_baraxis->max(),QString());
                 m_chart->setAxisX(m_baraxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(m_baraxis->min(),QString("1"));
                 QCOMPARE(m_baraxis->max(),QString("6"));
             }
             QTEST_MAIN(tst_QBarCategoriesAxis)
-            #include "tst_qbarcategoriesaxis.moc"
+            #include "tst_qbarcategoryaxis.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 <qvalueaxis.h>
-            #include <qbarcategoriesaxis.h>
+            #include <qbarcategoryaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
             Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void 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 QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QScatterSeries(this);
                 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValueAxis() <<  (QAbstractSeries*) new QSplineSeries(this);
                 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPieSeries(this);
                 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValueAxis() <<   (QAbstractSeries*) new QBarSeries(this);
                 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
                 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
             }
             void tst_QChart::axisX()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisX());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisX(axis,series);
                 QVERIFY(m_chart->axisX(series)==axis);
             }
             void tst_QChart::axisY_data()
             {
                 axisX_data();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(!m_chart->axisY());
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QVERIFY(m_chart->axisY(series)==axis);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::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:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                 	   	QVERIFY(caxis!=0);
                 	   	qreal min = caxis->min().toDouble();
                 	   	qreal max = caxis->max().toDouble();
                 	   	m_chart->scroll(50, 0);
                 	   	QVERIFY(min<caxis->min().toDouble());
                 	   	QVERIFY(max<caxis->max().toDouble());
                 		break;
                 	}
                 	default:
                 		qFatal("Unsupported type");
                 		break;
                 }
             }
             void tst_QChart::scroll_left_data()
             {
             	scroll_right_data();
             }
             void tst_QChart::scroll_left()
             {
             	 QFETCH(QAbstractSeries *, series);
             	 m_chart->addSeries(series);
             	 m_chart->createDefaultAxes();
             	 m_view->show();
             	 QTest::qWaitForWindowShown(m_view);
             	 QAbstractAxis * axis = m_chart->axisX();
             	 QVERIFY(axis!=0);
             	 switch(axis->type())
             	    {
             	    	case QAbstractAxis::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:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
             	    	   	QVERIFY(caxis!=0);
             	    	   	qreal min = caxis->min().toDouble();
             	    	   	qreal max = caxis->max().toDouble();
             	    	   	m_chart->scroll(-50, 0);
             	    	   	QVERIFY(min>caxis->min().toDouble());
             	    	   	QVERIFY(max>caxis->max().toDouble());
             	    		break;
             	    	}
             	    	default:
             	    		qFatal("Unsupported type");
             	    		break;
             	    }
             }
             void tst_QChart::scroll_up_data()
             {
             	scroll_right_data();
             }
             void tst_QChart::scroll_up()
             {
                 QFETCH(QAbstractSeries *, series);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QAbstractAxis * axis = m_chart->axisY();
                 QVERIFY(axis!=0);
                 switch(axis->type())
                 {
                 	case QAbstractAxis::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:{
                         QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                 	   	QVERIFY(caxis!=0);
                 	   	qreal min = caxis->min().toDouble();
                 	   	qreal max = caxis->max().toDouble();
                 	   	m_chart->scroll(0, 50);
                 	   	QVERIFY(min<caxis->min().toDouble());
                 	   	QVERIFY(max<caxis->max().toDouble());
                 		break;
                 	}
                 	default:
                 		qFatal("Unsupported type");
                 		break;
                 }
             }
             void tst_QChart::scroll_down_data()
             {
             	scroll_right_data();
             }
             void tst_QChart::scroll_down()
             {
             	 QFETCH(QAbstractSeries *, series);
             	 m_chart->addSeries(series);
             	 m_chart->createDefaultAxes();
             	 m_view->show();
             	 QTest::qWaitForWindowShown(m_view);
             	 QAbstractAxis * axis = m_chart->axisY();
             	 QVERIFY(axis!=0);
             	 switch(axis->type())
             	    {
             	    	case QAbstractAxis::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:{
                             QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
             	    	   	QVERIFY(caxis!=0);
             	    	   	qreal min = caxis->min().toDouble();
             	    	   	qreal max = caxis->max().toDouble();
             	    	   	m_chart->scroll(0, -50);
             	    	   	QVERIFY(min>caxis->min().toDouble());
             	    	   	QVERIFY(max>caxis->max().toDouble());
             	    		break;
             	    	}
             	    	default:
             	    		qFatal("Unsupported type");
             	    		break;
             	    }
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 m_chart->createDefaultAxes();
                 QRectF marigns = m_chart->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"

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