HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1808:f1a8cd777029

QBarCategoriesAxis renamed to QBarCategoryAxis

Marek Rosa -

r1808:f1a8cd777029

parent child

Context file:

r1808:f1a8cd777029

Expand all files

examples/barchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->setAxisX(axis,series);
             //![4]

examples/barmodelmapper/tablewidget.cpp +1 -1

                 //! [6]
                 QStringList categories;
                 categories << "April" << "May" << "June" << "July" << "August";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);

examples/horizontalbarchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->setAxisY(axis,series);
             //![4]

examples/horizontalpercentbarchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisY(axis,series);

examples/horizontalstackedbarchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisY(axis,series);

examples/lineandbar/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axisX = new QBarCategoriesAxis();
+                QBarCategoryAxis* axisX = new QBarCategoryAxis();
                 axisX->append(categories);
                 chart->setAxisX(axisX,lineseries);
                 chart->setAxisX(axisX,barseries);

examples/percentbarchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis,series);

examples/populationpyramid/main.cpp +1 -1

                 categories << "0-4" << "5-9" << "10-14" << "15-19" << "20-24" << "25-29" << "30-34" << "35-39" << "40-44" << "45-49"
                            << "50-54" << "55-59" << "60-64" << "65-69" << "70-74" << "75-79" << "80-84" << "85-89" << "90-";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->setAxisY(axis,series);
             //![4]

examples/scrollchart/main.cpp +1 -1

                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->setAxisX(axis, series2);

examples/stackedbarchart/main.cpp +1 -1

             //![4]
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->setAxisX(axis,series);
             //![4]

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

                 m_currentSeries = series;
                 // Reset axis
-                QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                QBarCategoryAxis* axis = new QBarCategoryAxis();
                 axis->append(m_currentSeries->categories());
                 addSeries(series);

plugins/declarative/plugin.cpp +1 -1

                     qmlRegisterType<QHBarModelMapper>(uri, 1, 0, "HBarModelMapper");
                     qmlRegisterType<QVBarModelMapper>(uri, 1, 0, "VBarModelMapper");
                     qmlRegisterType<QValueAxis>(uri, 1, 0, "ValuesAxis");
-                    qmlRegisterType<QBarCategoriesAxis>(uri, 1, 0, "BarCategoriesAxis");
+                    qmlRegisterType<QBarCategoryAxis>(uri, 1, 0, "BarCategoriesAxis");
                     qmlRegisterUncreatableType<QLegend>(uri, 1, 0, "Legend",
                                                       QLatin1String("Trying to create uncreatable: Legend."));

src/axis/categoriesaxis/chartcategoriesaxisx.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {

src/axis/categoriesaxis/chartcategoriesaxisx_p.h +3 -3

             class QAbstractAxis;
             class ChartPresenter;
-            class QBarCategoriesAxis;
+            class QBarCategoryAxis;
             class ChartCategoriesAxisX : public ChartAxis
             {
             public:
-                ChartCategoriesAxisX(QBarCategoriesAxis *axis, ChartPresenter *presenter);
+                ChartCategoriesAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter);
                 ~ChartCategoriesAxisX();
                 AxisType axisType() const { return X_AXIS;}
             private:
                 QStringList m_categories;
-                QBarCategoriesAxis *m_categoriesAxis;
+                QBarCategoryAxis *m_categoriesAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoriesaxis/chartcategoriesaxisy.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }

src/axis/categoriesaxis/chartcategoriesaxisy_p.h +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
-            class QBarCategoriesAxis;
+            class QBarCategoryAxis;
             class ChartPresenter;
             class ChartCategoriesAxisY : public ChartAxis
             {
             public:
-                ChartCategoriesAxisY(QBarCategoriesAxis *axis, ChartPresenter *presenter);
+                ChartCategoriesAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter);
                 ~ChartCategoriesAxisY();
                 AxisType axisType() const { return Y_AXIS;}
                     void handleAxisUpdated();
             private:
                 QStringList m_categories;
-                QBarCategoriesAxis *m_categoriesAxis;
+                QBarCategoryAxis *m_categoriesAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoriesaxis/qbarcategoriesaxis.cpp +48 -48

             /*!
                 Constructs an axis object which is a child of \a parent.
             */
-            QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
+            QBarCategoryAxis::QBarCategoryAxis(QObject *parent):
-                QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
+                QAbstractAxis(*new QBarCategoryAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
-            QBarCategoriesAxis::~QBarCategoriesAxis()
+            QBarCategoryAxis::~QBarCategoryAxis()
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if(d->m_dataset){
                        d->m_dataset->removeAxis(this);
                 }
             /*!
                 \internal
             */
-            QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
+            QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
-            void QBarCategoriesAxis::append(const QStringList &categories)
+            void QBarCategoryAxis::append(const QStringList &categories)
             {
                 if(categories.isEmpty()) return;
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.append(categories);
                     setRange(categories.first(),categories.last());
             /*!
                 Appends \a category to axis
             */
-            void QBarCategoriesAxis::append(const QString &category)
+            void QBarCategoryAxis::append(const QString &category)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.append(category);
                     setRange(category,category);
             /*!
                 Removes \a category from axis
             */
-            void QBarCategoriesAxis::remove(const QString &category)
+            void QBarCategoryAxis::remove(const QString &category)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     if(!d->m_categories.isEmpty())
             /*!
                 Inserts \a category to axis at \a index
             */
-            void QBarCategoriesAxis::insert(int index, const QString &category)
+            void QBarCategoryAxis::insert(int index, const QString &category)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->m_categories.insert(index,category);
                     setRange(category,category);
                 Replaces \a oldCategory with \a newCategory.
                 If \a oldCategory does not exits on the axis nothing is done.
             */
-            void QBarCategoriesAxis::replace(const QString &oldCategory, const QString &newCategory)
+            void QBarCategoryAxis::replace(const QString &oldCategory, const QString &newCategory)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 int pos = d->m_categories.indexOf(oldCategory);
                 if (pos != -1) {
                     d->m_categories.replace(pos, newCategory);
             /*!
               Removes all categories.
              */
-            void QBarCategoriesAxis::clear()
+            void QBarCategoryAxis::clear()
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit categoriesChanged();
             }
-            void QBarCategoriesAxis::setCategories(const QStringList &categories)
+            void QBarCategoryAxis::setCategories(const QStringList &categories)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 if(d->m_categories!=categories) {
                     d->m_categories = categories;
                     setRange(categories.first(),categories.last());
                 }
             }
-            QStringList QBarCategoriesAxis::categories()
+            QStringList QBarCategoryAxis::categories()
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
-            int QBarCategoriesAxis::count() const
+            int QBarCategoryAxis::count() const
             {
-                Q_D(const QBarCategoriesAxis);
+                Q_D(const QBarCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
-            QString QBarCategoriesAxis::at(int index) const
+            QString QBarCategoryAxis::at(int index) const
             {
-                Q_D(const QBarCategoriesAxis);
+                Q_D(const QBarCategoryAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
-            void QBarCategoriesAxis::setMin(const QString& min)
+            void QBarCategoryAxis::setMin(const QString& min)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
-            QString QBarCategoriesAxis::min() const
+            QString QBarCategoryAxis::min() const
             {
-                Q_D(const QBarCategoriesAxis);
+                Q_D(const QBarCategoryAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
-            void QBarCategoriesAxis::setMax(const QString& max)
+            void QBarCategoryAxis::setMax(const QString& max)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
-            QString QBarCategoriesAxis::max() const
+            QString QBarCategoryAxis::max() const
             {
-                Q_D(const QBarCategoriesAxis);
+                Q_D(const QBarCategoryAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
-            void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
+            void QBarCategoryAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
-                Q_D(QBarCategoriesAxis);
+                Q_D(QBarCategoryAxis);
                 bool changed = false;
             /*!
               Returns the type of the axis
             */
-            QAbstractAxis::AxisType QBarCategoriesAxis::type() const
+            QAbstractAxis::AxisType QBarCategoryAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
+            QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0.0),
                 m_max(0.0),
             }
-            QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
+            QBarCategoryAxisPrivate::~QBarCategoryAxisPrivate()
             {
             }
-            void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
+            void QBarCategoryAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
-            void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
+            void QBarCategoryAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
-            void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
+            void QBarCategoryAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
-                Q_Q(QBarCategoriesAxis);
+                Q_Q(QBarCategoryAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
-            void QBarCategoriesAxisPrivate::handleDomainUpdated()
+            void QBarCategoryAxisPrivate::handleDomainUpdated()
             {
-                Q_Q(QBarCategoriesAxis);
+                Q_Q(QBarCategoryAxis);
                 Domain* domain = qobject_cast<Domain*>(sender());
                 if(m_orientation==Qt::Horizontal) {
                 }
             }
-            ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
-                Q_Q(QBarCategoriesAxis);
+                Q_Q(QBarCategoryAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                 }
             }
-            void QBarCategoriesAxisPrivate::intializeDomain(Domain* domain)
+            void QBarCategoryAxisPrivate::intializeDomain(Domain* domain)
             {
-                Q_Q(QBarCategoriesAxis);
+                Q_Q(QBarCategoryAxis);
                 if(m_max==m_min) {
                     int min;
                     int max;

src/axis/categoriesaxis/qbarcategoriesaxis.h +7 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QBarCategoriesAxisPrivate;
+            class QBarCategoryAxisPrivate;
-            class QTCOMMERCIALCHART_EXPORT QBarCategoriesAxis : public QAbstractAxis
+            class QTCOMMERCIALCHART_EXPORT QBarCategoryAxis : public QAbstractAxis
             {
                 Q_OBJECT
                 Q_PROPERTY(QStringList categories READ categories WRITE setCategories NOTIFY categoriesChanged)
                 Q_PROPERTY(QString max READ max WRITE setMax NOTIFY maxChanged)
             public:
-                explicit QBarCategoriesAxis(QObject *parent = 0);
+                explicit QBarCategoryAxis(QObject *parent = 0);
-                ~QBarCategoriesAxis();
+                ~QBarCategoryAxis();
             protected:
-                QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent = 0);
+                QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
             	void rangeChanged(const QString &min, const QString &max);
             private:
-                Q_DECLARE_PRIVATE(QBarCategoriesAxis)
+                Q_DECLARE_PRIVATE(QBarCategoryAxis)
-                Q_DISABLE_COPY(QBarCategoriesAxis)
+                Q_DISABLE_COPY(QBarCategoryAxis)
                 friend class ChartCategoriesAxisX;
                 friend class ChartCategoriesAxisY;
             };

src/axis/categoriesaxis/qbarcategoriesaxis_p.h +7 -7

             class Domain;
-            class QBarCategoriesAxisPrivate : public QAbstractAxisPrivate
+            class QBarCategoryAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
-                QBarCategoriesAxisPrivate(QBarCategoriesAxis *q);
+                QBarCategoryAxisPrivate(QBarCategoryAxis *q);
-                ~QBarCategoriesAxisPrivate();
+                ~QBarCategoryAxisPrivate();
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 void intializeDomain(Domain* domain);
                 void handleDomainUpdated();
-                qreal min() { return m_min;};
+                qreal min() { return m_min;}
-                qreal max() { return m_max;};
+                qreal max() { return m_max;}
-                int count() const { return m_count; };
+                int count() const { return m_count; }
             private:
                 //range handling
                 int m_count;
             private:
-                Q_DECLARE_PUBLIC(QBarCategoriesAxis);
+                Q_DECLARE_PUBLIC(QBarCategoryAxis);
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.cpp +3 -3

                             if(axis->orientation()==Qt::Vertical)
                             {
-                                populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
+                                populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                             }
                             break;
                         }
                             if(axis->orientation()==Qt::Horizontal)
                             {
-                                populateCategories(qobject_cast<QBarCategoriesAxis*>(axis));
+                                populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                             }
                             break;
                         }
             }
-            void QAbstractBarSeriesPrivate::populateCategories(QBarCategoriesAxis* axis)
+            void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis* axis)
             {
                 QStringList categories;
                 if(axis->categories().isEmpty()) {

src/barchart/qabstractbarseries_p.h +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapper;
-            class QBarCategoriesAxis;
+            class QBarCategoryAxis;
             class QAbstractBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 void labelsVisibleChanged(bool visible);
             private:
-                void populateCategories(QBarCategoriesAxis* axis);
+                void populateCategories(QBarCategoryAxis* axis);
             protected:
                 QList<QBarSet *> m_barSets;

src/chartdataset.cpp +1 -1

                     axis = new QValueAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeCategories:
-                    axis = new QBarCategoriesAxis(this);
+                    axis = new QBarCategoryAxis(this);
                     break;
                 case QAbstractAxis::AxisTypeIntervals:
                     axis = new QIntervalsAxis(this);

tests/auto/qbarcategoriesaxis/tst_qbarcategoriesaxis.cpp +11 -11

                 void autoscale();
             private:
-                QBarCategoriesAxis* m_baraxis;
+                QBarCategoryAxis* m_baraxis;
                 QBarSeries* m_series;
             };
             void tst_QBarCategoriesAxis::init()
             {
-                m_baraxis = new QBarCategoriesAxis();
+                m_baraxis = new QBarCategoryAxis();
                 m_series = new QBarSeries();
                 QBarSet *set0 = new QBarSet("Jane");
             void tst_QBarCategoriesAxis::qbarcategoriesaxis()
             {
                 qabstractaxis();
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.append(QStringList());
                 axis.append(QString());
                 QCOMPARE(axis.at(0), QString());
             {
                 QFETCH(QStringList, categories);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
                 QFETCH(QString, string);
                 QFETCH(QStringList, categories);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.append(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
             {
                 QFETCH(QStringList, categories);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QSignalSpy spy1(&axis, SIGNAL(maxChanged(QString const&)));
             {
                 QFETCH(QStringList, categories);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.setCategories(categories);
                 QCOMPARE(axis.categories(), categories);
                 QFETCH(QStringList, categories);
                 QFETCH(int, count);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.setCategories(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QFETCH(int, index);
                 QFETCH(QString, category);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.append(categories);
                 QSignalSpy spy0(&axis, SIGNAL(categoriesChanged()));
                 QFETCH(QString, category);
                 QFETCH(QStringList, result);
-                QBarCategoriesAxis axis;
+                QBarCategoryAxis axis;
                 axis.append(categories);
                 int maxCount = axis.max() == category;
             void tst_QBarCategoriesAxis::autoscale()
             {
                 delete m_baraxis;
-                m_baraxis = new QBarCategoriesAxis();
+                m_baraxis = new QBarCategoryAxis();
                 QSignalSpy spy0(m_baraxis, SIGNAL(maxChanged(QString)));
                 QSignalSpy spy1(m_baraxis, SIGNAL(minChanged(QString)));

tests/auto/qchart/tst_qchart.cpp +13 -13

             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValueAxis *)
-            Q_DECLARE_METATYPE(QBarCategoriesAxis *)
+            Q_DECLARE_METATYPE(QBarCategoryAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QTest::addColumn<QAbstractSeries *>("series");
-                QTest::newRow("categories,lineSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QLineSeries(this);
+                QTest::newRow("categories,lineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QLineSeries(this);
-                QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
+                QTest::newRow("categories,areaSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
-                QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QScatterSeries(this);
+                QTest::newRow("categories,scatterSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QScatterSeries(this);
-                QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QSplineSeries(this);
+                QTest::newRow("categories,splineSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QSplineSeries(this);
-                QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPieSeries(this);
+                QTest::newRow("categories,pieSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPieSeries(this);
-                QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QBarSeries(this);
+                QTest::newRow("categories,barSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QBarSeries(this);
-                QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
+                QTest::newRow("categories,percentBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
-                QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
+                QTest::newRow("categories,stackedBarSeries") <<  (QAbstractAxis*) new QBarCategoryAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
                 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QLineSeries(this);
                 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValueAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
                 		break;
                 	}
                 	case QAbstractAxis::AxisTypeCategories:{
-                	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
+                        QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                 	   	QVERIFY(caxis!=0);
                 	   	qreal min = caxis->min().toDouble();
                 	   	qreal max = caxis->max().toDouble();
             	    		break;
             	    	}
             	    	case QAbstractAxis::AxisTypeCategories:{
-            	    	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
+                            QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
             	    	   	QVERIFY(caxis!=0);
             	    	   	qreal min = caxis->min().toDouble();
             	    	   	qreal max = caxis->max().toDouble();
                 		break;
                 	}
                 	case QAbstractAxis::AxisTypeCategories:{
-                	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
+                        QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
                 	   	QVERIFY(caxis!=0);
                 	   	qreal min = caxis->min().toDouble();
                 	   	qreal max = caxis->max().toDouble();
             	    		break;
             	    	}
             	    	case QAbstractAxis::AxisTypeCategories:{
-            	    	   	QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
+                            QBarCategoryAxis* caxis = qobject_cast<QBarCategoryAxis*>(axis);
             	    	   	QVERIFY(caxis!=0);
             	    	   	qreal min = caxis->min().toDouble();
             	    	   	qreal max = caxis->max().toDouble();

tests/chartwidgettest/mainwidget.cpp +3 -3

                     QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
-                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                        QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
-                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                        QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else {
                         series = new QPercentBarSeries(this);
-                        QBarCategoriesAxis* axis = new QBarCategoriesAxis();
+                        QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     }

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