HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1321:c4f4e0f381ad

removed categories from barseries. categories are now only on axis

sauimone -

r1321:c4f4e0f381ad

parent child

Context file:

r1321:c4f4e0f381ad

Expand all files

demos/chartthemes/themewidget.cpp +3 -2

                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Bar chart");
-                QBarCategories categories;
+                QStringList categories;
                 for (int i(0); i < valueCount; i++)
                     categories << QString::number(i);
+                chart->axisX()->categories()->insert(categories);
                 QStackedBarSeries* series = new QStackedBarSeries(chart);
-                series->setCategories(categories);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                     foreach (Data data, m_dataTable[i])

examples/groupedbarchart/main.cpp +11 -10

                 QApplication a(argc, argv);
             //![1]
-                QBarCategories categories;
-                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-            //![1]
-            //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
-            //![2]
+            //![1]
-            //![3]
+            //![2]
                 QGroupedBarSeries* series = new QGroupedBarSeries();
-                series->setCategories(categories);
+            //    series->setCategories(categories);
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
-            //![3]
+            //![2]
-            //![4]
+            //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple grouped barchart example");
+            //![3]
+            //![4]
+                QStringList categories;
+                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
+                chart->axisX()->categories()->insert(categories);
             //![4]
             //![5]

examples/legend/mainwidget.h 0 -1

             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
-            //class MainWidget : public QGraphicsWidget
             {
                 Q_OBJECT
             public:

examples/percentbarchart/main.cpp +10 -10

                 QApplication a(argc, argv);
             //![1]
-                QBarCategories categories;
-                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-            //![1]
-            //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
-            //![2]
+            //![1]
-            //![3]
+            //![2]
                 QPercentBarSeries* series = new QPercentBarSeries();
-                series->setCategories(categories);
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
-            //![3]
+            //![2]
-            //![4]
+            //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple percentbarchart example");
+            //![3]
+            //![4]
+                QStringList categories;
+                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
+                chart->axisX()->categories()->insert(categories);
             //![4]
             //![5]

examples/stackedbarchart/main.cpp +10 -10

                 QApplication a(argc, argv);
             //![1]
-                QBarCategories categories;
-                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
-            //![1]
-            //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
-            //![2]
+            //![1]
-            //![3]
+            //![2]
                 QStackedBarSeries* series = new QStackedBarSeries();
-                series->setCategories(categories);
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
-            //![3]
+            //![2]
-            //![4]
+            //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple stackedbarchart example");
+            //![3]
+            //![4]
+                QStringList categories;
+                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
+                chart->axisX()->categories()->insert(categories);
             //![4]
             //![5]

examples/stackedbarchartdrilldown/drilldownchart.cpp +2 -2

                 axisY()->setNiceNumbersEnabled(true);
             }
-            void DrilldownChart::handleClicked(QBarSet *barset, QString category)
+            void DrilldownChart::handleClicked(QBarSet *barset, int index)
             {
                 Q_UNUSED(barset)
                 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
-                changeSeries(series->drilldownSeries(category));
+                changeSeries(series->drilldownSeries(index));
             }
             #include "moc_drilldownchart.cpp"

examples/stackedbarchartdrilldown/drilldownchart.h +1 -1

                 void changeSeries(QAbstractSeries *series);
             public Q_SLOTS:
-                void handleClicked(QBarSet *barset, QString category);
+                void handleClicked(QBarSet *barset, int index);
             private:
                 QAbstractSeries* m_currentSeries;

examples/stackedbarchartdrilldown/drilldownseries.cpp +4 -5

             DrilldownBarSeries::DrilldownBarSeries(QStringList categories, QObject *parent)
                 : QStackedBarSeries(parent)
             {
-                setCategories(categories);
             }
-            void DrilldownBarSeries::mapDrilldownSeries(QString category, DrilldownBarSeries* drilldownSeries)
+            void DrilldownBarSeries::mapDrilldownSeries(int index, DrilldownBarSeries* drilldownSeries)
             {
-                mDrilldownSeries[category] = drilldownSeries;
+                mDrilldownSeries[index] = drilldownSeries;
             }
-            DrilldownBarSeries* DrilldownBarSeries::drilldownSeries(QString category)
+            DrilldownBarSeries* DrilldownBarSeries::drilldownSeries(int index)
             {
-                return mDrilldownSeries[category];
+                return mDrilldownSeries[index];
             }
             #include "moc_drilldownseries.cpp"

examples/stackedbarchartdrilldown/drilldownseries.h +3 -3

             public:
                 DrilldownBarSeries(QStringList categories, QObject *parent = 0);
-                void mapDrilldownSeries(QString category, DrilldownBarSeries* drilldownSeries);
+                void mapDrilldownSeries(int index, DrilldownBarSeries* drilldownSeries);
-                DrilldownBarSeries* drilldownSeries(QString category);
+                DrilldownBarSeries* drilldownSeries(int index);
             private:
-                QMap<QString, DrilldownBarSeries*> mDrilldownSeries;
+                QMap<int, DrilldownBarSeries*> mDrilldownSeries;
             };
             //! [1]

examples/stackedbarchartdrilldown/main.cpp +8 -7

                 seasonSeries->setName("Crop by month - Season");
                 // Each month in season series has drilldown series for weekly data
-                foreach (QString month, months) {
+                for (int month=0; month < months.count(); month++) {
                     // Create drilldown series for every week
                     DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
                     seasonSeries->mapDrilldownSeries(month, weeklySeries);
                     // Drilling down from weekly data brings us back to season data.
-                    foreach (QString week, weeks) {
+                    for (int week=0; week < weeks.count(); week++) {
                         weeklySeries->mapDrilldownSeries(week, seasonSeries);
-                        weeklySeries->setName(QString("Crop by week - " + month));
+                        weeklySeries->setName(QString("Crop by week - " + months.at(month)));
                     }
                     // Use right click signal to implement drilldown
-                    QObject::connect(weeklySeries, SIGNAL(clicked(QBarSet*,QString)), drilldownChart, SLOT(handleClicked(QBarSet*,QString)));
+                    QObject::connect(weeklySeries, SIGNAL(clicked(QBarSet*,int)), drilldownChart, SLOT(handleClicked(QBarSet*,int)));
                 }
                 // Enable drilldown from season series using right click.
-                QObject::connect(seasonSeries, SIGNAL(clicked(QBarSet*,QString)), drilldownChart, SLOT(handleClicked(QBarSet*,QString)));
+                QObject::connect(seasonSeries, SIGNAL(clicked(QBarSet*,int)), drilldownChart, SLOT(handleClicked(QBarSet*,int)));
             //! [4]
             //! [5]
                 // Fill monthly and weekly series with data
                 foreach (QString plant, plants) {
                     QBarSet* monthlyCrop = new QBarSet(plant);
-                    foreach (QString month, months) {
+                    for (int month=0; month<months.count(); month++) {
                         QBarSet* weeklyCrop = new QBarSet(plant);
-                        foreach (QString week, weeks )
+                        for (int week=0; week<weeks.count(); week++) {
                             *weeklyCrop << (qrand() % 20);
+                        }
                         // Get the drilldown series from season series and add crop to it.
                         seasonSeries->drilldownSeries(month)->append(weeklyCrop);
                         *monthlyCrop << weeklyCrop->sum();

src/axis/qaxiscategories.cpp +4 -3

             }
             /*!
-              Inserts bar \a categories.
+              Inserts \a categories to axis. First item in list is assumed to be at x = 0, next at x = 1 and so on
              */
-            void QAxisCategories::insert(const QBarCategories &categories)
+            void QAxisCategories::insert(const QStringList &categories)
             {
-                int i=1;
+                int i=0;
                 foreach (const QString& string , categories) {
                     d_ptr->m_map.insert(i,string);
                     i++;
                 emit d_ptr->updated();
             }
             /*!
               Inserts category, instead of \a value on axis a \a label will be shown.
              */

src/axis/qaxiscategories.h +2 -2

             #define QAXISCATEGORIES_H
             #include <qchartglobal.h>
-            #include <qbarseries.h>
+            #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             public:
                 ~QAxisCategories();
-                void insert(const QBarCategories &category);
+                void insert(const QStringList &category);
                 void insert(qreal value,QString label);
                 void remove(qreal value);
                 QList<qreal> values() const;

src/barchart/bar.cpp +4 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Bar::Bar(QBarSet *barset, QString category, QGraphicsItem *parent) : QGraphicsRectItem(parent),
+            Bar::Bar(QBarSet *barset, int index, QGraphicsItem *parent) : QGraphicsRectItem(parent),
-                m_category(category),
+                m_index(index),
                 m_barset(barset)
             {
-                setAcceptedMouseButtons(Qt::LeftButton /*| Qt::RightButton*/);
+                setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
-                emit clicked(m_barset, m_category);
+                emit clicked(m_barset, m_index);
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

src/barchart/bar_p.h +3 -5

             {
                 Q_OBJECT
             public:
-                Bar(QBarSet *barset, QString category, QGraphicsItem *parent = 0);
+                Bar(QBarSet *barset, int index, QGraphicsItem *parent = 0);
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             Q_SIGNALS:
-                void clicked(QString category);
+                void clicked(QBarSet *barset, int index);
-                void clicked(QBarSet *barset, QString category);
-                void hovered(bool status);
                 void hovered(QBarSet *barset, bool status);
             private:
-                QString m_category;
+                int m_index;
                 QBarSet *m_barset;
             };

src/barchart/barchartitem.cpp +5 -6

                 bool labelsVisible = m_series->isLabelsVisible();
                 // Create new graphic items for bars
-                for (int c = 0; c < m_series->categoryCount(); c++) {
+                for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
-                    QString category = m_series->d_func()->categoryName(c);
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
-                        Bar *bar = new Bar(set,category,this);
+                        Bar *bar = new Bar(set,c,this);
                         m_bars.append(bar);
-                        connect(bar, SIGNAL(clicked(QBarSet*,QString)), m_series, SIGNAL(clicked(QBarSet*,QString)));
+                        connect(bar, SIGNAL(clicked(QBarSet*,int)), m_series, SIGNAL(clicked(QBarSet*,int)));
                         connect(bar, SIGNAL(hovered(QBarSet*,bool)), m_series, SIGNAL(hovered(QBarSet*,bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
             {
                 QVector<QRectF> layout;
-                // Use temporary qreals for accurancy
+                // Use temporary qreals for accuracy
-                qreal categoryCount = m_series->categoryCount();
+                qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 bool barsVisible = m_series->isVisible();

src/barchart/groupedbarchartitem.cpp +2 -2

             {
                 QVector<QRectF> layout;
-                // Use temporary qreals for accurancy
+                // Use temporary qreals for accuracy
-                qreal categoryCount = m_series->categoryCount();
+                qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:

src/barchart/percentbarchartitem.cpp +2 -2

             {
                 QVector<QRectF> layout;
-                // Use temporary qreals for accurancy
+                // Use temporary qreals for accuracy
-                qreal categoryCount = m_series->categoryCount();
+                qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:

src/barchart/qbarmodelmapper.cpp +2 -1

                         posInCategories++;
                         categoriesIndex = categoriesModelIndex(posInCategories);
                     }
-                    m_series->setCategories(categories);
+                    // TODO: set the categories to axis
+            //        m_series->setCategories(categories);
                 }
                 blockSeriesSignals(false);
             }

src/barchart/qbarseries.cpp +6 -35

             */
             /*!
-                \fn void QBarSeries::clicked(QBarSet *barset, QString category)
+                \fn void QBarSeries::clicked(QBarSet *barset, int index)
-                The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
+                The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
-                contained by the series.
+                Clicked bar inside set is indexed by \a index
             */
             /*!
             }
             /*!
-                Sets the \a categories, which are used to to group the data.
-            */
-            void QBarSeries::setCategories(QBarCategories categories)
-                Q_D(QBarSeries);
-                d->setCategories(categories);
-                emit d->categoriesUpdated();
-            /*!
                 Sets the margin around bars. Parameter \a margin is from 0 to 1 and represents
                 percentage of margin compared to bars
             */
             {
                 Q_D(QBarSeries);
                 d->m_barSets.clear();
-                d->m_categories.clear();
             }
             /*!
             }
             /*!
-                Returns number of categories in series
-            */
-            int QBarSeries::categoryCount() const
-                Q_D(const QBarSeries);
-                return d->categoryCount();
-            /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             }
             /*!
-                Returns the bar categories of the series.
-            */
-            QBarCategories QBarSeries::categories() const
-                Q_D(const QBarSeries);
-                return d->categories();
-            /*!
                 Sets the visibility of series to \a visible
             */
             void QBarSeries::setVisible(bool visible)
             {
             }
-            void QBarSeriesPrivate::setCategories(QBarCategories categories)
+            void QBarSeriesPrivate::setCategories(QStringList categories)
             {
                 m_categories = categories;
             }
                 return count;
             }
-            QBarCategories QBarSeriesPrivate::categories() const
+            QStringList QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
-                QBarCategories categories;
+                QStringList categories;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {

src/barchart/qbarseries.h +1 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            typedef QStringList QBarCategories;
             class QBarSet;
-            class BarCategory;
             class QBarSeriesPrivate;
             // Container for series
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
-                void setCategories(QBarCategories categories);
                 void setBarMargin(qreal margin);
                 qreal barMargin() const;
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 int barsetCount() const;
-                int categoryCount() const;
                 QList<QBarSet*> barSets() const;
-                QBarCategories categories() const;
                 void clear();
                 void setVisible(bool visible = true);
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
-                void clicked(QBarSet *barset, QString category);
+                void clicked(QBarSet *barset, int index);
                 void hovered(QBarSet* barset, bool status);
             protected:

src/barchart/qbarseries_p.h +5 -4

                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarSeries *parent);
-                void setCategories(QBarCategories categories);
+                // TODO: refactor/remove private category stuff
+                void setCategories(QStringList categories);
                 void insertCategory(int index, const QString category);
                 void removeCategory(int index);
                 int categoryCount() const;
-                QBarCategories categories() const;
+                QStringList categories() const;
                 void setBarMargin(qreal margin);
                 qreal barMargin() const;
                 qreal maxCategorySum();
             Q_SIGNALS:
-                void clicked(QBarSet *barset, QString category);
+                void clicked(QBarSet *barset, int index);
                 void updatedBars();
                 void restructuredBars();
                 void categoriesUpdated();
             protected:
                 QList<QBarSet *> m_barSets;
-                QBarCategories m_categories;
+                QStringList m_categories;
                 qreal m_barMargin;
                 bool m_labelsVisible;
                 bool m_visible;

src/barchart/qbarset.cpp 0 -14

@@ -38,20 +38,6 QTCOMMERCIALCHART_BEGIN_NAMESPACE
38	*/	38	*/
39		39
40	/*!	40	/*!
41	\fn void QBarSet::clicked(QString category)
42	\brief signals that set has been clicked
43	Parameter \a category describes on which category was clicked
44	*/
45
46	/*!
47	\fn void QBarSet::hovered(bool status)
48	\brief signals that mouse has hovered over the set. If \a status is true, then mouse was entered. If \a status is false, then mouse was left.
49
50	The signal is emitted if mouse is hovered on top of set
51	Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
52	*/
53
54	/*!
55	Constructs QBarSet with a name of \a name and with parent of \a parent	41	Constructs QBarSet with a name of \a name and with parent of \a parent
56	*/	42	*/
57	QBarSet::QBarSet(const QString name, QObject *parent)	43	QBarSet::QBarSet(const QString name, QObject *parent)

src/barchart/qbarset.h 0 -4

                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
-            //Q_SIGNALS:
-            //    void clicked(QString category);
-            //    void hovered(bool status);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)

src/barchart/qbarset_p.h 0 -1

                 ~QBarSetPrivate();
             Q_SIGNALS:
-                void clicked(QString category);
                 void restructuredBars();
                 void updatedBars();

src/barchart/qgroupedbarseries.cpp +1 -2

             void QGroupedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
-                Q_Q(QGroupedBarSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
-                qreal x = q->categoryCount();
+                qreal x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, x) - 0.5;
                 minY = qMin(minY, y);

src/barchart/qpercentbarseries.cpp +1 -2

             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
-                Q_Q(QPercentBarSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
-                qreal x = q->categoryCount();
+                qreal x = categoryCount();
                 minX = qMin(minX, x) - 0.5;
                 maxX = qMax(maxX, x) - 0.5;
                 minY = 0;

src/barchart/qstackedbarseries.cpp +1 -2

             void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
-                Q_Q(QStackedBarSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
-                qreal x = q->categoryCount();
+                qreal x = categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, x) - 0.5;
                 minY = qMin(minY, y);

src/barchart/stackedbarchartitem.cpp +2 -2

             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
-                // Use temporary qreals for accurancy
+                // Use temporary qreals for accuracy
-                qreal categoryCount = m_series->categoryCount();
+                qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:

src/chartdataset.cpp 0 -15

                 series->d_ptr->scaleDomain(*domain);
-                // Note that with SeriesTypeBar we don't set up categories, but use real values on x-asis
-                if(series->type() == QAbstractSeries::SeriesTypeGroupedBar
-                        || series->type() == QAbstractSeries::SeriesTypeStackedBar
-                        || series->type() == QAbstractSeries::SeriesTypePercentBar) {
-                    QBarSeries* barSeries = static_cast<QBarSeries*>(series);
-                    setupCategories(barSeries);
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 qDeleteAll(axes);
             }
-            void ChartDataSet::setupCategories(QBarSeries* series)
-               QAxisCategories* categories = axisX()->categories();
-               categories->clear();
-               categories->insert(series->categories());
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);

src/chartdataset_p.h 0 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxis;
-            class QBarSeries;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
             private:
                 QStringList createLabels(QAxis* axis,qreal min, qreal max);
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
-                void setupCategories(QBarSeries* series);
             private:
                 QMap<QAbstractSeries *, QAxis *> m_seriesAxisMap;

tests/auto/qbarseries/tst_qbarseries.cpp +15 -88

                 void qbarseries();
                 void type_data();
                 void type();
-                void setCategories_data();
-                void setCategories();
                 void append_data();
                 void append();
                 void remove_data();
                 void removeList();
                 void barsetCount_data();
                 void barsetCount();
-                void categoryCount_data();
-                void categoryCount();
                 void barSets_data();
                 void barSets();
-                void categories_data();
-                void categories();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 QList<QBarSet*> m_testSets;
-                QBarCategories m_categories;
             };
             void tst_QBarSeries::initTestCase()
             void tst_QBarSeries::init()
             {
-                m_categories << "category0" << "category1" << "category2";
                 m_barseries = new QBarSeries();
-                m_barseries->setCategories(m_categories);
                 m_barseries_with_sets = new QBarSeries();
-                m_barseries_with_sets->setCategories(m_categories);
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
-                m_categories.clear();
             }
             void tst_QBarSeries::qbarseries_data()
             {
-                QTest::addColumn<QBarCategories> ("categories");
-                QBarCategories c;
-                c << "category0" << "category1" << "category2";
-                QTest::newRow("categories") << c;
             }
             void tst_QBarSeries::qbarseries()
             {
-                QFETCH(QBarCategories, categories);
                 QBarSeries *barseries = new QBarSeries();
                 QVERIFY(barseries != 0);
-                barseries->setCategories(categories);
-                QBarCategories verifyCategories = barseries->categories();
-                QVERIFY(verifyCategories.count() == categories.count());
-                for (int i=0; i<categories.count(); i++) {
-                    QVERIFY(verifyCategories.at(i).compare(categories.at(i)) == 0);
             }
             void tst_QBarSeries::type_data()
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
-            void tst_QBarSeries::setCategories_data()
-                QTest::addColumn<QBarCategories> ("categories");
-                QBarCategories categories;
-                categories << "c1" << "c2" << "c3" << "c4" << "c5" << "c6";
-                QTest::newRow("cat") << categories;
-            void tst_QBarSeries::setCategories()
-                QVERIFY(m_barseries->categories().count() == m_categories.count());
-                QFETCH(QBarCategories, categories);
-                m_barseries->setCategories(categories);
-                QVERIFY(m_barseries->categories().count() == categories.count());
-                for (int i=0; i<categories.count(); i++) {
-                    QVERIFY(m_barseries->categories().at(i).compare(categories.at(i)) == 0);
             void tst_QBarSeries::append_data()
             {
             }
                 QVERIFY(m_barseries_with_sets->barsetCount() == m_testSets.count());
             }
-            void tst_QBarSeries::categoryCount_data()
-            void tst_QBarSeries::categoryCount()
-                QVERIFY(m_barseries->categoryCount() == m_categories.count());
-                QVERIFY(m_barseries_with_sets->categoryCount() == m_categories.count());
             void tst_QBarSeries::barSets_data()
             {
                 }
             }
-            void tst_QBarSeries::categories_data()
-            void tst_QBarSeries::categories()
-                QBarCategories categories = m_barseries->categories();
-                QVERIFY(categories.count() == m_categories.count());
-                for (int i=0; i<m_categories.count(); i++) {
-                    QVERIFY(categories.at(i).compare(m_categories.at(i)) == 0);
             void tst_QBarSeries::setLabelsVisible_data()
             {
             void tst_QBarSeries::mouseclicked()
             {
                 QBarSeries* series = new QBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
                 *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             }
             void tst_QBarSeries::mousehovered_data()
             void tst_QBarSeries::mousehovered()
             {
                 QBarSeries* series = new QBarSeries();
-                QBarCategories categories;
+                QStringList categories;
                 categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
+            //    series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0.1,10) << QPointF(1.1,10) << QPointF(2.1,10);

tests/auto/qchart/tst_qchart.cpp 0 -7

                 QAbstractSeries* series6 = new QPercentBarSeries(this);
                 QAbstractSeries* series7 = new QStackedBarSeries(this);
-                QBarSeries* s5 = static_cast<QBarSeries*> (series5);
-                s5->setCategories(QBarCategories());
-                QPercentBarSeries* s6 = static_cast<QPercentBarSeries*> (series6);
-                s6->setCategories(QBarCategories());
-                QStackedBarSeries* s7 = static_cast<QStackedBarSeries*> (series7);
-                s7->setCategories(QBarCategories());
                 QAxis* axis = new QAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QAxis*) 0;

tests/auto/qgroupedbarseries/tst_qgroupedbarseries.cpp +13 -19

             void tst_QGroupedBarSeries::mouseclicked()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).type() == QVariant::String);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             }
             void tst_QGroupedBarSeries::mousehovered_data()
             void tst_QGroupedBarSeries::mousehovered()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;

tests/auto/qpercentbarseries/tst_qpercentbarseries.cpp +13 -13

             void tst_QPercentBarSeries::mouseclicked()
             {
                 QPercentBarSeries* series = new QPercentBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             }
             void tst_QPercentBarSeries::mousehovered_data()
             void tst_QPercentBarSeries::mousehovered()
             {
                 QPercentBarSeries* series = new QPercentBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;

tests/auto/qstackedbarseries/tst_qstackedbarseries.cpp +13 -13

             void tst_QStackedBarSeries::mouseclicked()
             {
                 QStackedBarSeries* series = new QStackedBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
-                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
+                QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 1, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 1, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             //====================================================================================
             // barset 2, category test1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test1")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 0);
             //====================================================================================
             // barset 2, category test2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test2")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 1);
             //====================================================================================
             // barset 2, category test3
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
-                QVERIFY(seriesSpyArg.at(1).toString().compare(QString("test3")) == 0);
+                QVERIFY(seriesSpyArg.at(1).type() == QVariant::Int);
+                QVERIFY(seriesSpyArg.at(1).toInt() == 2);
             }
             void tst_QStackedBarSeries::mousehovered_data()
             void tst_QStackedBarSeries::mousehovered()
             {
                 QStackedBarSeries* series = new QStackedBarSeries();
-                QBarCategories categories;
-                categories << "test1" << "test2" << "test3";
-                series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;

tests/chartwidgettest/mainwidget.cpp +4 -4

                     QBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
-                        series->setCategories(category);
+                        m_chart->axisX()->categories()->insert(category);
                     } else if (seriesName == "Grouped bar") {
                         series = new QGroupedBarSeries(this);
-                        series->setCategories(category);
+                        m_chart->axisX()->categories()->insert(category);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
-                        series->setCategories(category);
+                        m_chart->axisX()->categories()->insert(category);
                     } else {
                         series = new QPercentBarSeries(this);
-                        series->setCategories(category);
+                        m_chart->axisX()->categories()->insert(category);
                     }
                     for (int j(0); j < data.count(); j++) {

tests/gdpbarchart/widget.cpp +1 -2

                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                         category << selectedCountriesStrings[i];
                     QBarSeries* series0 = new QBarSeries();
-                    series0->setCategories(category);
+                    chartView->chart()->axisX()->categories()->insert(category);
-            //        series0 = new QBarSeries(category);
                     // prepare the selected counries SQL query
                     QString countriesQuery = "country IN (";

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