HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1612:859a2158b75a

Refactor CategoriesAxis to BarCategoriesAxis part 1 of 2

Michal Klocek -

r1612:859a2158b75a

parent child

Context file:

r1612:859a2158b75a

Expand all files

demos/qmlchart/qml/qmlchart/View6.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     title: "Bar series"
                     anchors.fill: parent
                     legend.alignment: Qt.AlignBottom
-                    CategoriesAxis {
+                    BarCategoriesAxis {
                         id:myAxis
                         categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                         }
                     BarSeries {
                         id: mySeries
                         BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     }
                     Component.onCompleted: {
                         createDefaultAxes();
                         setAxisX(myAxis,mySeries);
                     }
                 }
                 //![1]
             }

demos/qmlchart/qml/qmlchart/View7.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     title: "Stacked Bar series"
                     anchors.fill: parent
                     legend.alignment: Qt.AlignBottom
-                    CategoriesAxis {
+                    BarCategoriesAxis {
                         id: myAxis;
                         categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                         }
                     StackedBarSeries {
                         id: mySeries;
                         BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     }
                     Component.onCompleted: {
                         createDefaultAxes();
                         setAxisX(myAxis,mySeries);
                     }
                 }
                 //![1]
             }

demos/qmlchart/qml/qmlchart/View8.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     title: "Percent Bar series"
                     anchors.fill: parent
                     legend.alignment: Qt.AlignBottom
-                    CategoriesAxis {
+                    BarCategoriesAxis {
                         id: myAxis
                         categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                         }
                     PercentBarSeries {
                         id: mySeries
                         BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6] }
                         BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                         BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     }
                     Component.onCompleted: {
                         createDefaultAxes();
                          setAxisX(myAxis,mySeries);
                     }
                 }
                 //![1]
             }

demos/qmlcustommodel/qml/qmlcustommodel/main.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             import QmlCustomModel 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     id: chartView
                     title: "Top-5 car brand shares in Finland"
                     anchors.fill: parent
                     animationOptions: ChartView.SeriesAnimations
-                    CategoriesAxis {
+                    BarCategoriesAxis {
                         id: categoryAxis
                         categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                     }
                     // ...
                 //![1]
                     //![2]
                     CustomModel {
                         id: customModel
                         verticalHeaders: ["Manufacturer", "Volkswagen", "Toyota", "Ford", "Skoda", "Volvo", "Others"]
                         CustomModelElement { values: [0, "Manufacturer", 0, 1, 2, 3, 4] }
                         CustomModelElement { values: [1, "Volkswagen", 10.3, 12.0, 12.8, 13.0, 13.8] }
                         CustomModelElement { values: [2, "Toyota", 13.8, 13.5, 16.2, 13.7, 10.7] }
                         CustomModelElement { values: [3, "Ford", 6.4, 7.1, 8.9, 8.2, 8.6] }
                         CustomModelElement { values: [4, "Skoda", 4.7, 5.8, 6.9, 8.3, 8.2] }
                         CustomModelElement { values: [5, "Volvo", 7.1, 6.7, 6.5, 6.3, 7.0] }
                         CustomModelElement { values: [6, "Others", 57.7, 54.9, 48.7, 50.5, 51.7] }
                     }
                     //![2]
                     //![5]
                     BarSeries {
                         name: "Others"
                         barWidth: 0.9
                         visible: false
                         HBarModelMapper {
                             model: customModel
                             firstBarSetRow: 6
                             lastBarSetRow: 6
                             firstColumn: 2
                         }
                     }
                     //![5]
                     //![4]
                     LineSeries {
                         name: "Volkswagen"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 1
                             firstColumn: 2
                         }
                     }
                     //![4]
                     LineSeries {
                         name: "Toyota"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 2
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Ford"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 3
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Skoda"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 4
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         name: "Volvo"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 5
                             firstColumn: 2
                         }
                     }
                     //![3]
                     PieSeries {
                         id: pieSeries
                         size: 0.4
                         horizontalPosition: 0.7
                         verticalPosition: 0.4
                         onClicked: {
                             // Show the selection by exploding the slice
                             slice.exploded = !slice.exploded;
                             // Update the line series to show the yearly data for this slice
                             for (var i = 0; i < chartView.count; i++) {
                                 if (chartView.series(i).name == slice.label) {
                                     chartView.series(i).visible = slice.exploded;
                                 }
                             }
                         }
                     }
                     //![3]
                     VPieModelMapper {
                         series: pieSeries
                         model: customModel
                         labelsColumn: 1
                         valuesColumn: 2
                         firstRow: 1
                     }
                 }
             }

examples/barchart/main.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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QLegend>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 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;
             //![1]
             //![2]
                 QBarSeries* series = new QBarSeries();
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Barchart example");
                 chart->createDefaultAxes();
             //![3]
             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QCategoriesAxis* axis = new QCategoriesAxis();
+                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                 axis->append(categories);
                 chart->setAxisX(axis,series);
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(Qt::AlignBottom);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/barmodelmapper/tablewidget.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 "tablewidget.h"
             #include "customtablemodel.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QChartView>
             #include <QLineSeries>
             #include <QVXYModelMapper>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QHeaderView>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 // create simple model for storing data
                 // user's table data model
                 //! [1]
                 CustomTableModel *model = new CustomTableModel;
                 //! [1]
                 //! [2]
                 // create table view and add model to it
                 QTableView *tableView = new QTableView;
                 tableView->setModel(model);
                 tableView->setMinimumWidth(300);
                 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 //! [2]
                 //! [3]
                 QChart *chart = new QChart;
                 chart->setAnimationOptions(QChart::AllAnimations);
                 //! [3]
                 // series 1
                 //! [4]
                 QBarSeries *series = new QBarSeries;
                 int first = 3;
                 int count = 5;
                 QVBarModelMapper *mapper = new QVBarModelMapper(this);
                 mapper->setFirstBarSetColumn(1);
                 mapper->setLastBarSetColumn(4);
                 mapper->setFirstRow(first);
                 mapper->setRowCount(count);
                 mapper->setSeries(series);
                 mapper->setModel(model);
                 chart->addSeries(series);
                 //! [4]
                 //! [5]
                 // for storing color hex from the series
                 QString seriesColorHex = "#000000";
                 // get the color of the series and use it for showing the mapped area
                 QList<QBarSet*> barsets = series->barSets();
                 for (int i = 0; i < barsets.count(); i++) {
                     seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                     model->addMapping(seriesColorHex, QRect(1 + i, first, 1, barsets.at(i)->count()));
                 }
                 //! [5]
                 //! [6]
                 QStringList categories;
                 categories << "April" << "May" << "June" << "July" << "August";
-                QCategoriesAxis* axis = new QCategoriesAxis();
+                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);
                 //! [6]
                 //! [7]
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setMinimumSize(640, 480);
                 //! [7]
                 //! [8]
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(tableView, 1, 0);
                 mainLayout->addWidget(chartView, 1, 1);
                 mainLayout->setColumnStretch(1, 1);
                 mainLayout->setColumnStretch(0, 0);
                 setLayout(mainLayout);
                 //! [8]
             }

examples/percentbarchart/main.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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QPercentBarSeries>
             #include <QBarSet>
             #include <QLegend>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 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;
             //![1]
             //![2]
                 QPercentBarSeries* series = new QPercentBarSeries();
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Percentbarchart example");
             //![3]
             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QCategoriesAxis* axis = new QCategoriesAxis();
+                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis,series);
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(Qt::AlignBottom);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/stackedbarchart/main.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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLegend>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 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;
             //![1]
             //![2]
                 QStackedBarSeries* series = new QStackedBarSeries();
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Stackedbarchart example");
                 chart->createDefaultAxes();
             //![3]
             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QCategoriesAxis* axis = new QCategoriesAxis();
+                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                 axis->append(categories);
                 chart->setAxisX(axis,series);
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(Qt::AlignBottom);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/stackedbarchartdrilldown/drilldownchart.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 "drilldownchart.h"
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QChart(parent, wFlags)
                 ,m_currentSeries(0)
             {
             }
             void DrilldownChart::changeSeries(DrilldownBarSeries *series)
             {
                 if (m_currentSeries) {
                     removeSeries(m_currentSeries);
                 }
                 m_currentSeries = series;
                 // Reset axis
-                QCategoriesAxis* axis = new QCategoriesAxis();
+                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                 axis->append(m_currentSeries->categories());
                 addSeries(series);
                 createDefaultAxes();
                 setAxisX(axis,series);
                 setTitle(series->name());
             }
             void DrilldownChart::handleClicked(int index, QBarSet *barset)
             {
                 Q_UNUSED(barset)
                 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                 changeSeries(series->drilldownSeries(index));
             }
             #include "moc_drilldownchart.cpp"

plugins/declarative/plugin.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtDeclarative/qdeclarativeextensionplugin.h>
             #include <QtDeclarative/qdeclarative.h>
             #include "qchart.h"
             #include "qabstractaxis.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.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>
             #include <QHXYModelMapper>
             #include <QHPieModelMapper>
             #include <QVPieModelMapper>
             #include <QHBarModelMapper>
             #include <QVBarModelMapper>
             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<QValuesAxis>(uri, 1, 0, "ValuesAxis");
-                    qmlRegisterType<QCategoriesAxis>(uri, 1, 0, "CategoriesAxis");
+                    qmlRegisterType<QBarCategoriesAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                       QLatin1String("Trying to create uncreatable: Legend."));
                     qmlRegisterUncreatableType<QXYSeries>(uri, 1, 0, "XYSeries",
                                                       QLatin1String("Trying to create uncreatable: XYSeries."));
                     qmlRegisterUncreatableType<QAbstractItemModel>(uri, 1, 0, "AbstractItemModel",
                                                       QLatin1String("Trying to create uncreatable: AbstractItemModel."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                       QLatin1String("Trying to create uncreatable: XYModelMapper."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                       QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QBarModelMapper>(uri, 1, 0, "BarModelMapper",
                                                       QLatin1String("Trying to create uncreatable: BarModelMapper."));
                     qmlRegisterUncreatableType<QAbstractSeries>(uri, 1, 0, "AbstractSeries",
                                                       QLatin1String("Trying to create uncreatable: AbstractSeries."));
                     qmlRegisterUncreatableType<QAbstractBarSeries>(uri, 1, 0, "AbstractBarSeries",
                                                          QLatin1String("Trying to create uncreatable: AbstractBarSeries."));
                     qmlRegisterUncreatableType<QAbstractAxis>(uri, 1, 0, "AbstractAxis",
                                                       QLatin1String("Trying to create uncreatable: AbstractAxis."));
                     qmlRegisterUncreatableType<QPieModelMapper>(uri, 1, 0, "PieModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: PieModelMapper."));
                     qmlRegisterUncreatableType<QXYModelMapper>(uri, 1, 0, "XYModelMapper",
                                                                 QLatin1String("Trying to create uncreatable: XYModelMapper."));
                 }
             };
             #include "plugin.moc"
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_EXPORT_PLUGIN2(qtcommercialchartqml, QT_PREPEND_NAMESPACE(ChartQmlPlugin))

src/axis/chartcategoriesaxisx.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 "chartcategoriesaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QGraphicsLayout>
             #include <QDebug>
             #include <QFontMetrics>
             #include <QCategoriesAxis>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoriesAxisX::ChartCategoriesAxisX(QCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
               m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisX::~ChartCategoriesAxisX()
             {
             }
             QVector<qreal> ChartCategoriesAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 // TODO: shift logic
                 const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartCategoriesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 createCategoryLabels(ticksList,m_min,m_max,m_categoriesAxis->categories());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 for (int i = 1; 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-1));
                     labelItem->setText(ticksList.at(i-1));
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
                     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);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartcategoriesaxisx_p.h +3 -3

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

src/axis/chartcategoriesaxisy_p.h +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$
             **
             ****************************************************************************/
             //  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 CHARTCATEGORIESAXISY_H
             #define CHARTCATEGORIESAXISY_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
-            class QCategoriesAxis;
+            class QBarCategoriesAxis;
             class ChartPresenter;
             class ChartCategoriesAxisY : public ChartAxis
             {
             public:
                 ChartCategoriesAxisY(QAbstractAxis *axis, ChartPresenter *presenter);
                 ~ChartCategoriesAxisY();
                 AxisType axisType() const { return Y_AXIS;}
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
             private:
-                QCategoriesAxis *m_categoriesAxis;
+                QBarCategoriesAxis *m_categoriesAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTCATEGORIESAXISY_H */

src/axis/qcategoriesaxis.cpp +45 -45

             /****************************************************************************
             **
             ** 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 "qcategoriesaxis.h"
             #include "qcategoriesaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QCategoriesAxis::QCategoriesAxis(QObject *parent):
+            QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
-                QAbstractAxis(*new QCategoriesAxisPrivate(this),parent)
+                QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
             {
             }
-            QCategoriesAxis::~QCategoriesAxis()
+            QBarCategoriesAxis::~QBarCategoriesAxis()
             {
             }
-            QCategoriesAxis::QCategoriesAxis(QCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
+            QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
-            void QCategoriesAxis::append(const QStringList &categories)
+            void QBarCategoriesAxis::append(const QStringList &categories)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.append(categories);
                 	setRange(categories.first(),categories.last());
                 }else{
                 	d->m_categories.append(categories);
                 }
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
-            void QCategoriesAxis::append(const QString &category)
+            void QBarCategoriesAxis::append(const QString &category)
             {
-            	Q_D(QCategoriesAxis);
+            	Q_D(QBarCategoriesAxis);
             	if (d->m_categories.isEmpty()) {
             		d->m_categories.append(category);
             		setRange(category,category);
             	}else{
             		d->m_categories.append(category);
             	}
             	emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
-            void QCategoriesAxis::remove(const QString &category)
+            void QBarCategoriesAxis::remove(const QString &category)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     setRange(d->m_categories.first(),d->m_categories.last());
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
-            void QCategoriesAxis::insert(int index, const QString &category)
+            void QBarCategoriesAxis::insert(int index, const QString &category)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.insert(index,category);
                 	setRange(category,category);
                 }else{
                 }
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
-            void QCategoriesAxis::clear()
+            void QBarCategoriesAxis::clear()
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit categoriesChanged();
             }
-            void QCategoriesAxis::setCategories(const QStringList &categories)
+            void QBarCategoriesAxis::setCategories(const QStringList &categories)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 if(d->m_categories!=categories){
                 d->m_categories = categories;
                 setRange(categories.first(),categories.last());
                 emit categoriesChanged();
                 }
             }
-            QStringList QCategoriesAxis::categories()
+            QStringList QBarCategoriesAxis::categories()
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
-            int QCategoriesAxis::count() const
+            int QBarCategoriesAxis::count() const
             {
-                Q_D(const QCategoriesAxis);
+                Q_D(const QBarCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
-            QString QCategoriesAxis::at(int index) const
+            QString QBarCategoriesAxis::at(int index) const
             {
-                Q_D(const QCategoriesAxis);
+                Q_D(const QBarCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
-            void QCategoriesAxis::setMin(const QString& min)
+            void QBarCategoriesAxis::setMin(const QString& min)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
-            QString QCategoriesAxis::min() const
+            QString QBarCategoriesAxis::min() const
             {
-                Q_D(const QCategoriesAxis);
+                Q_D(const QBarCategoriesAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
-            void QCategoriesAxis::setMax(const QString& max)
+            void QBarCategoriesAxis::setMax(const QString& max)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
-            QString QCategoriesAxis::max() const
+            QString QBarCategoriesAxis::max() const
             {
-                Q_D(const QCategoriesAxis);
+                Q_D(const QBarCategoriesAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
-            void QCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
+            void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
-                Q_D(QCategoriesAxis);
+                Q_D(QBarCategoriesAxis);
                 int minIndex = d->m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = d->m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 if (maxIndex <= minIndex) {
                     // max must be greater than min
                     return;
                 }
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - (minIndex))) {
                 	d->m_minCategory = minCategory;
                     d->m_min = minIndex;
                     changed = true;
                 }
                 if (!qFuzzyIsNull(d->m_max - (maxIndex))) {
                     d->m_max = maxIndex;
                     d->m_maxCategory = maxCategory;
                     changed = true;
                 }
                 if ((changed)) {
                     d->emitRange();
                     emit categoriesChanged();
                 }
             }
             /*!
                 Returns the type of axis.
             */
-            QAbstractAxis::AxisType QCategoriesAxis::type() const
+            QAbstractAxis::AxisType QBarCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QCategoriesAxisPrivate::QCategoriesAxisPrivate(QCategoriesAxis* q):
+            QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
-            QCategoriesAxisPrivate::~QCategoriesAxisPrivate()
+            QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
             {
             }
-            void QCategoriesAxisPrivate::setMin(const QVariant &min)
+            void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
-            void QCategoriesAxisPrivate::setMax(const QVariant &max)
+            void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
-            void QCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
+            void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
-                Q_Q(QCategoriesAxis);
+                Q_Q(QBarCategoriesAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
-            int QCategoriesAxisPrivate::ticksCount() const
+            int QBarCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
-            void QCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
+            void QBarCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
-            ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
-                Q_Q( QCategoriesAxis);
+                Q_Q( QBarCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
-            void QCategoriesAxisPrivate::emitRange()
+            void QBarCategoriesAxisPrivate::emitRange()
             {
-            	Q_Q( QCategoriesAxis);
+            	Q_Q( QBarCategoriesAxis);
             	if(!q->signalsBlocked()) {
             		emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false);
             	}
             }
             #include "moc_qcategoriesaxis.cpp"
             #include "moc_qcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qcategoriesaxis.h +7 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCATEGORIESAXIS_H
             #define QCATEGORIESAXIS_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QCategoriesAxisPrivate;
+            class QBarCategoriesAxisPrivate;
-            class QTCOMMERCIALCHART_EXPORT QCategoriesAxis : public QAbstractAxis
+            class QTCOMMERCIALCHART_EXPORT QBarCategoriesAxis : 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)
             public:
-                explicit QCategoriesAxis(QObject *parent = 0);
+                explicit QBarCategoriesAxis(QObject *parent = 0);
-                ~QCategoriesAxis();
+                ~QBarCategoriesAxis();
             protected:
-                QCategoriesAxis(QCategoriesAxisPrivate &d,QObject *parent = 0);
+                QBarCategoriesAxis(QBarCategoriesAxisPrivate &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 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);
             private:
-                Q_DECLARE_PRIVATE(QCategoriesAxis)
+                Q_DECLARE_PRIVATE(QBarCategoriesAxis)
-                Q_DISABLE_COPY(QCategoriesAxis)
+                Q_DISABLE_COPY(QBarCategoriesAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_H

src/axis/qcategoriesaxis_p.h +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$
             **
             ****************************************************************************/
             //  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 QCATEGORIESAXIS_P_H
             #define QCATEGORIESAXIS_P_H
             #include "qcategoriesaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QCategoriesAxisPrivate : public QAbstractAxisPrivate
+            class QBarCategoriesAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
-                QCategoriesAxisPrivate(QCategoriesAxis *q);
+                QBarCategoriesAxisPrivate(QBarCategoriesAxis *q);
-                ~QCategoriesAxisPrivate();
+                ~QBarCategoriesAxisPrivate();
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 void emitRange();
             private:
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
                 int ticksCount() const;
             Q_SIGNALS:
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 QStringList m_categories;
                 QString m_minCategory;
                 QString m_maxCategory;
             private:
-                Q_DECLARE_PUBLIC(QCategoriesAxis)
+                Q_DECLARE_PUBLIC(QBarCategoriesAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_P_H

src/barchart/qabstractbarseries.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.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.
             */
             /*!
                 Constructs empty QAbstractBarSeries.
                 QAbstractBarSeries is QObject which is a child of a \a parent.
             */
             QAbstractBarSeries::QAbstractBarSeries(QObject *parent) :
                 QAbstractSeries(*new QAbstractBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs abstractbarseries and owned barsets.
             */
             QAbstractBarSeries::~QAbstractBarSeries()
             {
                 Q_D(QAbstractBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \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);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 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);
                     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 of the bar sets from the series
             */
             void QAbstractBarSeries::clear()
             {
                 Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 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;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(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);
             }
             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());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAbstractBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             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::initializeAxisX(QAbstractAxis* axis)
             {
                 if(axis->type()==QAbstractAxis::AxisTypeCategories)
                 {
-                    QCategoriesAxis* cataxis = qobject_cast<QCategoriesAxis*>(axis);
+                    QBarCategoriesAxis* cataxis = qobject_cast<QBarCategoriesAxis*>(axis);
                     Q_ASSERT(cataxis);
                     QStringList categories;
                     for (int i(1); i < categoryCount()+1; i++)
                     categories << QString::number(i);
                     cataxis->append(categories);
                 }
             }
             void QAbstractBarSeriesPrivate::initializeAxisY(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis)
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisXType() const
             {
                 return QAbstractAxis::AxisTypeCategories;
             }
             QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisYType() const
             {
                 return QAbstractAxis::AxisTypeValues;
             }
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.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 "qvaluesaxis.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis_p.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),
                 m_domainIndex(0)
             {
             }
             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;
                 }
                 series->setParent(this); // take ownership
                 domain = new Domain(series);
                 m_seriesDomainMap.insert(series,domain);
                 series->d_ptr->scaleDomain(*domain);
                 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);
                 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series,domain);
             }
             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->defaultAxisXType();
                         if(axisY) typeY&=axisY->type();
                         else typeY|=i.key()->d_ptr->defaultAxisYType();
                 }
                 if(typeX.testFlag(QAbstractAxis::AxisTypeValues) && typeX.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     i.toFront();
                     while (i.hasNext()) {
                            i.next();
                            QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisXType());
                            i.key()->d_ptr->initializeAxisX(axis);
                            addAxisX(axis,i.key());
                            emit axisAdded(axis,i.value());
                     }
                 }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeX)));
                     i.toFront();
                           while (i.hasNext()) {
                                  i.next();
                                  i.key()->d_ptr->initializeAxisX(axis);
                                  addAxisX(axis,i.key());
                           }
                     emit axisAdded(axis,i.value());
                 }
                 if(typeY.testFlag(QAbstractAxis::AxisTypeValues) && typeY.testFlag(QAbstractAxis::AxisTypeCategories))
                 {
                     i.toFront();
                     while (i.hasNext()) {
                            i.next();
                            QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisYType());
                            i.key()->d_ptr->initializeAxisY(axis);
                            addAxisY(axis,i.key());
                            emit axisAdded(axis,i.value());
                     }
                 }else if(!typeY.testFlag(QAbstractAxis::AxisTypeNoAxis)){
                     QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(typeY)));
                     i.toFront();
                           while (i.hasNext()) {
                                  i.next();
                                  i.key()->d_ptr->initializeAxisY(axis);
                                  addAxisY(axis,i.key());
                           }
                           emit axisAdded(axis,i.value());
                 }
             }
             QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type)
             {
                 QAbstractAxis* axis =0;
                 switch(type) {
                     case QAbstractAxis::AxisTypeValues:
                     axis = new QValuesAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategories:
-                    axis = new QCategoriesAxis(this);
+                    axis = new QBarCategoriesAxis(this);
                     break;
                     default:
                     axis = 0;
                     break;
                 }
                 return axis;
             }
             void ChartDataSet::addAxisX(QAbstractAxis* axis,QAbstractSeries* series) {
                 Domain* domain = m_seriesDomainMap.value(series);
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 axis->d_ptr->m_orientation=Qt::Horizontal;
                 m_seriesAxisXMap.insert(series,axis);
             }
             void ChartDataSet::addAxisY(QAbstractAxis* axis,QAbstractSeries* series) {
                 Domain* domain = m_seriesDomainMap.value(series);
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 axis->d_ptr->m_orientation=Qt::Vertical;
                 m_seriesAxisYMap.insert(series,axis);
             }
             void ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 Domain* domain = m_seriesDomainMap.take(series);
                 if(!domain) {
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                 }
                 emit seriesRemoved(series);
                 delete domain;
                 domain = 0;
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_dataset = 0;
                 removeAxes(series);
             }
             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->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->deleteLater();
                     }
                 }
             }
             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->blockSignals(enabled);
                        if(axisY) axisY->blockSignals(enabled);
                    }
             }
             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) return m_seriesAxisXMap.begin().value();
                 return m_seriesAxisXMap.value(series);
             }
             QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_seriesAxisYMap.begin().value();
                 return m_seriesAxisYMap.value(series);
             }
             void ChartDataSet::setAxisX(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Vertical) {
                     qWarning()<<"Axis already defined as axis Y";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisXMap.take(series);
                 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                 if(oldAxis) {
                     int x = axesX.indexOf(oldAxis);
                     if(x==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int x = axesX.indexOf(axis);
                 if(x==-1) {
                     axis->d_ptr->m_orientation=Qt::Horizontal;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisXMap.insert(series,axis);
                 axis->d_ptr->emitRange();
             }
             void ChartDataSet::setAxisY(QAbstractSeries *series, QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 Domain* domain = m_seriesDomainMap.value(series);
                 if(!domain) {
                     qWarning() << "Series not found on the chart.";
                     return;
                 }
                 if(axis->d_ptr->m_orientation==Qt::Horizontal) {
                     qWarning()<<"Axis already defined as axis X";
                     return;
                 }
                 QAbstractAxis *oldAxis = m_seriesAxisYMap.take(series);
                 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                 if(oldAxis) {
                     int y = axesY.indexOf(oldAxis);
                     if(y==-1) {
                         emit axisRemoved(oldAxis);
                         oldAxis->deleteLater();
                     }
                 }
                 QObject::connect(axis->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                 QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axis->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                 int y = axesY.indexOf(axis);
                 if(y==-1) {
                     axis->d_ptr->m_orientation=Qt::Vertical;
                     emit axisAdded(axis,domain);
                 }
                 m_seriesAxisYMap.insert(series,axis);
                 axis->d_ptr->emitRange();
             }
             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_seriesAxisXMap.keys();
             }
             void ChartDataSet::updateSeries(QAbstractSeries *series)
             {
                 emit seriesUpdated(series);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/chartwidgettest/mainwidget.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartview.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qlineseries.h"
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             #include <QCategoriesAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
                             this, SLOT(addSeries(QString,int,int,QString,bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(labels.at(i), column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
                     QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
-                        QCategoriesAxis* axis = new QCategoriesAxis();
+                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
-                        QCategoriesAxis* axis = new QCategoriesAxis();
+                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else {
                         series = new QPercentBarSeries(this);
-                        QCategoriesAxis* axis = new QCategoriesAxis();
+                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     }
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
                         series->append(set);
                     }
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
                 m_chart->createDefaultAxes();
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chart->setTheme((QChart::ChartTheme) themeIndex);
             }

tests/qmlchartproperties/qml/qmlchartproperties/BarChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Grouped bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 property variant series: mySeries
-                CategoriesAxis {
+                BarCategoriesAxis {
                     id:myAxis;
                     categories: ["2007", "2008", "2009", "2010", "2011", "2012" ] }
                 BarSeries {
                     id: mySeries
                     name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     onNameChanged:              console.log("groupedBarSeries.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("groupedBarSeries.onVisibleChanged: " + series.visible);
                     onClicked:                  console.log("groupedBarSeries.onClicked: " + barset + " " + index);
                     onHovered:                  console.log("groupedBarSeries.onHovered: " + barset + " " + status);
                     onLabelsVisibleChanged:     console.log("groupedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
                     onCountChanged:             console.log("groupedBarSeries.onCountChanged: " + count);
                 }
                 Component.onCompleted: {
                     createDefaultAxes();
                     setAxisX(myAxis,mySeries);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/PercentBarChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Percent bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 property variant series: mySeries
-                CategoriesAxis {
+                BarCategoriesAxis {
                     id: myAxis
                     categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                 }
                 PercentBarSeries {
                     id: mySeries
                     name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     onNameChanged:              console.log("percentBarSeries.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("percentBarSeries.onVisibleChanged: " + series.visible);
                     onClicked:                  console.log("percentBarSeries.onClicked: " + barset + " " + index);
                     onHovered:                  console.log("percentBarSeries.onHovered: " + barset + " " + status);
                     onLabelsVisibleChanged:     console.log("percentBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
                     onCountChanged:             console.log("percentBarSeries.onCountChanged: " + count);
                 }
                 Component.onCompleted: {
                     createDefaultAxes();
                     setAxisX(myAxis,mySeries);
                 }
             }

tests/qmlchartproperties/qml/qmlchartproperties/StackedBarChart.qml +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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             ChartView {
                 title: "Stacked bar series"
                 anchors.fill: parent
                 theme: ChartView.ChartThemeLight
                 legend.alignment: Qt.AlignBottom
                 property variant series: mySeries
-                CategoriesAxis {
+                BarCategoriesAxis {
                     id: myAxis
                     categories: ["2007", "2008", "2009", "2010", "2011", "2012" ]
                 }
                 StackedBarSeries {
                     id: mySeries
                     name: "bar"
                     BarSet { label: "Bob"; values: [2, 2, 3, 4, 5, 6]
                         onClicked:                  console.log("barset.onClicked: " + index);
                         onHovered:                  console.log("barset.onHovered: " + status);
                         onPenChanged:               console.log("barset.onPenChanged: " + pen);
                         onBrushChanged:             console.log("barset.onBrushChanged: " + brush);
                         onLabelChanged:             console.log("barset.onLabelChanged: " + label);
                         onLabelBrushChanged:        console.log("barset.onLabelBrushChanged: " + labelBrush);
                         onLabelFontChanged:         console.log("barset.onLabelFontChanged: " + labelFont);
                         onColorChanged:             console.log("barset.onColorChanged: " + color);
                         onBorderColorChanged:       console.log("barset.onBorderColorChanged: " + color);
                         onLabelColorChanged:        console.log("barset.onLabelColorChanged: " + color);
                         onCountChanged:             console.log("barset.onCountChanged: " + count);
                         onValuesAdded:              console.log("barset.onValuesAdded: " + index + ", " + count);
                         onValuesRemoved:            console.log("barset.onValuesRemoved: " + index + ", " + count);
                         onValueChanged:             console.log("barset.onValuesChanged: " + index);
                     }
                     BarSet { label: "Susan"; values: [5, 1, 2, 4, 1, 7] }
                     BarSet { label: "James"; values: [3, 5, 8, 13, 5, 8] }
                     onNameChanged:              console.log("stackedBarSeries.onNameChanged: " + series.name);
                     onVisibleChanged:           console.log("stackedBarSeries.onVisibleChanged: " + series.visible);
                     onClicked:                  console.log("stackedBarSeries.onClicked: " + barset + " " + index);
                     onHovered:                  console.log("stackedBarSeries.onHovered: " + barset + " " + status);
                     onLabelsVisibleChanged:     console.log("stackedBarSeries.onLabelsVisibleChanged: " + series.labelsVisible);
                     onCountChanged:             console.log("stackedBarSeries.onCountChanged: " + count);
                 }
                 Component.onCompleted: {
                     createDefaultAxes();
                     setAxisX(myAxis,mySeries);
                 }
             }

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