HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1584:900775017aef

QBarSeries to QAbstractBarSeries

sauimone -

r1584:900775017aef

parent child

Context file:

r1584:900775017aef

Expand all files

plugins/declarative/declarativebarseries.cpp +6 -6

             }
             DeclarativeBarSeries::DeclarativeBarSeries(QDeclarativeItem *parent) :
-                QBarSeries(parent)
+                QAbstractBarSeries(parent)
             {
                 connect(this, SIGNAL(barsetsAdded(QList<QBarSet*>)), this, SLOT(handleAdded(QList<QBarSet*>)));
                 connect(this, SIGNAL(barsetsRemoved(QList<QBarSet*>)), this, SLOT(handleRemoved(QList<QBarSet*>)));
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
-                        QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
+                        QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if (qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
-                if (QBarSeries::insert(insertIndex, barset))
+                if (QAbstractBarSeries::insert(insertIndex, barset))
                     return barset;
                 delete barset;
                 return 0;
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
-                        QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
+                        QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
-                        QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
+                        QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<DeclarativeBarSet *>(child)) {
-                        QBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
+                        QAbstractBarSeries::append(qobject_cast<DeclarativeBarSet *>(child));
                     } else if(qobject_cast<QVBarModelMapper *>(child)) {
                         QVBarModelMapper *mapper = qobject_cast<QVBarModelMapper *>(child);
                         mapper->setSeries(this);

plugins/declarative/declarativebarseries.h +3 -3

                 void handleCountChanged(int index, int count);
             };
-            class DeclarativeBarSeries : public QBarSeries, public QDeclarativeParserStatus
+            class DeclarativeBarSeries : public QAbstractBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_INVOKABLE DeclarativeBarSet *at(int index);
                 Q_INVOKABLE DeclarativeBarSet *append(QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE DeclarativeBarSet *insert(int index, QString label, QVariantList values);
-                Q_INVOKABLE bool remove(QBarSet *barset) { return QBarSeries::remove(barset); }
+                Q_INVOKABLE bool remove(QBarSet *barset) { return QAbstractBarSeries::remove(barset); }
-                Q_INVOKABLE void clear() { return QBarSeries::clear(); }
+                Q_INVOKABLE void clear() { return QAbstractBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();

src/barchart/barchartitem.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            BarChartItem::BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_series(series)
             {

src/barchart/barchartitem_p.h +2 -2

             {
                 Q_OBJECT
             public:
-                BarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             public:
                 QVector<QRectF> m_layout;
                 // Not owned.
-                QBarSeries *m_series;
+                QAbstractBarSeries *m_series;
                 QList<Bar *> m_bars;
                 QList<QGraphicsSimpleTextItem *> m_labels;
             };

src/barchart/groupedbarchartitem.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            GroupedBarChartItem::GroupedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            GroupedBarChartItem::GroupedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }

src/barchart/groupedbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                GroupedBarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                GroupedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/percentbarchartitem.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }

src/barchart/percentbarchartitem_p.h +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QBarSeries;
+            class QAbstractBarSeries;
             class PercentBarChartItem : public BarChartItem
             {
                 Q_OBJECT
             public:
-                PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/barchart/qbarmodelmapper.cpp +2 -2

                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
-            QBarSeries* QBarModelMapper::series() const
+            QAbstractBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
-            void QBarModelMapper::setSeries(QBarSeries *series)
+            void QBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {

src/barchart/qbarmodelmapper.h +3 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapperPrivate;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QBarModelMapper : public QObject
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
-                QBarSeries* series() const;
+                QAbstractBarSeries* series() const;
-                void setSeries(QBarSeries *series);
+                void setSeries(QAbstractBarSeries *series);
                 int first() const;
                 void setFirst(int first);

src/barchart/qbarmodelmapper_p.h +1 -1

                 void blockSeriesSignals(bool block = true);
             private:
-                QBarSeries *m_series;
+                QAbstractBarSeries *m_series;
                 QList<QBarSet*> m_barSets;
                 QAbstractItemModel *m_model;
                 int m_first;

src/barchart/qbarseries.cpp +61 -61

                 Constructs empty QBarSeries.
                 QBarSeries is QObject which is a child of a \a parent.
             */
-            QBarSeries::QBarSeries(QObject *parent) :
+            QAbstractBarSeries::QAbstractBarSeries(QObject *parent) :
-                QAbstractSeries(*new QBarSeriesPrivate(this),parent)
+                QAbstractSeries(*new QAbstractBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
-            QBarSeries::~QBarSeries()
+            QAbstractBarSeries::~QAbstractBarSeries()
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             /*!
                 \internal
             */
-            QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
+            QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
-            QAbstractSeries::SeriesType QBarSeries::type() const
+            QAbstractSeries::SeriesType QAbstractBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
                 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 QGroupedBarSeries \endlink this value means the width of one group of bars instead of just one bar.
             */
-            void QBarSeries::setBarWidth(qreal width)
+            void QAbstractBarSeries::setBarWidth(qreal width)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 d->setBarWidth(width);
             }
                 Returns the width of the bars of the series.
                 \sa setBarWidth()
             */
-            qreal QBarSeries::barWidth() const
+            qreal QAbstractBarSeries::barWidth() const
             {
-                Q_D(const QBarSeries);
+                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 QBarSeries::append(QBarSet *set)
+            bool QAbstractBarSeries::append(QBarSet *set)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBarSet*> sets;
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
-            bool QBarSeries::remove(QBarSet *set)
+            bool QAbstractBarSeries::remove(QBarSet *set)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBarSet*> sets;
                 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 QBarSeries::append(QList<QBarSet* > sets)
+            bool QAbstractBarSeries::append(QList<QBarSet* > sets)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit barsetsAdded(sets);
                 Returns true, if inserting succeeded.
             */
-            bool QBarSeries::insert(int index, QBarSet *set)
+            bool QAbstractBarSeries::insert(int index, QBarSet *set)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBarSet*> sets;
             /*!
                 Removes all of the bar sets from the series
             */
-            void QBarSeries::clear()
+            void QAbstractBarSeries::clear()
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 QList<QBarSet *> sets = barSets();
                 bool success = d->remove(sets);
                 if (success) {
             /*!
                 Returns number of sets in series.
             */
-            int QBarSeries::count() const
+            int QAbstractBarSeries::count() const
             {
-                Q_D(const QBarSeries);
+                Q_D(const QAbstractBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
-            QList<QBarSet*> QBarSeries::barSets() const
+            QList<QBarSet*> QAbstractBarSeries::barSets() const
             {
-                Q_D(const QBarSeries);
+                Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
-            void QBarSeries::setLabelsVisible(bool visible)
+            void QAbstractBarSeries::setLabelsVisible(bool visible)
             {
-                Q_D(QBarSeries);
+                Q_D(QAbstractBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->setLabelsVisible(visible);
                     emit labelsVisibleChanged();
             /*!
                 Returns the visibility of labels
             */
-            bool QBarSeries::isLabelsVisible() const
+            bool QAbstractBarSeries::isLabelsVisible() const
             {
-                Q_D(const QBarSeries);
+                Q_D(const QAbstractBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
+            QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barWidth(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
             {
             }
-            int QBarSeriesPrivate::categoryCount() const
+            int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 return count;
             }
-            void QBarSeriesPrivate::setBarWidth(qreal width)
+            void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 emit updatedBars();
             }
-            qreal QBarSeriesPrivate::barWidth() const
+            qreal QAbstractBarSeriesPrivate::barWidth() const
             {
                 return m_barWidth;
             }
-            QBarSet* QBarSeriesPrivate::barsetAt(int index)
+            QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
-            void QBarSeriesPrivate::setVisible(bool visible)
+            void QAbstractBarSeriesPrivate::setVisible(bool visible)
             {
                 m_visible = visible;
                 emit updatedBars();
             }
-            void QBarSeriesPrivate::setLabelsVisible(bool visible)
+            void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
             {
                 m_labelsVisible = visible;
                 emit labelsVisibleChanged(visible);
             }
-            qreal QBarSeriesPrivate::min()
+            qreal QAbstractBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 return min;
             }
-            qreal QBarSeriesPrivate::max()
+            qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 return max;
             }
-            qreal QBarSeriesPrivate::valueAt(int set, int category)
+            qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                 return m_barSets.at(set)->at(category);
             }
-            qreal QBarSeriesPrivate::percentageAt(int set, int category)
+            qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                 return value / sum;
             }
-            qreal QBarSeriesPrivate::categorySum(int category)
+            qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 return sum;
             }
-            qreal QBarSeriesPrivate::absoluteCategorySum(int category)
+            qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 return sum;
             }
-            qreal QBarSeriesPrivate::maxCategorySum()
+            qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 return max;
             }
-            qreal QBarSeriesPrivate::minX()
+            qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 return min;
             }
-            qreal QBarSeriesPrivate::maxX()
+            qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
             }
-            void QBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
-            Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            Chart* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
             }
-            QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
+            QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                 return markers;
             }
-            QAbstractAxis* QBarSeriesPrivate::createAxisX(QObject* parent)
+            QAbstractAxis* QAbstractBarSeriesPrivate::createAxisX(QObject* parent)
             {
                 return new QCategoriesAxis(parent);
             }
-            QAbstractAxis* QBarSeriesPrivate::createAxisY(QObject* parent)
+            QAbstractAxis* QAbstractBarSeriesPrivate::createAxisY(QObject* parent)
             {
                 return new QValuesAxis(parent);
             }
-            bool QBarSeriesPrivate::append(QBarSet *set)
+            bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 return true;
             }
-            bool QBarSeriesPrivate::remove(QBarSet *set)
+            bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 return true;
             }
-            bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
+            bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
-                Q_Q(QBarSeries);
+                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 true;
             }
-            bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
+            bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 return true;
             }
-            bool QBarSeriesPrivate::insert(int index, QBarSet *set)
+            bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;

src/barchart/qbarseries.h +6 -6

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
-            class QBarSeriesPrivate;
+            class QAbstractBarSeriesPrivate;
             // Container for series
-            class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
+            class QTCOMMERCIALCHART_EXPORT QAbstractBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth)
                 Q_PROPERTY(bool labelsVisible READ isLabelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
             public:
-                explicit QBarSeries(QObject *parent = 0);
+                explicit QAbstractBarSeries(QObject *parent = 0);
-                virtual ~QBarSeries();
+                virtual ~QAbstractBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 bool isLabelsVisible() const;
             protected:
-                explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
+                explicit QAbstractBarSeries(QAbstractBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
-                Q_DECLARE_PRIVATE(QBarSeries)
+                Q_DECLARE_PRIVATE(QAbstractBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;

src/barchart/qbarseries_p.h +3 -3

             class QBarModelMapper;
-            class QBarSeriesPrivate : public QAbstractSeriesPrivate
+            class QAbstractBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
-                QBarSeriesPrivate(QBarSeries *parent);
+                QAbstractBarSeriesPrivate(QAbstractBarSeries *parent);
                 int categoryCount() const;
                 void setBarWidth(qreal width);
                 bool m_visible;
             private:
-                Q_DECLARE_PUBLIC(QBarSeries)
+                Q_DECLARE_PUBLIC(QAbstractBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +1 -1

                 friend class QBarSeries;
                 friend class BarLegendMarker;
                 friend class BarChartItem;
-                friend class QBarSeriesPrivate;
+                friend class QAbstractBarSeriesPrivate;
                 friend class StackedBarChartItem;
                 friend class PercentBarChartItem;
                 friend class GroupedBarChartItem;

src/barchart/qgroupedbarseries.cpp +2 -2

                 QGroupedBarSeries is QObject which is a child of a \a parent.
             */
             QGroupedBarSeries::QGroupedBarSeries(QObject *parent)
-                : QBarSeries(*new QGroupedBarSeriesPrivate(this), parent)
+                : QAbstractBarSeries(*new QGroupedBarSeriesPrivate(this), parent)
             {
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(QGroupedBarSeries *q) : QBarSeriesPrivate(q)
+            QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(QGroupedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }

src/barchart/qgroupedbarseries.h +1 -1

             class QGroupedBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:

src/barchart/qgroupedbarseries_p.h +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QGroupedBarSeriesPrivate: public QBarSeriesPrivate
+            class QGroupedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QGroupedBarSeriesPrivate(QGroupedBarSeries* q);

src/barchart/qhbarmodelmapper.cpp +2 -2

                 }
             }
-            QBarSeries* QHBarModelMapper::series() const
+            QAbstractBarSeries* QHBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
-            void QHBarModelMapper::setSeries(QBarSeries *series)
+            void QHBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);

src/barchart/qhbarmodelmapper.h +3 -3

             class QTCOMMERCIALCHART_EXPORT QHBarModelMapper : public QBarModelMapper
             {
                 Q_OBJECT
-                Q_PROPERTY(QBarSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
+                Q_PROPERTY(QAbstractBarSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
                 Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
                 Q_PROPERTY(int firstBarSetRow READ firstBarSetRow WRITE setFirstBarSetRow NOTIFY firstBarSetRowChanged)
                 Q_PROPERTY(int lastBarSetRow READ lastBarSetRow WRITE setLastBarSetRow NOTIFY lastBarSetRowChanged)
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
-                QBarSeries* series() const;
+                QAbstractBarSeries* series() const;
-                void setSeries(QBarSeries *series);
+                void setSeries(QAbstractBarSeries *series);
                 int firstBarSetRow() const;
                 void setFirstBarSetRow(int firstBarSetRow);

src/barchart/qpercentbarseries.cpp +2 -2

                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QObject *parent)
-                : QBarSeries(*new QPercentBarSeriesPrivate(this), parent)
+                : QAbstractBarSeries(*new QPercentBarSeriesPrivate(this), parent)
             {
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QBarSeriesPrivate(q)
+            QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }

src/barchart/qpercentbarseries.h +1 -1

             class QPercentBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:

src/barchart/qpercentbarseries_p.h +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QPercentBarSeriesPrivate: public QBarSeriesPrivate
+            class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QPercentBarSeriesPrivate(QPercentBarSeries* q);

src/barchart/qstackedbarseries.cpp +2 -2

                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QObject *parent)
-                : QBarSeries(*new QStackedBarSeriesPrivate(this), parent)
+                : QAbstractBarSeries(*new QStackedBarSeriesPrivate(this), parent)
             {
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QBarSeriesPrivate(q)
+            QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }

src/barchart/qstackedbarseries.h +1 -1

             class QStackedBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:

src/barchart/qstackedbarseries_p.h +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QStackedBarSeriesPrivate: public QBarSeriesPrivate
+            class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QStackedBarSeriesPrivate(QStackedBarSeries* q);

src/barchart/qvbarmodelmapper.cpp +2 -2

                 }
             }
-            QBarSeries* QVBarModelMapper::series() const
+            QAbstractBarSeries* QVBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
-            void QVBarModelMapper::setSeries(QBarSeries *series)
+            void QVBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);

src/barchart/qvbarmodelmapper.h +3 -3

             class QTCOMMERCIALCHART_EXPORT QVBarModelMapper : public QBarModelMapper
             {
                 Q_OBJECT
-                Q_PROPERTY(QBarSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
+                Q_PROPERTY(QAbstractBarSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
                 Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
                 Q_PROPERTY(int firstBarSetColumn READ firstBarSetColumn WRITE setFirstBarSetColumn NOTIFY firstBarSetColumnChanged)
                 Q_PROPERTY(int lastBarSetColumn READ lastBarSetColumn WRITE setLastBarSetColumn NOTIFY lastBarSetColumnChanged)
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
-                QBarSeries* series() const;
+                QAbstractBarSeries* series() const;
-                void setSeries(QBarSeries *series);
+                void setSeries(QAbstractBarSeries *series);
                 int firstBarSetColumn() const;
                 void setFirstBarSetColumn(int firstBarSetColumn);

src/barchart/stackedbarchartitem.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }

src/barchart/stackedbarchartitem_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
             private:
                 virtual QVector<QRectF> calculateLayout();

src/charttheme.cpp +1 -1

                 }
             }
-            void ChartTheme::decorate(QBarSeries *series, int index)
+            void ChartTheme::decorate(QAbstractBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;

src/charttheme_p.h +2 -2

             class LineChartItem;
             class QLineSeries;
             class BarChartItem;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class StackedBarChartItem;
             class QStackedBarSeries;
             class QPercentBarSeries;
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart *chart);
                 void decorate(QLegend *legend);
-                void decorate(QBarSeries *series, int index);
+                void decorate(QAbstractBarSeries *series, int index);
                 void decorate(QLineSeries *series, int index);
                 void decorate(QAreaSeries *series, int index);
                 void decorate(QScatterSeries *series, int index);

src/legend/legendmarker.cpp +1 -1

             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
+            BarLegendMarker::BarLegendMarker(QAbstractBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));

src/legend/legendmarker_p.h +2 -2

             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
             class BarLegendMarker : public LegendMarker
             {
             public:
-                BarLegendMarker(QBarSeries *barseries, QBarSet *barset,QLegend *legend);
+                BarLegendMarker(QAbstractBarSeries *barseries, QBarSet *barset,QLegend *legend);
             protected:
                 void updated();
             private:

tests/auto/chartdataset/tst_chartdataset.cpp +2 -2

                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
-                QAbstractSeries* bar = new QBarSeries(this);
+                QAbstractSeries* bar = new QAbstractBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
-                QAbstractSeries* bar = new QBarSeries(this);
+                QAbstractSeries* bar = new QAbstractBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);

tests/auto/qbarseries/tst_qbarseries.cpp +8 -8

                 void clearWithAnimations();
             private:
-                QBarSeries* m_barseries;
+                QAbstractBarSeries* m_barseries;
-                QBarSeries* m_barseries_with_sets;
+                QAbstractBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
             void tst_QBarSeries::init()
             {
-                m_barseries = new QBarSeries();
+                m_barseries = new QAbstractBarSeries();
-                m_barseries_with_sets = new QBarSeries();
+                m_barseries_with_sets = new QAbstractBarSeries();
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
             void tst_QBarSeries::qbarseries()
             {
-                QBarSeries *barseries = new QBarSeries();
+                QAbstractBarSeries *barseries = new QAbstractBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QBarSeries::mouseclicked()
             {
-                QBarSeries* series = new QBarSeries();
+                QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
             void tst_QBarSeries::mousehovered()
             {
-                QBarSeries* series = new QBarSeries();
+                QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
             void tst_QBarSeries::clearWithAnimations()
             {
-                QBarSeries* series = new QBarSeries();
+                QAbstractBarSeries* series = new QAbstractBarSeries();
                 QBarSet* set1 = new QBarSet(QString("set 1"));
             //    *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);

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

                 QAbstractSeries* series2 = new QScatterSeries(this);
                 QAbstractSeries* series3 = new QSplineSeries(this);
                 QAbstractSeries* series4 = new QPieSeries(this);
-                QAbstractSeries* series5 = new QBarSeries(this);
+                QAbstractSeries* series5 = new QAbstractBarSeries(this);
                 QAbstractSeries* series6 = new QPercentBarSeries(this);
                 QAbstractSeries* series7 = new QStackedBarSeries(this);

tests/chartwidgettest/mainwidget.cpp +2 -2

                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
-                    QBarSeries* series = 0;
+                    QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
-                        series = new QBarSeries(this);
+                        series = new QAbstractBarSeries(this);
                         QCategoriesAxis* axis = new QCategoriesAxis();
                         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