HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2249:707325ca7e43

Added missing count property to QBarCategoryAxis

Tero Ahola -

r2249:707325ca7e43

parent child

Context file:

r2249:707325ca7e43

Collapse all files

tests/auto/qml-qtquicktest/tst_barcategoryaxis.qml created 644 +87 0

@@ -0,0 +1,87
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtQuickTest 1.0
	23	import QtCommercial.Chart 1.2
	24
	25	Rectangle {
	26	width: 400
	27	height: 300
	28
	29	TestCase {
	30	id: tc1
	31	name: "tst_qml-qtquicktest BarCategoryAxis"
	32	when: windowShown
	33
	34	function test_minMax() {
	35	compare(barSeries1.axisX.min, "Jan", "AxisX min");
	36	compare(barSeries1.axisX.max, "Jun", "AxisX max");
	37	compare(barSeries1.axisY.min, 0, "AxisY min");
	38	compare(barSeries1.axisY.max, 10, "AxisY max");
	39	}
	40
	41	function test_categories() {
	42	compare(barSeries1.axisX.count, 6, "AxisX count");
	43
	44	// Replace categories
	45	var cat = barSeries1.axisX.categories;
	46	barSeries1.axisX.categories = ["Tam", "Hel", "Maa", "Huh"];
	47	compare(barSeries1.axisX.count, 4, "AxisX count");
	48	compare(categoriesCountChangedSpy.count, 1, "onCountChanged");
	49	compare(categoriesChangedSpy.count, 1, "onCategoriesChanged");
	50
	51	// Reset the original categories
	52	barSeries1.axisX.categories = cat;
	53	compare(barSeries1.axisX.count, 6, "AxisX count");
	54	compare(categoriesCountChangedSpy.count, 2, "onCountChanged");
	55	compare(categoriesChangedSpy.count, 2, "onCategoriesChanged");
	56	}
	57	}
	58
	59	ChartView {
	60	id: chartView
	61	anchors.fill: parent
	62
	63	BarSeries {
	64	id: barSeries1
	65	axisX: BarCategoryAxis {
	66	id: axisX
	67	categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
	68	}
	69	axisY: ValuesAxis {
	70	id: axisY
	71	min: 0
	72	max: 10
	73	}
	74	}
	75
	76	SignalSpy {
	77	id: categoriesCountChangedSpy
	78	target: axisX
	79	signalName: "countChanged"
	80	}
	81	SignalSpy {
	82	id: categoriesChangedSpy
	83	target: axisX
	84	signalName: "categoriesChanged"
	85	}
	86	}
	87	}

tests/auto/qml-qtquicktest/tst_barcategoryaxis_1_1.qml created 644 +87 0

@@ -0,0 +1,87
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtQuickTest 1.0
	23	import QtCommercial.Chart 1.1
	24
	25	Rectangle {
	26	width: 400
	27	height: 300
	28
	29	TestCase {
	30	id: tc1
	31	name: "tst_qml-qtquicktest BarCategoryAxis 1.1"
	32	when: windowShown
	33
	34	function test_minMax() {
	35	compare(barSeries1.axisX.min, "Jan", "AxisX min");
	36	compare(barSeries1.axisX.max, "Jun", "AxisX max");
	37	compare(barSeries1.axisY.min, 0, "AxisY min");
	38	compare(barSeries1.axisY.max, 10, "AxisY max");
	39	}
	40
	41	function test_categories() {
	42	compare(barSeries1.axisX.count, 6, "AxisX count");
	43
	44	// Replace categories
	45	var cat = barSeries1.axisX.categories;
	46	barSeries1.axisX.categories = ["Tam", "Hel", "Maa", "Huh"];
	47	compare(barSeries1.axisX.count, 4, "AxisX count");
	48	compare(categoriesCountChangedSpy.count, 1, "onCountChanged");
	49	compare(categoriesChangedSpy.count, 1, "onCategoriesChanged");
	50
	51	// Reset the original categories
	52	barSeries1.axisX.categories = cat;
	53	compare(barSeries1.axisX.count, 6, "AxisX count");
	54	compare(categoriesCountChangedSpy.count, 2, "onCountChanged");
	55	compare(categoriesChangedSpy.count, 2, "onCategoriesChanged");
	56	}
	57	}
	58
	59	ChartView {
	60	id: chartView
	61	anchors.fill: parent
	62
	63	BarSeries {
	64	id: barSeries1
	65	axisX: BarCategoryAxis {
	66	id: axisX
	67	categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
	68	}
	69	axisY: ValuesAxis {
	70	id: axisY
	71	min: 0
	72	max: 10
	73	}
	74	}
	75
	76	SignalSpy {
	77	id: categoriesCountChangedSpy
	78	target: axisX
	79	signalName: "countChanged"
	80	}
	81	SignalSpy {
	82	id: categoriesChangedSpy
	83	target: axisX
	84	signalName: "categoriesChanged"
	85	}
	86	}
	87	}

tests/auto/qml-qtquicktest/tst_categoryaxis_1_1.qml created 644 +84 0

@@ -0,0 +1,84
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtQuickTest 1.0
	23	import QtCommercial.Chart 1.1
	24
	25	Rectangle {
	26	width: 400
	27	height: 300
	28
	29	TestCase {
	30	id: tc1
	31	name: "tst_qml-qtquicktest CategoryAxis 1.1"
	32	when: windowShown
	33
	34	function test_minMax() {
	35	compare(lineSeries1.axisX.min, 0, "AxisX min");
	36	compare(lineSeries1.axisX.max, 10, "AxisX max");
	37	compare(lineSeries1.axisY.min, 0, "AxisY min");
	38	compare(lineSeries1.axisY.max, 10, "AxisY max");
	39	}
	40
	41	function test_categories() {
	42	compare(lineSeries1.axisY.startValue, 0, "AxisY start value");
	43	compare(lineSeries1.axisY.count, 3, "AxisY count");
	44	compare(lineSeries1.axisY.categoriesLabels[0], "label0", "AxisY categories labels");
	45	compare(lineSeries1.axisY.categoriesLabels[1], "label1", "AxisY categories labels");
	46	compare(lineSeries1.axisY.categoriesLabels[2], "label2", "AxisY categories labels");
	47	}
	48	}
	49
	50	ChartView {
	51	id: chartView
	52	anchors.fill: parent
	53
	54	LineSeries {
	55	id: lineSeries1
	56	axisX: ValuesAxis {
	57	id: axisX
	58	min: 0
	59	max: 10
	60	}
	61	axisY: CategoryAxis {
	62	id: axisY
	63	min: 0
	64	max: 10
	65	startValue: 0
	66	CategoryRange {
	67	label: "label0"
	68	endValue: 1
	69	}
	70	CategoryRange {
	71	label: "label1"
	72	endValue: 3
	73	}
	74	CategoryRange {
	75	label: "label2"
	76	endValue: 10
	77	}
	78	}
	79	XYPoint { x: -1; y: -1 }
	80	XYPoint { x: 0; y: 0 }
	81	XYPoint { x: 5; y: 5 }
	82	}
	83	}
	84	}

tests/auto/qml-qtquicktest/tst_valueaxis.qml created 644 +102 0

@@ -0,0 +1,102
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	import QtQuick 1.0
	22	import QtQuickTest 1.0
	23	import QtCommercial.Chart 1.2
	24
	25	Rectangle {
	26	width: 400
	27	height: 300
	28
	29	TestCase {
	30	id: tc1
	31	name: "tst_qml-qtquicktest ValueAxis"
	32	when: windowShown
	33
	34	function test_defaultPropertyValues() {
	35	compare(lineSeries1.axisX.min, 0, "AxisX min");
	36	compare(lineSeries1.axisX.max, 10, "AxisX max");
	37	compare(lineSeries1.axisY.min, 0, "AxisY min");
	38	compare(lineSeries1.axisY.max, 10, "AxisY max");
	39	verify(axisX.tickCount > 0, "AxisX tick count");
	40	verify(axisY.tickCount > 0, "AxisX tick count");
	41	compare(axisX.niceNumbersEnabled, false, "nice numbers");
	42	compare(axisX.labelFormat, "", "label format");
	43	}
	44
	45	function test_modifyProperties() {
	46	lineSeries1.axisX.tickCount = 3;
	47	compare(lineSeries1.axisX.tickCount, 3, "set tick count");
	48
	49	lineSeries1.axisX.niceNumbersEnabled = true;
	50	compare(axisX.niceNumbersEnabled, true, "nice numbers");
	51	}
	52
	53	function test_signals() {
	54	axisX.min = 2;
	55	compare(minChangedSpy.count, 1, "onMinChanged");
	56	compare(maxChangedSpy.count, 0, "onMaxChanged");
	57
	58	axisX.max = 8;
	59	compare(minChangedSpy.count, 1, "onMinChanged");
	60	compare(maxChangedSpy.count, 1, "onMaxChanged");
	61
	62	// restore original values
	63	axisX.min = 0;
	64	axisX.max = 10;
	65	compare(minChangedSpy.count, 2, "onMinChanged");
	66	compare(maxChangedSpy.count, 2, "onMaxChanged");
	67	}
	68	}
	69
	70	ChartView {
	71	id: chartView
	72	anchors.fill: parent
	73
	74	LineSeries {
	75	id: lineSeries1
	76	axisX: ValueAxis {
	77	id: axisX
	78	min: 0
	79	max: 10
	80	}
	81	axisY: ValueAxis {
	82	id: axisY
	83	min: 0
	84	max: 10
	85	}
	86	XYPoint { x: -1; y: -1 }
	87	XYPoint { x: 0; y: 0 }
	88	XYPoint { x: 5; y: 5 }
	89	}
	90
	91	SignalSpy {
	92	id: minChangedSpy
	93	target: axisX
	94	signalName: "minChanged"
	95	}
	96	SignalSpy {
	97	id: maxChangedSpy
	98	target: axisX
	99	signalName: "maxChanged"
	100	}
	101	}
	102	}

plugins/declarative/plugin.cpp +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvalueaxis.h"
             #include "declarativecategoryaxis.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 "declarativemargins.h"
             #ifndef QT_ON_ARM
                 #include "qdatetimeaxis.h"
             #endif
             #include <QAbstractItemModel>
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QList<QPieSlice *>)
             Q_DECLARE_METATYPE(QList<QBarSet *>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartQmlPlugin : public QDeclarativeExtensionPlugin
             {
                 Q_OBJECT
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDeclarativeExtensionInterface")
             #endif
             public:
                 virtual void registerTypes(const char *uri)
                 {
                     Q_ASSERT(QLatin1String(uri) == QLatin1String("QtCommercial.Chart"));
                     qRegisterMetaType<QList<QPieSlice *> >();
                     qRegisterMetaType<QList<QBarSet *> >();
                     // QtCommercial.Chart 1.0
                     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. Use specific types of axis instead."));
                     qmlRegisterUncreatableType<QBarSet>(uri, 1, 0, "BarSetBase",
                                                         QLatin1String("Trying to create uncreatable: BarsetBase."));
                     qmlRegisterUncreatableType<QPieSeries>(uri, 1, 0, "QPieSeries",
                                                            QLatin1String("Trying to create uncreatable: QPieSeries. Use PieSeries instead."));
                     // QtCommercial.Chart 1.1
                     qmlRegisterType<DeclarativeChart, 1>(uri, 1, 1, "ChartView");
                     qmlRegisterType<DeclarativeScatterSeries, 1>(uri, 1, 1, "ScatterSeries");
                     qmlRegisterType<DeclarativeLineSeries, 1>(uri, 1, 1, "LineSeries");
                     qmlRegisterType<DeclarativeSplineSeries, 1>(uri, 1, 1, "SplineSeries");
                     qmlRegisterType<DeclarativeAreaSeries, 1>(uri, 1, 1, "AreaSeries");
                     qmlRegisterType<DeclarativeBarSeries, 1>(uri, 1, 1, "BarSeries");
                     qmlRegisterType<DeclarativeStackedBarSeries, 1>(uri, 1, 1, "StackedBarSeries");
                     qmlRegisterType<DeclarativePercentBarSeries, 1>(uri, 1, 1, "PercentBarSeries");
                     qmlRegisterType<DeclarativeHorizontalBarSeries, 1>(uri, 1, 1, "HorizontalBarSeries");
                     qmlRegisterType<DeclarativeHorizontalStackedBarSeries, 1>(uri, 1, 1, "HorizontalStackedBarSeries");
                     qmlRegisterType<DeclarativeHorizontalPercentBarSeries, 1>(uri, 1, 1, "HorizontalPercentBarSeries");
                     qmlRegisterType<DeclarativePieSeries>(uri, 1, 1, "PieSeries");
                     qmlRegisterType<DeclarativeBarSet>(uri, 1, 1, "BarSet");
+                    qmlRegisterType<QValueAxis>(uri, 1, 1, "ValueAxis");
             #ifndef QT_ON_ARM
                     qmlRegisterType<QDateTimeAxis>(uri, 1, 1, "DateTimeAxis");
             #endif
                     qmlRegisterType<DeclarativeCategoryAxis>(uri, 1, 1, "CategoryAxis");
                     qmlRegisterType<DeclarativeCategoryRange>(uri, 1, 1, "CategoryRange");
                     qmlRegisterType<QBarCategoryAxis>(uri, 1, 1, "BarCategoryAxis");
                     qmlRegisterUncreatableType<DeclarativeMargins>(uri, 1, 1, "Margins",
                                                                    QLatin1String("Trying to create uncreatable: Margins."));
                     // QtCommercial.Chart 1.2
                     qmlRegisterType<DeclarativeChart, 2>(uri, 1, 2, "ChartView");
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
                 Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))
             #endif

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +25 -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 "qbarcategoryaxis.h"
             #include "qbarcategoryaxis_p.h"
             #include "chartbarcategoryaxisx_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
                 BarCategoryAxis 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.
                 Example code on how to use QBarCategoryAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QBarSeries *series = new QBarSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 chartView->chart()->createDefaultAxes();
                 QBarCategoryAxis *axisX = new QBarCategoryAxis;
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 axisX->append(categories);
                 axisX->setRange("Feb", "May");
                 chartView->chart()->setAxisX(axisX, series);
                 \endcode
             */
             /*!
                 \qmlclass BarCategoryAxis QBarCategoryAxis
                 \inherits AbstractAxis
                 \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 BarCategoryAxis you can use ChartView API. For example:
                 \code
                     ChartView {
                         BarCategoryAxis {
                             id: categoryAxis
                             categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoryAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList BarCategoryAxis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoryAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoryAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoryAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty QString BarCategoryAxis::max
               Defines the maximum value on the axis.
             */
+            /*!
+              \property QBarCategoryAxis::count
+              The count of categories.
+            */
+            /*!
+              \qmlproperty int BarCategoryAxis::count
+              The count of categories.
+            */
             /*!
               \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 BarCategoryAxis::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 BarCategoryAxis::onMaxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
+              \fn void QBarCategoryAxis::countChanged()
+              Axis emits signal when the count of categories has changed.
+            */
+            /*!
+              \qmlsignal BarCategoryAxis::onCountChanged()
+              Axis emits signal when the count of categories 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. A maximum of the axis will be changed to last category in \a categories.
                 If there were no categories previously defined, minimum of axis will be also changed to first category in \a categories.
                 A category has to be valid QStrings and can not be duplicated. Duplicated categories will not be appended.
             */
             void QBarCategoryAxis::append(const QStringList &categories)
             {
                 if (categories.isEmpty())
                     return;
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 foreach(QString category, categories) {
                     if (!d->m_categories.contains(category) && !category.isNull()) {
                         d->m_categories.append(category);
                     }
                 }
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0)
                     setRange(d->m_categories.first(), d->m_categories.last());
                 else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
+                emit countChanged();
             }
             /*!
                 Appends \a category to axis. A maximum of the axis will be changed to last \a category.
                 If there were no categories previously defined, minimum of axis will be also changed to \a category.
                 A \a category has to be valid QStrings and can not be duplicated. Duplicated categories will not be appended.
             */
             void QBarCategoryAxis::append(const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.append(category);
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0)
                     setRange(d->m_categories.last(), d->m_categories.last());
                 else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
+                emit countChanged();
             }
             /*!
                 Removes \a category from axis. Removing category which is currently maximum or minimum
                 will affect the axis range.
             */
             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()) {
                         if (d->m_minCategory == category) {
                             setRange(d->m_categories.first(), d->m_maxCategory);
                         } else if (d->m_maxCategory == category) {
                             setRange(d->m_minCategory, d->m_categories.last());
                         } else {
                             d->updateCategoryDomain();
                             d->emitUpdated();
                         }
                     } else {
                         setRange(QString::null, QString::null);
                     }
                     emit categoriesChanged();
+                    emit countChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index. A \a category has to be valid QStrings and can not be duplicated.
                 If \a category is prepended or appended to categories, minimum and maximum of axis is updated accordingly.
             */
             void QBarCategoryAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoryAxis);
                 int count = d->m_categories.count();
                 if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.insert(index, category);
                 if (d->m_categories.count() == count)
                     return;
                 if (count == 0) {
                     setRange(d->m_categories.first(), d->m_categories.first());
                 } else if (index == 0) {
                     setRange(d->m_categories.first(), d->m_maxCategory);
                 } else if (index == count) {
                     setRange(d->m_minCategory, d->m_categories.last());
                 } else {
                     d->updateCategoryDomain();
                     d->emitUpdated();
                 }
                 emit categoriesChanged();
+                emit countChanged();
             }
             /*!
                 Replaces \a oldCategory with \a newCategory. If \a oldCategory does not exits on the axis nothing is done.
-                A \a newVategory has to be valid QStrings and can not be duplicated. In case of replacing minimum or maximum category,
+                A \a newCategory has to be valid QStrings and can not be duplicated. In case of replacing minimum or maximum category,
                 minimum and maximum of axis is updated accordingly.
             */
             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.contains(newCategory) && !newCategory.isNull()) {
                     d->m_categories.replace(pos, newCategory);
                     if (d->m_minCategory == oldCategory) {
                         setRange(newCategory, d->m_maxCategory);
                     } else if (d->m_maxCategory == oldCategory) {
                         setRange(d->m_minCategory, newCategory);
                     } else {
                         d->emitUpdated();
                     }
                     emit categoriesChanged();
+                    emit countChanged();
                 }
             }
             /*!
               Removes all categories. Sets the maximum and minimum of the axis's range to QString::null.
              */
             void QBarCategoryAxis::clear()
             {
                 Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 setRange(QString::null, QString::null);
                 emit categoriesChanged();
+                emit countChanged();
             }
             /*!
                Set \a categories and discards the old ones, range of axis is adjusted to match first and last category in \a categories.
                A category has to be valid QStrings and can not be duplicated.
             */
             void QBarCategoryAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 d->m_minCategory = QString::null;
                 d->m_maxCategory = QString::null;
                 d->m_min = 0;
                 d->m_max = 0;
                 d->m_count = 0;
                 append(categories);
             }
             /*!
                 Returns categories
             */
             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 in case or clearing all categories
                 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(maxCategory) < d->m_categories.indexOf(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 AxisTypeBarCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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 ChartBarCategoryAxisY(q, presenter);
                 return new ChartBarCategoryAxisX(q, presenter);
             }
             void QBarCategoryAxisPrivate::updateCategoryDomain()
             {
                 m_min = m_categories.indexOf(m_minCategory) - 0.5;
                 m_max = m_categories.indexOf(m_maxCategory) + 0.5;
                 m_count = m_max - m_min;
             }
             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_qbarcategoryaxis.cpp"
             #include "moc_qbarcategoryaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/barcategoryaxis/qbarcategoryaxis.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARCATEGORYAXIS_H
             #define QBARCATEGORYAXIS_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategoryAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarCategoryAxis : public QAbstractAxis
             {
                 Q_OBJECT
                 Q_PROPERTY(QStringList categories READ categories WRITE setCategories NOTIFY categoriesChanged)
                 Q_PROPERTY(QString min READ min WRITE setMin NOTIFY minChanged)
                 Q_PROPERTY(QString max READ max WRITE setMax NOTIFY maxChanged)
+                Q_PROPERTY(int count READ count NOTIFY countChanged)
             public:
                 explicit QBarCategoryAxis(QObject *parent = 0);
                 ~QBarCategoryAxis();
             protected:
                 QBarCategoryAxis(QBarCategoryAxisPrivate &d, QObject *parent = 0);
             public:
                 AxisType type() const;
                 void append(const QStringList &categories);
                 void append(const QString &category);
                 void remove(const QString &category);
                 void insert(int index, const QString &category);
                 void replace(const QString &oldCategory, const QString &newCategory);
                 void clear();
                 void setCategories(const QStringList &categories);
                 QStringList categories();
                 int count() const;
                 QString at(int index) const;
                 //range handling
                 void setMin(const QString &minCategory);
                 QString min() const;
                 void setMax(const QString &maxCategory);
                 QString max() const;
                 void setRange(const QString &minCategory, const QString &maxCategory);
             Q_SIGNALS:
                 void categoriesChanged();
                 void minChanged(const QString &min);
                 void maxChanged(const QString &max);
                 void rangeChanged(const QString &min, const QString &max);
+                void countChanged();
             private:
                 Q_DECLARE_PRIVATE(QBarCategoryAxis)
                 Q_DISABLE_COPY(QBarCategoryAxis)
                 friend class ChartBarCategoryAxisX;
                 friend class ChartBarCategoryAxisY;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARCATEGORYAXIS_H

src/axis/categoryaxis/qcategoryaxis.cpp +18 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qcategoryaxis.h"
             #include "qcategoryaxis_p.h"
             #include "chartcategoryaxisx_p.h"
             #include "chartcategoryaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QCategoryAxis
                 \brief The QCategoryAxis class allows putting a named ranges on the axis.
                 \mainclass
                 This class can be used when the underlying data needs to be given extra meaning.
                 Unlike with the QBarCategoryAxis the QCategoryAxis allows the categories ranges widths to be specified freely.
                 Example code on how to use QCategoryAxis:
                 \table
                     \row
                         \o  \br
                             \br
                             \code
                             QChartView *chartView = new QChartView;
                             QLineSeries *series = new QLineSeries;
                             // ...
                             chartView->chart()->addSeries(series);
                             QCategoryAxis *axisY = new QCategoryAxis;
                             axisY->setMin(0);
                             axisY->setMax(52);
                             axisY->setStartValue(15);
                             axisY->append("First", 20);
                             axisY->append("Second", 37);
                             axisY->append("Third", 52);
                             chartView->chart()->setAxisY(axisY, series);
                             \endcode
                         \o \br
                            \inlineimage api_category_axis.png
                 \endtable
             */
             /*!
                 \qmlclass CategoryAxis QCategoryAxis
                 \inherits AbstractAxis
                 \brief CategoryAxis allows putting a named ranges on the axis.
                 For example:
                 \table
                     \row
                         \o  \br
                             \br
                             \br
                             \snippet ../demos/qmlaxes/qml/qmlaxes/View3.qml 1
                         \o \inlineimage demos_qmlaxes3.png
                 \endtable
             */
             /*!
               \property QCategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
               \qmlproperty int CategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
+              \property QCategoryAxis::count
+              The count of categories.
+            */
+            /*!
+              \qmlproperty int CategoryAxis::count
+              The count of categories.
+            */
+            /*!
+              \property QCategoryAxis::categoriesLabels
+              The category labels as a string list.
+            */
+            /*!
+              \qmlproperty StringList CategoryAxis::categoriesLabels
+              The category labels as a list of strings.
+            */
+            /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QCategoryAxis::QCategoryAxis(QObject *parent):
                 QValueAxis(*new QCategoryAxisPrivate(this), parent)
             {
             }
             /*!
                 Destroys the object
             */
             QCategoryAxis::~QCategoryAxis()
             {
             }
             /*!
                 \internal
             */
             QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d, QObject *parent): QValueAxis(d, parent)
             {
             }
             /*!
                 \qmlmethod CategoryAxis::append(string label, real endValue)
                 Appends new category to the axis with an \a label. Category label has to be unique.
                 Parameter \a endValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             /*!
                 Appends new category to the axis with an \a categoryLabel.
                 Category label has to be unique.
                 Parameter \a categoryEndValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             void QCategoryAxis::append(const QString &categoryLabel, qreal categoryEndValue)
             {
                 Q_D(QCategoryAxis);
                 if (!d->m_categories.contains(categoryLabel)) {
                     if (d->m_categories.isEmpty()) {
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
                     } else if (categoryEndValue > endValue(d->m_categories.last())) {
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryEndValue));
                         d->m_categories.append(categoryLabel);
                     }
                 }
             }
             /*!
                 Sets \a min to be the low end limit of the first category on the axis.
                 If there is already some categories added to the axis then passed value must be lower than the high end value of the already defined first category range.
                 Otherwise nothing is done.
             */
             void QCategoryAxis::setStartValue(qreal min)
             {
                 Q_D(QCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categoryMinimum = min;
                 } else {
                     Range range = d->m_categoriesMap.value(d->m_categories.first());
                     if (min < range.second)
                         d->m_categoriesMap.insert(d->m_categories.first(), Range(min, range.second));
                 }
             }
             /*!
                 Returns the low end limit of the category specified by an \a categoryLabel
             */
             qreal QCategoryAxis::startValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 if (categoryLabel.isEmpty())
                     return d->m_categoryMinimum;
                 return d->m_categoriesMap.value(categoryLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
             qreal QCategoryAxis::endValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
             }
             /*!
                 \qmlmethod CategoryAxis::remove(string label)
                 Removes a category specified by the \a label from the axis
             */
             /*!
                 Removes an interval specified by the \a categoryLabel from the axis
             */
             void QCategoryAxis::remove(const QString &categoryLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(categoryLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.removeAt(labelIndex);
                     d->m_categoriesMap.remove(categoryLabel);
                     // the range of the interval that follows (if exists) needs to be updated
                     if (labelIndex < d->m_categories.count()) {
                         QString label = d->m_categories.at(labelIndex);
                         Range range = d->m_categoriesMap.value(label);
                         // set the range
                         if (labelIndex == 0) {
                             range.first = d->m_categoryMinimum;
                             d->m_categoriesMap.insert(label, range);
                         } else {
                             range.first = d->m_categoriesMap.value(d->m_categories.at(labelIndex - 1)).second;
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
                     d->emitUpdated();
                 }
             }
             /*!
               \qmlmethod CategoryAxis::replace(string oldLabel, string newLabel)
               Replaces \a oldLabel of an existing category with a \a newLabel.
               If the old label does not exist the method returns without making any changes.
             */
             /*!
               Replaces \a oldLabel of an existing category with a \a newLabel
               If the old label does not exist the method returns without making any changes.
              */
             void QCategoryAxis::replaceLabel(const QString &oldLabel, const QString &newLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(oldLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.replace(labelIndex, newLabel);
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
                     d->emitUpdated();
                 }
             }
             /*!
               Returns the list of the intervals labels
              */
             QStringList QCategoryAxis::categoriesLabels()
             {
                 Q_D(QCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of intervals.
              */
             int QCategoryAxis::count() const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QCategoryAxis::type() const
             {
                 return QAbstractAxis::AxisTypeCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis *q)
                 : QValueAxisPrivate(q),
                   m_categoryMinimum(0)
             {
             }
             QCategoryAxisPrivate::~QCategoryAxisPrivate()
             {
             }
             int QCategoryAxisPrivate::ticksCount() const
             {
                 return m_categories.count() + 1;
             }
             void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max, int count)
             {
                 Q_UNUSED(count);
                 Q_UNUSED(min);
                 Q_UNUSED(max);
             }
             ChartAxis *QCategoryAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QCategoryAxis);
                 if (m_orientation == Qt::Vertical)
                     return new ChartCategoryAxisY(q, presenter);
                 return new ChartCategoryAxisX(q, presenter);
             }
             #include "moc_qcategoryaxis.cpp"
             #include "moc_qcategoryaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/qbarcategoryaxis/tst_qbarcategoryaxis.cpp +22 -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 "../qabstractaxis/tst_qabstractaxis.h"
             #include <qbarseries.h>
             #include <qbarset.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 qbarcategoryaxis_data();
                 void qbarcategoryaxis();
                 void append2_data();
                 void append2();
                 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";
                 foreach(QString category, categories)
                     m_baraxis->append(category);
                 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::qbarcategoryaxis_data()
             {
             }
             void tst_QBarCategoriesAxis::qbarcategoryaxis()
             {
                 qabstractaxis();
                 QBarCategoryAxis axis;
                 axis.append(QStringList());
                 axis.append(QString());
                 QCOMPARE(axis.count(), 0);
                 QStringList test;
                 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::AxisTypeBarCategory);
             }
             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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.count(), 1);
             }
             void tst_QBarCategoriesAxis::append2_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::append2()
             {
                 QFETCH(QStringList, categories);
                 QBarCategoryAxis axis;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 foreach(QString category, categories)
                     axis.append(category);
                 QCOMPARE(spy0.count(), categories.count());
                 QCOMPARE(spy1.count(), categories.count());
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), categories.count());
                 m_chart->setAxisX(&axis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QCOMPARE(axis.categories(), categories);
                 QCOMPARE(spy0.count(), categories.count());
                 QCOMPARE(spy1.count(), categories.count());
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), categories.count());
+                QCOMPARE(spy4.count(), categories.count());
             }
             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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 QCOMPARE(axis.count(), count);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
+                QCOMPARE(spy4.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") << 1 << "Jun";
                 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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.count(), 1);
                 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)));
                 QSignalSpy spy2(&axis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(&axis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(&axis, SIGNAL(countChanged()));
                 axis.remove(category);
                 QCOMPARE(axis.categories(),result);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), maxCount);
                 QCOMPARE(spy2.count(), minCount);
                 QCOMPARE(spy3.count(), rangeCount);
+                QCOMPARE(spy4.count(), 1);
             }
             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)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(m_baraxis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.count(), 0);
             }
             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)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(m_baraxis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.count(), 0);
             }
             void tst_QBarCategoriesAxis::min_data()
             {
                 min_raw_data();
             }
             void tst_QBarCategoriesAxis::min()
             {
                 min_raw();
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             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)));
                 QSignalSpy spy2(m_baraxis, SIGNAL(minChanged(QString)));
                 QSignalSpy spy3(m_baraxis, SIGNAL(rangeChanged(QString,QString)));
+                QSignalSpy spy4(m_baraxis, SIGNAL(countChanged()));
                 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);
+                QCOMPARE(spy4.count(), 0);
             }
             void tst_QBarCategoriesAxis::range_data()
             {
                 range_raw_data();
             }
             void tst_QBarCategoriesAxis::range()
             {
                 range_raw();
                 m_chart->setAxisX(m_baraxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             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_qbarcategoryaxis.moc"

tests/auto/qml-qtquicktest/tst_categoryaxis.qml ~~tests/auto/qml-qtquicktest/tst_categoriesaxis.qml~~ renamed 0 0

NO CONTENT: file renamed from tests/auto/qml-qtquicktest/tst_categoriesaxis.qml to tests/auto/qml-qtquicktest/tst_categoryaxis.qml

tests/auto/qml-qtquicktest/tst_valueaxis_1_1.qml ~~tests/auto/qml-qtquicktest/tst_valuesaxis.qml~~ renamed +4 -4

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtQuickTest 1.0
-            import QtCommercial.Chart 1.2
+            import QtCommercial.Chart 1.1
             Rectangle {
                 width: 400
                 height: 300
                 TestCase {
                     id: tc1
-                    name: "tst_qml-qtquicktest ValuesAxis"
+                    name: "tst_qml-qtquicktest ValueAxis 1.1"
                     when: windowShown
                     function test_minMax() {
                         compare(lineSeries1.axisX.min, 0, "AxisX min");
                         compare(lineSeries1.axisX.max, 10, "AxisX max");
                         compare(lineSeries1.axisY.min, 0, "AxisY min");
                         compare(lineSeries1.axisY.max, 10, "AxisY max");
                     }
                 }
                 ChartView {
                     id: chartView
                     anchors.fill: parent
                     LineSeries {
                         id: lineSeries1
-                        axisX: ValuesAxis {
+                        axisX: ValueAxis {
                             id: axisX
                             min: 0
                             max: 10
                         }
-                        axisY: ValuesAxis {
+                        axisY: ValueAxis {
                             id: axisY
                             min: 0
                             max: 10
                         }
                         XYPoint { x: -1; y: -1 }
                         XYPoint { x: 0; y: 0 }
                         XYPoint { x: 5; y: 5 }
                     }
                 }
             }

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