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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativebarseries.h"
             #include "declarativechart.h"
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QHBarModelMapper>
             #include <QAbstractAxis>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeBarSet::DeclarativeBarSet(QObject *parent) :
                 QBarSet("", parent)
             {
                 connect(this, SIGNAL(valuesAdded(int,int)), this, SLOT(handleCountChanged(int, int)));
                 connect(this, SIGNAL(valuesRemoved(int,int)), this, SLOT(handleCountChanged(int, int)));
             }
             void DeclarativeBarSet::handleCountChanged(int index, int count)
             {
                 Q_UNUSED(index)
                 Q_UNUSED(count)
                 emit countChanged(QBarSet::count());
             }
             QVariantList DeclarativeBarSet::values()
             {
                 QVariantList values;
                 for (int i(0); i < count(); i++)
                     values.append(QVariant(QBarSet::at(i)));
                 return values;
             }
             void DeclarativeBarSet::setValues(QVariantList values)
             {
                 while (count())
                     remove(count() - 1);
                 for (int i(0); i < values.count(); i++) {
                     if (values.at(i).canConvert(QVariant::Double))
                         QBarSet::append(values[i].toDouble());
                 }
             }
             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*>)));
             }
             void DeclarativeBarSeries::handleAdded(QList<QBarSet* > barsets)
             {
                 foreach(QBarSet *b, barsets) {
                     DeclarativeBarSet *barset = qobject_cast<DeclarativeBarSet *>(b);
                     emit added(barset);
                 }
             }
             void DeclarativeBarSeries::handleRemoved(QList<QBarSet* > barsets)
             {
                 foreach(QBarSet *b, barsets) {
                     DeclarativeBarSet *barset = qobject_cast<DeclarativeBarSet *>(b);
                     emit removed(barset);
                 }
             }
             void DeclarativeBarSeries::classBegin()
             {
             }
             void DeclarativeBarSeries::componentComplete()
             {
                 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);
                     } else if (qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             void DeclarativeBarSeries::setAxisX(QAbstractAxis *axis)
             {
                 chart()->setAxisX(axis, this);
             }
             QAbstractAxis *DeclarativeBarSeries::axisX()
             {
                 return chart()->axisX(this);
             }
             void DeclarativeBarSeries::setAxisY(QAbstractAxis *axis)
             {
                 chart()->setAxisY(axis, this);
             }
             QAbstractAxis *DeclarativeBarSeries::axisY()
             {
                 return chart()->axisY(this);
             }
             QDeclarativeListProperty<QObject> DeclarativeBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeBarSeries::insert(int index, QString label, QVariantList values)
             {
                 int insertIndex = index;
                 if (insertIndex < 0)
                     insertIndex = 0;
                 else if (insertIndex > count())
                     insertIndex = count();
                 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;
             }
             DeclarativeGroupedBarSeries::DeclarativeGroupedBarSeries(QDeclarativeItem *parent) :
                 QGroupedBarSeries(parent)
             {
             }
             void DeclarativeGroupedBarSeries::classBegin()
             {
             }
             void DeclarativeGroupedBarSeries::componentComplete()
             {
                 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);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             void DeclarativeGroupedBarSeries::setAxisX(QAbstractAxis *axis)
             {
                 chart()->setAxisX(axis, this);
             }
             QAbstractAxis *DeclarativeGroupedBarSeries::axisX()
             {
                 return chart()->axisX(this);
             }
             void DeclarativeGroupedBarSeries::setAxisY(QAbstractAxis *axis)
             {
                 chart()->setAxisY(axis, this);
             }
             QAbstractAxis *DeclarativeGroupedBarSeries::axisY()
             {
                 return chart()->axisY(this);
             }
             QDeclarativeListProperty<QObject> DeclarativeGroupedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeGroupedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeGroupedBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeGroupedBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QGroupedBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             DeclarativeStackedBarSeries::DeclarativeStackedBarSeries(QDeclarativeItem *parent) :
                 QStackedBarSeries(parent)
             {
             }
             void DeclarativeStackedBarSeries::classBegin()
             {
             }
             void DeclarativeStackedBarSeries::componentComplete()
             {
                 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);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             void DeclarativeStackedBarSeries::setAxisX(QAbstractAxis *axis)
             {
                 chart()->setAxisX(axis, this);
             }
             QAbstractAxis *DeclarativeStackedBarSeries::axisX()
             {
                 return chart()->axisX(this);
             }
             void DeclarativeStackedBarSeries::setAxisY(QAbstractAxis *axis)
             {
                 chart()->setAxisY(axis, this);
             }
             QAbstractAxis *DeclarativeStackedBarSeries::axisY()
             {
                 return chart()->axisY(this);
             }
             QDeclarativeListProperty<QObject> DeclarativeStackedBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativeStackedBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativeStackedBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativeStackedBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QStackedBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             DeclarativePercentBarSeries::DeclarativePercentBarSeries(QDeclarativeItem *parent) :
                 QPercentBarSeries(parent)
             {
             }
             void DeclarativePercentBarSeries::classBegin()
             {
             }
             void DeclarativePercentBarSeries::componentComplete()
             {
                 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);
                     } else if(qobject_cast<QHBarModelMapper *>(child)) {
                         QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child);
                         mapper->setSeries(this);
                     }
                 }
             }
             void DeclarativePercentBarSeries::setAxisX(QAbstractAxis *axis)
             {
                 chart()->setAxisX(axis, this);
             }
             QAbstractAxis *DeclarativePercentBarSeries::axisX()
             {
                 return chart()->axisX(this);
             }
             void DeclarativePercentBarSeries::setAxisY(QAbstractAxis *axis)
             {
                 chart()->setAxisY(axis, this);
             }
             QAbstractAxis *DeclarativePercentBarSeries::axisY()
             {
                 return chart()->axisY(this);
             }
             QDeclarativeListProperty<QObject> DeclarativePercentBarSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBarSeries::appendSeriesChildren);
             }
             void DeclarativePercentBarSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBarSet *DeclarativePercentBarSeries::at(int index)
             {
                 QList<QBarSet*> setList = barSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBarSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBarSet *DeclarativePercentBarSeries::insert(int index, QString label, QVariantList values)
             {
                 DeclarativeBarSet *barset = new DeclarativeBarSet(this);
                 barset->setLabel(label);
                 barset->setValues(values);
                 if (QPercentBarSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
             #include "moc_declarativebarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativebarseries.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEBARSERIES_H
             #define DECLARATIVEBARSERIES_H
             #include "qchartglobal.h"
             #include "qgroupedbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qabstractaxis.h"
             #include <QDeclarativeItem>
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class DeclarativeBarSet : public QBarSet
             {
                 Q_OBJECT
                 Q_PROPERTY(QVariantList values READ values WRITE setValues)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
             public:
                 explicit DeclarativeBarSet(QObject *parent = 0);
                 QVariantList values();
                 void setValues(QVariantList values);
             public: // From QBarSet
                 Q_INVOKABLE void append(qreal value) { QBarSet::append(value); }
                 Q_INVOKABLE void remove(const int index, const int count = 1) { QBarSet::remove(index, count); }
                 Q_INVOKABLE void replace(int index, qreal value) { QBarSet::replace(index, value); }
                 Q_INVOKABLE qreal at(int index) { return QBarSet::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
             private Q_SLOTS:
                 void handleCountChanged(int index, int count);
             };
-            class DeclarativeBarSeries : public QBarSeries, public QDeclarativeParserStatus
+            class DeclarativeBarSeries : public QAbstractBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeBarSeries(QDeclarativeItem *parent = 0);
                 void setAxisX(QAbstractAxis *axis);
                 QAbstractAxis *axisX();
                 void setAxisY(QAbstractAxis *axis);
                 QAbstractAxis *axisY();
                 QDeclarativeListProperty<QObject> seriesChildren();
                 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();
                 void componentComplete();
             Q_SIGNALS:
                 void added(DeclarativeBarSet *barset);
                 void removed(DeclarativeBarSet *barset);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
                 void handleAdded(QList<QBarSet* > barsets);
                 void handleRemoved(QList<QBarSet* > barsets);
             };
             class DeclarativeGroupedBarSeries : public QGroupedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeGroupedBarSeries(QDeclarativeItem *parent = 0);
                 void setAxisX(QAbstractAxis *axis);
                 QAbstractAxis *axisX();
                 void setAxisY(QAbstractAxis *axis);
                 QAbstractAxis *axisY();
                 QDeclarativeListProperty<QObject> seriesChildren();
                 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 QGroupedBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QGroupedBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             class DeclarativeStackedBarSeries : public QStackedBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeStackedBarSeries(QDeclarativeItem *parent = 0);
                 void setAxisX(QAbstractAxis *axis);
                 QAbstractAxis *axisX();
                 void setAxisY(QAbstractAxis *axis);
                 QAbstractAxis *axisY();
                 QDeclarativeListProperty<QObject> seriesChildren();
                 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 QStackedBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QStackedBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             class DeclarativePercentBarSeries : public QPercentBarSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativePercentBarSeries(QDeclarativeItem *parent = 0);
                 void setAxisX(QAbstractAxis *axis);
                 QAbstractAxis *axisX();
                 void setAxisY(QAbstractAxis *axis);
                 QAbstractAxis *axisY();
                 QDeclarativeListProperty<QObject> seriesChildren();
                 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 QPercentBarSeries::remove(barset); }
                 Q_INVOKABLE void clear() { return QPercentBarSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEBARSERIES_H

src/barchart/barchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            BarChartItem::BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                 }
             }
             //handlers
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void BarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsSimpleTextItem* label, m_labels) {
                     label->setVisible(visible);
                 }
                 update();
             }
             void BarChartItem::handleDataStructureChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 bool labelsVisible = m_series->isLabelsVisible();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set,c,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), m_series, SIGNAL(clicked(int, QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), m_series, SIGNAL(hovered(bool, QBarSet*)));
                         connect(bar, SIGNAL(clicked(int, QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool, QBarSet*)), set, SIGNAL(hovered(bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                         // Labels
                         QGraphicsSimpleTextItem *label = new QGraphicsSimpleTextItem(this);
                         label->setVisible(labelsVisible);
                         m_labels.append(label);
                     }
                 }
                 // TODO: Is this the right place to call it?
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 handleLayoutChanged();
             }
             void BarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 handleLabelsVisibleChanged(visible);
                 foreach(QGraphicsItem *item, childItems()) {
                     item->setVisible(visible);
                 }
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class QAxisCategories;
             class QChart;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
-                BarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                BarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             public:
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual QVector<QRectF> calculateLayout();
                 virtual void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 void handleLabelsVisibleChanged(bool visible);
                 void handleDataStructureChanged();     // structure of of series has changed, recreate graphic items
                 void handleVisibleChanged();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 QVector<QRectF> m_layout;
                 // Not owned.
-                QBarSeries *m_series;
+                QAbstractBarSeries *m_series;
                 QList<Bar *> m_bars;
                 QList<QGraphicsSimpleTextItem *> m_labels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/groupedbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "groupedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            GroupedBarChartItem::GroupedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            GroupedBarChartItem::GroupedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> GroupedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = (scaleX / setCount) * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left();
                         xPos -= setCount*barWidth/2;
                         xPos += set*barWidth;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                     }
                 }
                 return layout;
             }
             #include "moc_groupedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/groupedbarchartitem_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef GROUPEDBARCHARTITEM_H
             #define GROUPEDBARCHARTITEM_H
             #include "barchartitem_p.h"
             #include "qstackedbarseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class GroupedBarChartItem : public BarChartItem
             {
                 Q_OBJECT
             public:
-                GroupedBarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                GroupedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
             private:
                 virtual QVector<QRectF> calculateLayout();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // GROUPEDBARCHARTITEM_H

src/barchart/percentbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "chartanimator_p.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            PercentBarChartItem::PercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->d_func()->categorySum(category);
                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * percentage * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set,category))) {
                             int p = m_series->d_func()->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             label->setText(vString);
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             void PercentBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartitem_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PERCENTBARCHARTITEM_H
             #define PERCENTBARCHARTITEM_H
             #include "barchartitem_p.h"
             #include <QGraphicsItem>
             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();
                 virtual void applyLayout(const QVector<QRectF> &layout);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARCHARTITEM_H

src/barchart/qbarmodelmapper.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "qchart.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 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) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(barsetsAdded(QList<QBarSet*>)), d, SLOT(barSetsAdded(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(barsetsRemoved(QList<QBarSet*>)), d, SLOT(barSetsRemoved(QList<QBarSet*>)));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row of the model contains the \a first values of the QBarSets in the series.
                 The default value is 0.
             */
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the number of rows/columns of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             /*!
                 Sets the \a count of rows/columns of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = qMax(-1, firstBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = qMax(-1, lastBarSetSection);
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         //            if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                         return m_series->barSets().at(index.column() - m_firstBarSetSection);
                         //            else
                         //                return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSetSection || barSection > m_lastBarSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet* bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
                             QBarSet* bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
                                 bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->barSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for(int i = 0; i < sets.count(); i++)
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBarSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBarSetSection, sets.count());
                 for(int i = firstIndex + m_firstBarSetSection; i < firstIndex + m_firstBarSetSection + sets.count(); i++) {
                     m_model->setHeaderData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, sets.at(i - firstIndex - m_firstBarSetSection)->label());
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBarSetSection)->count(); j++)
                         m_model->setData(barModelIndex(i, j), sets.at(i - firstIndex - m_firstBarSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_barSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBarSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_barSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBarSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesAdded(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += count;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(index + m_first, count);
                 else
                     m_model->insertColumns(index + m_first, count);
                 for (int j = index; j < index + count; j++)
                     m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, j), m_barSets.at(barSetIndex)->at(j));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesRemoved(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= count;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(index + m_first, count);
                 else
                     m_model->removeColumns(index + m_first, count);
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setHeaderData(barSetIndex + m_firstBarSetSection, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, m_barSets.at(barSetIndex)->label());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, index), m_barSets.at(barSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_barSets.clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     // check if there is such model index
                     if (barIndex.isValid()) {
                         QBarSet *barSet = new QBarSet(m_model->headerData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical).toString());
                         while (barIndex.isValid()) {
                             barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             barIndex = barModelIndex(i, posInBar);
                         }
                         connect(barSet, SIGNAL(valuesAdded(int, int)), this, SLOT(valuesAdded(int, int)));
                         connect(barSet, SIGNAL(valuesRemoved(int, int)), this, SLOT(valuesRemoved(int, int)));
                         connect(barSet, SIGNAL(valueChanged(int)), this, SLOT(barValueChanged(int)));
                         connect(barSet, SIGNAL(labelChanged()), this, SLOT(barLabelChanged()));
                         m_series->append(barSet);
                         m_barSets.append(barSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarmodelmapper.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARMODELMAPPER_H
             #define QBARMODELMAPPER_H
             #include "qchartglobal.h"
             #include <QObject>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapperPrivate;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QBarModelMapper : public QObject
             {
                 Q_OBJECT
             protected:
                 explicit QBarModelMapper(QObject *parent = 0);
                 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);
                 int count() const;
                 void setCount(int count);
                 int firstBarSetSection() const;
                 void setFirstBarSetSection(int firstBarSetSection);
                 int lastBarSetSection() const;
                 void setLastBarSetSection(int lastBarSetSection);
                 Qt::Orientation orientation() const;
                 void setOrientation(Qt::Orientation orientation);
             protected:
                 QBarModelMapperPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_H

src/barchart/qbarmodelmapper_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARMODELMAPPER_P_H
             #define QBARMODELMAPPER_P_H
             #include "qchartglobal.h"
             #include <QObject>
             #include "qbarmodelmapper.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QBarModelMapperPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QBarModelMapperPrivate(QBarModelMapper *q);
             public Q_SLOTS:
                 // for the model
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last);
                 void modelRowsAdded(QModelIndex parent, int start, int end);
                 void modelRowsRemoved(QModelIndex parent, int start, int end);
                 void modelColumnsAdded(QModelIndex parent, int start, int end);
                 void modelColumnsRemoved(QModelIndex parent, int start, int end);
                 // for the series
                 void barSetsAdded(QList<QBarSet*> sets);
                 void barSetsRemoved(QList<QBarSet*> sets);
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void barLabelChanged();
                 void barValueChanged(int index);
                 void initializeBarFromModel();
             private:
                 QBarSet* barSet(QModelIndex index);
                 QModelIndex barModelIndex(int barSection, int posInBar);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
                 void blockModelSignals(bool block = true);
                 void blockSeriesSignals(bool block = true);
             private:
-                QBarSeries *m_series;
+                QAbstractBarSeries *m_series;
                 QList<QBarSet*> m_barSets;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;
                 Qt::Orientation m_orientation;
                 int m_firstBarSetSection;
                 int m_lastBarSetSection;
                 bool m_seriesSignalsBlock;
                 bool m_modelSignalsBlock;
             private:
                 QBarModelMapper *q_ptr;
                 Q_DECLARE_PUBLIC(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_P_H

src/barchart/qbarseries.cpp +61 -61

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qvaluesaxis.h"
             #include "qcategoriesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief Series for creating a bar chart
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \qmlclass BarSeries QBarSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                 \beginfloatleft
                 \image demos_qmlchart6.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QBarSeries::barWidth
                 The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
                 \sa QGroupedBarSeries
             */
             /*!
                 \qmlproperty real BarSeries::barWidth
                 The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with QGroupedBarSeries this value means the width of one group of bars instead of just one bar.
             */
             /*!
                 \property QBarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \qmlproperty int BarSeries::count
                 Holds the number of sets in series.
             */
             /*!
                 \property QBarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \qmlproperty bool BarSeries::labelsVisible
                 Defines the visibility of the labels in series
             */
             /*!
                 \fn void QBarSeries::clicked(int index, QBarSet *barset)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \qmlsignal BarSeries::onClicked(int index, BarSet barset)
                 The signal is emitted if the user clicks with a mouse on top of BarSet.
                 Clicked bar inside set is indexed by \a index
             */
             /*!
                 \fn void QBarSeries::hovered(bool status, QBarSet* barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \qmlsignal BarSeries::onHovered(bool status, BarSet barset)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 \fn void QBarSeries::countChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \qmlsignal BarSeries::onCountChanged()
                 This signal is emitted when barset count has been changed, for example by append or remove.
             */
             /*!
                 \fn void QBarSeries::labelsVisibleChanged()
                 This signal is emitted when labels visibility have changed.
                 \sa isLabelsVisible(), setLabelsVisible()
             */
             /*!
                 \fn void QBarSeries::barsetsAdded(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal BarSeries::onAdded(BarSet barset)
                 Emitted when \a barset has been added to the series.
             */
             /*!
                 \fn void QBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                 This signal is emitted when \a sets have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal BarSeries::onRemoved(BarSet barset)
                 Emitted when \a barset has been removed from the series.
             */
             /*!
                 \qmlmethod BarSet BarSeries::at(int index)
                 Returns bar set at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod BarSet BarSeries::append(string label, VariantList values)
                 Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 For example:
                 \code
                     myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                     myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                 \endcode
             */
             /*!
                 \qmlmethod BarSet BarSeries::insert(int index, string label, VariantList values)
                 Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                 If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                 appended.
                 \sa BarSeries::append()
             */
             /*!
                 \qmlmethod bool BarSeries::remove(BarSet barset)
                 Removes the barset from the series. Returns true if successfull, false otherwise.
             */
             /*!
                 \qmlmethod BarSeries::clear()
                 Removes all barsets from the series.
             */
             /*!
                 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;
             }
             /*!
                 Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                 is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                 is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                 Note that with \link 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;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
-            bool 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;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
-            bool 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);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
-            bool 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;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 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) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 }
             }
             /*!
                 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),
                 m_visible(true)
             {
             }
-            int QBarSeriesPrivate::categoryCount() const
+            int QAbstractBarSeriesPrivate::categoryCount() const
             {
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
-            void QBarSeriesPrivate::setBarWidth(qreal width)
+            void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
                 if (width < 0.0) {
                     width = 0.0;
                 }
                 m_barWidth = width;
                 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;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
-            qreal QBarSeriesPrivate::max()
+            qreal QAbstractBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
-            qreal 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 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category);
             }
-            qreal 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 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
-            qreal QBarSeriesPrivate::categorySum(int category)
+            qreal QAbstractBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
-            qreal QBarSeriesPrivate::absoluteCategorySum(int category)
+            qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
-            qreal QBarSeriesPrivate::maxCategorySum()
+            qreal QAbstractBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
-            qreal QBarSeriesPrivate::minX()
+            qreal QAbstractBarSeriesPrivate::minX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
-            qreal QBarSeriesPrivate::maxX()
+            qreal QAbstractBarSeriesPrivate::maxX()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
-            void QBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal seriesMinX = this->minX();
                 qreal seriesMaxX = this->maxX();
                 qreal y = max();
                 minX = qMin(minX, seriesMinX - 0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, seriesMaxX + 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = categoryCount()+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
-            Chart* 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)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
-            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);
                     markers << marker;
                 }
                 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;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
-            bool 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;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
-            bool 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 false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
-            bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
+            bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
-                Q_Q(QBarSeries);
+                Q_Q(QAbstractBarSeries);
                 if (sets.count() == 0) {
                     return false;
                 }
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (!m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is not in series
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
-            bool 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;
                 }
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                 emit restructuredBars();      // this notifies barchartitem
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 return true;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +6 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             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(int count READ count NOTIFY countChanged)
                 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;
                 void setBarWidth(qreal width);
                 qreal barWidth() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
                 QList<QBarSet*> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 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 hovered(bool status, QBarSet *barset);
                 void countChanged();
                 void labelsVisibleChanged();
                 void barsetsAdded(QList<QBarSet*> sets);
                 void barsetsRemoved(QList<QBarSet*> sets);
             protected:
-                Q_DECLARE_PRIVATE(QBarSeries)
+                Q_DECLARE_PRIVATE(QAbstractBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarseries_p.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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);
                 qreal barWidth() const;
                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 QAbstractAxis* createAxisX(QObject* parent = 0);
                 QAbstractAxis* createAxisY(QObject* parent = 0);
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 bool insert(int index, QBarSet *set);
                 QBarSet* barsetAt(int index);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
                 qreal minX();
                 qreal maxX();
             Q_SIGNALS:
                 void clicked(int index, QBarSet *barset);
                 void updatedBars();
                 void restructuredBars();
                 void labelsVisibleChanged(bool visible);
             protected:
                 QList<QBarSet *> m_barSets;
                 qreal m_barWidth;
                 bool m_labelsVisible;
                 bool m_visible;
             private:
-                Q_DECLARE_PUBLIC(QBarSeries)
+                Q_DECLARE_PUBLIC(QAbstractBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/barchart/qbarset.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush NOTIFY labelBrushChanged)
                 Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
             public:
                 explicit QBarSet(const QString label, QObject *parent = 0);
                 virtual ~QBarSet();
                 void setLabel(const QString label);
                 QString label() const;
                 void append(const qreal value);
                 void append(const QList<qreal> &values);
                 QBarSet& operator << (const qreal &value);
                 void insert(const int index, const qreal value);
                 void remove(const int index, const int count = 1);
                 void replace(const int index, const qreal value);
                 qreal at(const int index) const;
                 qreal operator [] (const int index) const;
                 int count() const;
                 qreal sum() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 QColor color();
                 void setColor(QColor color);
                 QColor borderColor();
                 void setBorderColor(QColor color);
                 QColor labelColor();
                 void setLabelColor(QColor color);
             Q_SIGNALS:
                 void clicked(int index);
                 void hovered(bool status);
                 void penChanged();
                 void brushChanged();
                 void labelChanged();
                 void labelBrushChanged();
                 void labelFontChanged();
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void labelColorChanged(QColor color);
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void valueChanged(int index);
             private:
                 QScopedPointer<QBarSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBarSet)
                 friend class QBarSeries;
                 friend class BarLegendMarker;
                 friend class BarChartItem;
-                friend class QBarSeriesPrivate;
+                friend class QAbstractBarSeriesPrivate;
                 friend class StackedBarChartItem;
                 friend class PercentBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/qgroupedbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qgroupedbarseries.h"
             #include "qgroupedbarseries_p.h"
             #include "groupedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QGroupedBarSeries
                 \brief Series for creating grouped bar chart
                 \mainclass
                 QGroupedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as groups, where bars in same category are grouped next to each other. QGroupedBarSeries groups the data
                 from sets to categories, which are defined by a QStringList.
                 See the \l {GroupedbarChart Example} {grouped bar chart example} to learn how to create a grouped bar chart.
                 \image examples_groupedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QBarSeries, QStackedBarSeries
             */
             /*!
                 \qmlclass GroupedBarSeries QGroupedBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple grouped bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QGroupedBarSeries.
                 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)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeGroupedBar.
             */
             QAbstractSeries::SeriesType QGroupedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeGroupedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(QGroupedBarSeries *q) : QBarSeriesPrivate(q)
+            QGroupedBarSeriesPrivate::QGroupedBarSeriesPrivate(QGroupedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QGroupedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, -0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QGroupedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QGroupedBarSeries);
                 GroupedBarChartItem* bar = new GroupedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qgroupedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qgroupedbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef GROUPEDBARSERIES_H
             #define GROUPEDBARSERIES_H
             #include <QStringList>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QGroupedBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QGroupedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QGroupedBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QGroupedBarSeries)
                 Q_DISABLE_COPY(QGroupedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // GROUPEDBARSERIES_H

src/barchart/qgroupedbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QGROUPEDBARSERIES_P_H
             #define QGROUPEDBARSERIES_P_H
             #include "qbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QGroupedBarSeriesPrivate: public QBarSeriesPrivate
+            class QGroupedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QGroupedBarSeriesPrivate(QGroupedBarSeries* q);
                 Chart* createGraphics(ChartPresenter* presenter);
                 void scaleDomain(Domain& domain);
             private:
                 Q_DECLARE_PUBLIC(QGroupedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QGROUPEDBARSERIES_P_H

src/barchart/qhbarmodelmapper.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
                 \brief Horizontal model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Horizontal model mapper is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass HBarModelMapper QHBarModelMapper
                 HBarModelMapper allows you to use your own QAbstractItemModel derived model with data in rows as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 HBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the model has
                 at least four rows). Each bar set would contain data starting from column 1. The name of a set would be defined by
                 the vertical header (of the row).
                 \code
                     BarSeries {
                         HBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetRow: 1
                             lastBarSetRow: 3
                             firstColumn: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QHBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty BarSeries HBarModelMapper::series
                 Defines the BarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QHBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel HBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. NOTE: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QHBarModelMapper::firstBarSetRow
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstBarSetRow
                 Defines which column of the model is used as the data source for the first bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::lastBarSetRow
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int HBarModelMapper::lastBarSetRow
                 Defines which column of the model is used as the data source for the last bar set. The default value is -1
                 (invalid mapping).
             */
             /*!
                 \property QHBarModelMapper::firstColumn
                 \brief Defines which column of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int HBarModelMapper::firstColumn
                 Defines which column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QHBarModelMapper::columnCount
                 \brief Defines the number of columns of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of columns in the model)
             */
             /*!
                 \qmlproperty int HBarModelMapper::columnCount
                 Defines the number of columns of the model that are mapped as the data for QBarSeries. The default value is
                 -1 (count limited by the number of columns in the model)
             */
             /*!
                 \fn void QHBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstBarSetRowChanged()
                 Emitted when the firstBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::lastBarSetRowChanged()
                 Emitted when the lastBarSetRow has changed.
             */
             /*!
                 \fn void QHBarModelMapper::firstColumnChanged()
                 Emitted when the firstColumn has changed.
             */
             /*!
                 \fn void QHBarModelMapper::columnCountChanged()
                 Emitted when the columnCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             QAbstractItemModel* QHBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QHBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
-            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);
                     emit seriesReplaced();
                 }
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 if (firstBarSetRow != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
                     emit firstBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 if (lastBarSetRow != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetRow);
                     emit lastBarSetRowChanged();
                 }
             }
             int QHBarModelMapper::firstColumn() const
             {
                 return QBarModelMapper::first();
             }
             void QHBarModelMapper::setFirstColumn(int firstColumn)
             {
                 if (firstColumn != first()) {
                     QBarModelMapper::setFirst(firstColumn);
                     emit firstColumnChanged();
                 }
             }
             int QHBarModelMapper::columnCount() const
             {
                 return QBarModelMapper::count();
             }
             void QHBarModelMapper::setColumnCount(int columnCount)
             {
                 if (columnCount != count()) {
                     QBarModelMapper::setCount(columnCount);
                     emit firstColumnChanged();
                 }
             }
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qhbarmodelmapper.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QHBARMODELMAPPER_H
             #define QHBARMODELMAPPER_H
             #include <QBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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)
                 Q_PROPERTY(int firstColumn READ firstColumn WRITE setFirstColumn NOTIFY firstColumnChanged)
                 Q_PROPERTY(int columnCount READ columnCount WRITE setColumnCount NOTIFY columnCountChanged)
             public:
                 explicit QHBarModelMapper(QObject *parent = 0);
                 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);
                 int lastBarSetRow() const;
                 void setLastBarSetRow(int lastBarSetRow);
                 int firstColumn() const;
                 void setFirstColumn(int firstColumn);
                 int columnCount() const;
                 void setColumnCount(int columnCount);
             Q_SIGNALS:
                 void seriesReplaced();
                 void modelReplaced();
                 void firstBarSetRowChanged();
                 void lastBarSetRowChanged();
                 void firstColumnChanged();
                 void columnCountChanged();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHBARMODELMAPPER_H

src/barchart/qpercentbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief Series for creating percent bar chart
                 \mainclass
                 QPercentBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where each bar is shown as percentage of all bars in that category.
                 QPercentBarSeries groups the data from sets to categories, which are defined by a QStringList.
                 See the \l {PercentbarChart Example} {percent bar chart example} to learn how to create a percent bar chart.
                 \image examples_percentbarchart.png
                 \sa QBarSet, QStackedBarSeries, QBarSeries
             */
             /*!
                 \qmlclass PercentBarSeries QPercentBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple percent bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View9.qml 1
                 \beginfloatleft
                 \image demos_qmlchart9.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QPercentBarSeries.
                 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)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
             */
             QAbstractSeries::SeriesType QPercentBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QBarSeriesPrivate(q)
+            QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QPercentBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 minX = qMin(minX, -0.5);
                 maxX = qMax(maxX, x - 0.5);
                 minY = 0;
                 maxY = 100;
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem* bar = new PercentBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qpercentbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PERCENTBARSERIES_H
             #define PERCENTBARSERIES_H
             #include <QStringList>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPercentBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QPercentBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QPercentBarSeries)
                 Q_DISABLE_COPY(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qpercentbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QPERCENTBARSERIES_P_H
             #define QPERCENTBARSERIES_P_H
             #include "qbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QPercentBarSeriesPrivate: public QBarSeriesPrivate
+            class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QPercentBarSeriesPrivate(QPercentBarSeries* q);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
             private:
                 Q_DECLARE_PUBLIC(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qstackedbarseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qcategoriesaxis.h"
             #include "qvaluesaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QStackedBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {StackedbarChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_stackedbarchart.png
                 \sa QBarSet, QPercentBarSeries, QBarSeries
             */
             /*!
                 \qmlclass StackedBarSeries QStackedBarSeries
                 \inherits BarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View8.qml 1
                 \beginfloatleft
                 \image demos_qmlchart8.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QStackedBarSeries.
                 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)
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
             QAbstractSeries::SeriesType QStackedBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QBarSeriesPrivate(q)
+            QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QStackedBarSeries *q) : QAbstractBarSeriesPrivate(q)
             {
             }
             void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, -0.5);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x - 0.5);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem* bar = new StackedBarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qstackedbarseries.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef STACKEDBARSERIES_H
             #define STACKEDBARSERIES_H
             #include <QStringList>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QStackedBarSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QBarSeries
+            class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QAbstractBarSeries
             {
                 Q_OBJECT
             public:
                 explicit QStackedBarSeries(QObject *parent = 0);
                 QAbstractSeries::SeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QStackedBarSeries)
                 Q_DISABLE_COPY(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARSERIES_H

src/barchart/qstackedbarseries_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QSTACKEDBARSERIES_P_H
             #define QSTACKEDBARSERIES_P_H
             #include "qbarseries_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QStackedBarSeriesPrivate: public QBarSeriesPrivate
+            class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
                 QStackedBarSeriesPrivate(QStackedBarSeries* q);
                 Chart* createGraphics(ChartPresenter* presenter);
                 void scaleDomain(Domain& domain);
             private:
                 Q_DECLARE_PUBLIC(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qvbarmodelmapper.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \brief Vertical model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VBarModelMapper
                 \mainclass
                 VBarModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 VBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the
                 model has at least four columns). Each bar set would contain data starting from row 1. The name of a set would be
                 defined by the horizontal header (of the column).
                 \code
                     GroupedBarSeries {
                         VBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetColumn: 1
                             lastBarSetColumn: 3
                             firstRow: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QVBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty BarSeries VBarModelMapper::series
                 Defines the BarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. NOTE: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVBarModelMapper::firstBarSetColumn
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstBarSetColumn
                 Defines which column of the model is used as the data source for the first bar set. Default value
                 is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::lastBarSetColumn
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::lastBarSetColumn
                 Defines which column of the model is used as the data source for the last bar set. Default
                 value is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::firstRow
                 \brief Defines which row of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstRow
                 Defines which row of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QVBarModelMapper::rowCount
                 \brief Defines the number of rows of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VBarModelMapper::rowCount
                 Defines the number of rows of the model that are mapped as the data for QBarSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstBarSetColumnChanged()
                 Emitted when the firstBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::lastBarSetColumnChanged()
                 Emitted when the lastBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVBarModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel* QVBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QVBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
-            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);
                     emit seriesReplaced();
                 }
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 if (firstBarSetColumn != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
                     emit firstBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 if (lastBarSetColumn != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
                     emit lastBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::firstRow() const
             {
                 return QBarModelMapper::first();
             }
             void QVBarModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     QBarModelMapper::setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVBarModelMapper::rowCount() const
             {
                 return QBarModelMapper::count();
             }
             void QVBarModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     QBarModelMapper::setCount(rowCount);
                     emit firstRowChanged();
                 }
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qvbarmodelmapper.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QVBARMODELMAPPER_H
             #define QVBARMODELMAPPER_H
             #include <QBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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)
                 Q_PROPERTY(int firstRow READ firstRow WRITE setFirstRow NOTIFY firstRowChanged)
                 Q_PROPERTY(int rowCount READ rowCount WRITE setRowCount NOTIFY rowCountChanged)
             public:
                 explicit QVBarModelMapper(QObject *parent = 0);
                 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);
                 int lastBarSetColumn() const;
                 void setLastBarSetColumn(int lastBarSetColumn);
                 int firstRow() const;
                 void setFirstRow(int firstRow);
                 int rowCount() const;
                 void setRowCount(int rowCount);
             Q_SIGNALS:
                 void seriesReplaced();
                 void modelReplaced();
                 void firstBarSetColumnChanged();
                 void lastBarSetColumnChanged();
                 void firstRowChanged();
                 void rowCountChanged();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVBARMODELMAPPER_H

src/barchart/stackedbarchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset_p.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
+            StackedBarChartItem::StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accuracy
                 qreal categoryCount = m_series->d_func()->categoryCount();
                 qreal setCount = m_series->count();
                 bool barsVisible = m_series->isVisible();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal rangeY = m_domainMaxY - m_domainMinY;
                 qreal rangeX = m_domainMaxX - m_domainMinX;
                 qreal scaleY = (height / rangeY);
                 qreal scaleX = (width / rangeX);
                 qreal barWidth = scaleX * m_series->d_func()->barWidth();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + rangeY * m_domainMinY + geometry().topLeft().y();
                     for (int set=0; set < setCount; set++) {
                         QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->m_values.at(category).x() - m_domainMinX) * scaleX + m_rect.left() - barWidth/2;
                         qreal barHeight = barSet->m_values.at(category).y() * scaleY;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->m_values.at(category).y())) {
                             label->setText(QString::number(barSet->m_values.at(category).y()));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                 }
                 return layout;
             }
             void StackedBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this, m_layout, layout);
                 } else {
                     setLayout(layout);
                     update();
                 }
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarchartitem_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef STACKEDBARCHARTITEM_H
             #define STACKEDBARCHARTITEM_H
             #include "barchartitem_p.h"
             #include "qstackedbarseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class StackedBarChartItem : public BarChartItem
             {
                 Q_OBJECT
             public:
-                StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter);
+                StackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter);
             private:
                 virtual QVector<QRectF> calculateLayout();
                 virtual void applyLayout(const QVector<QRectF> &layout);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARCHARTITEM_H

src/charttheme.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qabstractaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qsplineseries.h"
             //items
             #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_labelBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_labelBrush);
                 chart->setDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (pen == legend->pen() || m_force)
                     legend->setPen(m_axisLinePen);
                 if (brush == legend->brush() || m_force)
                     legend->setBrush(m_chartBackgroundGradient);
                 if (font == legend->font() || m_force)
                     legend->setFont(m_labelFont);
                 if (brush == legend->labelBrush() || m_force)
                     legend->setLabelBrush(m_labelBrush);
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
-            void ChartTheme::decorate(QBarSeries *series, int index)
+            void ChartTheme::decorate(QAbstractBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (d->m_data.m_slicePen.isThemed() || m_force)
                         d->setPen(penColor, true);
                     if (d->m_data.m_sliceBrush.isThemed() || m_force)
                         d->setBrush(brushColor, true);
                     if (d->m_data.m_labelBrush.isThemed() || m_force)
                         d->setLabelBrush(m_labelBrush.color(), true);
                     if (d->m_data.m_labelFont.isThemed() || m_force)
                         d->setLabelFont(m_labelFont, true);
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAbstractAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_labelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class LineChartItem;
             class QLineSeries;
             class BarChartItem;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class StackedBarChartItem;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarChartItem;
             class QScatterSeries;
             class ScatterChartItem;
             class PieChartItem;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
                 explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight);
             public:
                 static ChartTheme *createTheme(QChart::ChartTheme theme);
                 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);
                 void decorate(QPieSeries *series, int index);
                 void decorate(QSplineSeries *series, int index);
                 void decorate(QAbstractAxis *axis, bool axisX);
                 void setForced(bool enabled);
                 bool isForced() { return m_force; }
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_chartBackgroundGradient;
                 QFont m_masterFont;
                 QFont m_labelFont;
                 QBrush m_labelBrush;
                 QPen m_axisLinePen;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 bool m_backgroundDropShadowEnabled;
                 QPen m_gridLinePen;
                 bool m_force;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/legend/legendmarker.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) :
                 QGraphicsObject(legend),
                 m_series(series),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_legend(legend),
                 m_textItem(new QGraphicsSimpleTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
                 m_margin(2),
                 m_space(4)
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
                 m_textItem->setPen(pen);
             }
             QPen LegendMarker::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 QFontMetrics fn(font);
                 m_markerRect = QRectF(0,0,fn.height()/2,fn.height()/2);
                 updateGeometry();
             }
             QFont LegendMarker::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarker::setLabel(const QString label)
             {
                 m_textItem->setText(label);
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
             }
             QBrush LegendMarker::labelBrush() const
             {
                 return m_textItem->brush();
             }
             void LegendMarker::setGeometry(const QRectF& rect)
             {
                 const QRectF& textRect = m_textItem->boundingRect();
                 m_textItem->setPos(m_markerRect.width() + m_space + m_margin,rect.height()/2 - textRect.height()/2);
                 m_rectItem->setRect(m_markerRect);
                 m_rectItem->setPos(m_margin,rect.height()/2 - m_markerRect.height()/2);
                 prepareGeometryChange();
                 m_boundingRect = rect;
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(m_textItem->font());
                 QSizeF sh;
                   switch (which) {
                     case Qt::MinimumSize:
                         sh = QSizeF(fn.boundingRect("...").width(),fn.height());
                         break;
                     case Qt::PreferredSize:
                         sh = QSizeF(fn.boundingRect(m_textItem->text()).width() + 2*m_margin + m_space +m_markerRect.width(),qMax(m_markerRect.height()+2*m_margin,fn.height()+2*m_margin));
                         break;
                     default:
                       break;
                   }
                   return sh;
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            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()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker_p.h +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             #include <QGraphicsLayoutItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
-            class QBarSeries;
+            class QAbstractBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
             class LegendMarker : public QGraphicsObject, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 explicit LegendMarker(QAbstractSeries *m_series, QLegend *parent);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setFont(const QFont &font);
                 QFont font() const;
                 void setLabel(const QString label);
                 QString label() const;
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 QAbstractSeries *series() const { return m_series;}
                 void setGeometry(const QRectF& rect);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QSizeF sizeHint (Qt::SizeHint which, const QSizeF& constraint) const;
             protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             public Q_SLOTS:
                 virtual void updated() = 0;
             protected:
                 QAbstractSeries *m_series;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
                 QLegend* m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;
                 qreal m_space;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class XYLegendMarker : public LegendMarker
             {
             public:
                 XYLegendMarker(QXYSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QXYSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class AreaLegendMarker : public LegendMarker
             {
             public:
                 AreaLegendMarker(QAreaSeries *series, QLegend *legend);
             protected:
                 void updated();
             private:
                 QAreaSeries *m_series;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class BarLegendMarker : public LegendMarker
             {
             public:
-                BarLegendMarker(QBarSeries *barseries, QBarSet *barset,QLegend *legend);
+                BarLegendMarker(QAbstractBarSeries *barseries, QBarSet *barset,QLegend *legend);
             protected:
                 void updated();
             private:
                 QBarSet *m_barset;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             class PieLegendMarker : public LegendMarker
             {
             public:
                 PieLegendMarker(QPieSeries *pieSeries, QPieSlice *pieslice, QLegend *legend);
             protected:
                 void updated();
             private:
                 QPieSlice *m_pieslice;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKER_P_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qabstractaxis.h>
             #include <qvaluesaxis.h>
             #include <qcategoriesaxis.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public Q_SLOTS:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private Q_SLOTS:
             	void chartdataset_data();
             	void chartdataset();
             	void addSeries_data();
             	void addSeries();
                 void setAxisX_data();
                 void setAxisX();
                 void setAxisY_data();
                 void setAxisY();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
                 void seriesCount_data();
             	void seriesCount();
                 void seriesIndex_data();
             	void seriesIndex();
             	void domain_data();
             	void domain();
                 void zoomInDomain_data();
             	void zoomInDomain();
             	/*
                 void zoomOutDomain_data();
                 void zoomOutDomain();
                 void scrollDomain_data();
                 void scrollDomain();
                 */
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
                 m_dataset = new ChartDataSet();
             }
             void tst_ChartDataSet::cleanup()
             {
                 QList<QAbstractSeries*> series = m_dataset->series();
                 foreach(QAbstractSeries* serie, series)
                 {
                     m_dataset->removeSeries(serie);
                 }
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axisX(0) == 0);
             	QVERIFY(m_dataset->axisY(0) == 0);
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(m_dataset->seriesIndex(series),-1);
             	QVERIFY(m_dataset->domain(series) == 0);
             	QVERIFY(m_dataset->axisX(series) == 0);
             	QVERIFY(m_dataset->axisY(series) == 0);
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 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);
             	QTest::newRow("line") << line;
             	QTest::newRow("area") << area;
             	QTest::newRow("scatter") << scatter;
             	QTest::newRow("spline") << spline;
             	QTest::newRow("pie") << pie;
                 QTest::newRow("bar") << bar;
             	QTest::newRow("percent") << percent;
             	QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 if(series->type()==QAbstractSeries::SeriesTypePie){
                     TRY_COMPARE(spy0.count(), 0);
                 }else{
                     TRY_COMPARE(spy0.count(), 2);
                 }
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::setAxisX_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 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);
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
                 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
                 QList<QAbstractAxis*> axes0;
                 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
                 axes0 << axes0.last();
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
                     << (QList<QAbstractSeries*>() << line << spline << scatter)
                     << axes0 << 2;
                 //TODO: add more test cases
             }
             void tst_ChartDataSet::setAxisX()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::setAxisY_data()
             {
                 setAxisX_data();
             }
             void tst_ChartDataSet::setAxisY()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 Q_ASSERT(seriesList.count() == axisList.count());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 foreach(QAbstractSeries* series, seriesList){
                     m_dataset->addSeries(series);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), seriesList.count());
                 TRY_COMPARE(spy3.count(), 0);
                 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
                 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 for(int i=0 ; i < seriesList.count(); i++){
                        m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
                 }
                 TRY_COMPARE(spy4.count(), axisCount);
                 TRY_COMPARE(spy5.count(), 0);
                 TRY_COMPARE(spy6.count(), 0);
                 TRY_COMPARE(spy7.count(), 0);
                 for(int i=0 ; i < seriesList.count(); i++){
                     QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
                 }
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 m_dataset->addSeries(series);
                 m_dataset->createDefaultAxes();
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeSeries(series);
                 TRY_COMPARE(spy0.count(), 0);
                 if (series->type() == QAbstractSeries::SeriesTypePie) {
                     TRY_COMPARE(spy1.count(), 0);
                 }
                 else {
                     TRY_COMPARE(spy1.count(), 2);
                 }
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
                 QTest::addColumn<int>("axisCount");
                 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
                     << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
                         << new QScatterSeries(this))
                     << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
                         << new QValuesAxis(this)) << 3;
                 //TODO:
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(QList<QAbstractAxis*>, axisList);
                 QFETCH(int, axisCount);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->removeAllSeries();
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), axisCount);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), seriesList.count());
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::addColumn<int>("seriesCount");
                 QTest::newRow("line,line, line, spline  3") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) ) << 3;
                 QTest::newRow("scatter,scatter, line, line  2") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 QFETCH(int, seriesCount);
                 foreach(QAbstractSeries* series, seriesList){
                       m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
                 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() <<  new QScatterSeries(this) <<  new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->removeSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 1)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(1));
                 for (int i = 0; i < seriesList.count(); i++) {
                     QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
                 m_dataset->removeSeries(seriesList.at(2));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->removeSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i != 2 && i != 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
                 }
                 m_dataset->addSeries(seriesList.at(2));
                 m_dataset->addSeries(seriesList.at(0));
                 for (int i = 0; i < seriesList.count(); i++) {
                     if (i == 2)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
                     else if (i == 0)
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
                     else
                         QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
                 }
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QAbstractSeries*, series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 m_dataset->addSeries(series);
                 QVERIFY(m_dataset->domain(series));
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 QList<QVariant> arguments = spy2.takeFirst();
                 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
                 QVERIFY(m_dataset->domain(series) == domain);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
                 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() <<  new QLineSeries(this) <<  new QLineSeries(this) <<  new QLineSeries(this) << new QSplineSeries(this) );
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(QList<QAbstractSeries*>, seriesList);
                 foreach(QAbstractSeries* series, seriesList) {
                     m_dataset->addSeries(series);
                 }
                 /*
                 QValuesAxis* axis = new QValuesAxis();
                 for (int i = 0; i < seriesList.count(); i++) {
                     m_dataset->setAxisX(seriesList.at(i), axis);
                 }
             */
                 m_dataset->createDefaultAxes();
                 QList<QSignalSpy*> spyList;
                 foreach(QAbstractSeries* series, seriesList) {
                     spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 }
                 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
                 foreach(QSignalSpy* spy, spyList) {
                     TRY_COMPARE(spy->count(), 1);
                 }
                 qDeleteAll(spyList);
             }
             /*
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 m_dataset->addSeries(series0, axis0);
                 m_dataset->addSeries(series1, axis1);
                 m_dataset->addSeries(series2, axis2);
                 Domain* domain0 = m_dataset->domain(series0);
                 Domain* domain1 = m_dataset->domain(series1);
                 Domain* domain2 = m_dataset->domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 m_dataset->zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 m_dataset->addSeries(series0, axis0);
                 m_dataset->addSeries(series1, axis1);
                 m_dataset->addSeries(series2, axis2);
                 Domain* domain0 = m_dataset->domain(series0);
                 Domain* domain1 = m_dataset->domain(series1);
                 Domain* domain2 = m_dataset->domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 m_dataset->scrollDomain(10,10,QSize(1000,1000));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             */
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include "tst_definitions.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarseries_data();
                 void qbarseries();
                 void type_data();
                 void type();
                 void append_data();
                 void append();
                 void remove_data();
                 void remove();
                 void appendList_data();
                 void appendList();
                 void count_data();
                 void count();
                 void barSets_data();
                 void barSets();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 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::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
             }
             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"));
                     m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::cleanup()
             {
                 foreach(QBarSet* s, m_testSets) {
                     m_barseries_with_sets->remove(s);
                     delete s;
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
             }
             void tst_QBarSeries::qbarseries_data()
             {
             }
             void tst_QBarSeries::qbarseries()
             {
-                QBarSeries *barseries = new QBarSeries();
+                QAbstractBarSeries *barseries = new QAbstractBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QBarSeries::type_data()
             {
             }
             void tst_QBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
             void tst_QBarSeries::append_data()
             {
             }
             void tst_QBarSeries::append()
             {
                 QVERIFY(m_barseries->count() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
                 ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding same set again
                 ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
                 // Try adding null set
                 ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == 2);
             }
             void tst_QBarSeries::remove_data()
             {
             }
             void tst_QBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
                 ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
                 ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->count() == count);
                 // remove some sets
                 ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
                 ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
                     ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->count() == 0);
             }
             void tst_QBarSeries::appendList_data()
             {
             }
             void tst_QBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->count() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Append same sets again (should fail, count should remain same)
                 ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
                 ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
                 ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->count() == count);
             }
             void tst_QBarSeries::count_data()
             {
             }
             void tst_QBarSeries::count()
             {
                 QVERIFY(m_barseries->count() == 0);
                 QVERIFY(m_barseries_with_sets->count() == m_testSets.count());
             }
             void tst_QBarSeries::barSets_data()
             {
             }
             void tst_QBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
                 QVERIFY(m_barseries->isLabelsVisible() == false);
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == false);
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
                 // TODO: test the signal
                 QVERIFY(m_barseries_with_sets->isLabelsVisible() == true);
             }
             void tst_QBarSeries::mouseclicked_data()
             {
             }
             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);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(int,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(int)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(int)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(102,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 1, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(186,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 1, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(271,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             //====================================================================================
             // barset 2, bar 0
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(127,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 0);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 0);
             //====================================================================================
             // barset 2, bar 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(212,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 1);
             //====================================================================================
             // barset 2, bar 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(296,142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(seriesSpyArg.at(0).toInt() == 2);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Int);
                 QVERIFY(setSpyArg.at(0).toInt() == 2);
             }
             void tst_QBarSeries::mousehovered_data()
             {
             }
             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);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(bool,QBarSet*)));
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 142));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 10000);
                 TRY_COMPARE(seriesSpy.count(), 0);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(102,142));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(127,142));
                 TRY_COMPARE(seriesSpy.count(), 2);
                 TRY_COMPARE(setSpy1.count(), 1);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set1);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == true);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(127,0));
                 TRY_COMPARE(seriesSpy.count(), 1);
                 TRY_COMPARE(setSpy1.count(), 0);
                 TRY_COMPARE(setSpy2.count(), 1);
                 // should leave set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(1)), set2);
                 QVERIFY(seriesSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(0).toBool() == false);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
             }
             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);
                 *set1 << 10 << 10 << 10;
                 series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
             //    *set2 << QPointF(0.3,10) << QPointF(1.3,10) << QPointF(2.3,10);
                 *set2 << 10 << 10 << 10;
                 series->append(set2);
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->setAnimationOptions(QChart::SeriesAnimations);
                 view.chart()->addSeries(series);
                 view.show();
                 series->clear();
             }
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

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

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <qvaluesaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QValuesAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void margins_data();
                 void margins();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scroll_data();
                 void scroll();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::createTestData()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                 m_chart->addSeries(series0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(m_chart->axisX());
                 QVERIFY(m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scroll(0,0);
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::addColumn<QAbstractAxis *>("axis");
                 QAbstractSeries* series0 = new QLineSeries(this);
                 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
                 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);
                 QValuesAxis* axis = new QValuesAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QAbstractAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
                 QTest::newRow("default axis: areaSeries") << series1 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
                 QTest::newRow("default axis: scatterSeries") << series2 << (QAbstractAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
                 QTest::newRow("default axis: splineSeries") << series3 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
                 QTest::newRow("default axis: pieSeries") << series4 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
                 QTest::newRow("default axis: barSeries") << series5 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
                 QTest::newRow("default axis: percentBarSeries") << series6 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
                 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAbstractAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAbstractAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->series().count(), 1);
                 QCOMPARE(m_chart->series().first(), series);
                 QVERIFY(series->chart() == m_chart);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(!series->chart());
                 QCOMPARE(m_chart->series().count(), 0);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
             }
             void tst_QChart::axisX()
             {
                 QVERIFY(m_chart->axisX());
                 QAbstractAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis0");
                 QTest::addColumn<QAbstractAxis*>("axis1");
                 QTest::addColumn<QAbstractAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QAbstractAxis*)0 << new QValuesAxis() << new QValuesAxis();
                 QTest::newRow("3 optional") << new QValuesAxis() << new QValuesAxis() << new QValuesAxis();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAbstractAxis*, axis0);
                 QFETCH(QAbstractAxis*, axis1);
                 QFETCH(QAbstractAxis*, axis2);
                 QAbstractAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0);
                 m_chart->setAxisY(axis0,series0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1);
                 m_chart->setAxisY(axis1,series1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2);
                 m_chart->setAxisY(axis2,series2);
                 if (!axis0)
                     axis0 = defaultAxisY;
                 if (!axis1)
                     axis1 = defaultAxisY;
                 if (!axis2)
                     axis2 = defaultAxisY;
                 QVERIFY(m_chart->axisY(series0) == axis0);
                 QVERIFY(m_chart->axisY(series1) == axis1);
                 QVERIFY(m_chart->axisY(series2) == axis2);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QLegend *legend = m_chart->legend();
                 QVERIFY(legend);
                 // Colors related signals
                 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
                 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
                 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
                 // colorChanged
                 legend->setColor(QColor("aliceblue"));
                 QCOMPARE(colorSpy.count(), 1);
                 QBrush b = legend->brush();
                 b.setColor(QColor("aqua"));
                 legend->setBrush(b);
                 QCOMPARE(colorSpy.count(), 2);
                 // borderColorChanged
                 legend->setBorderColor(QColor("aliceblue"));
                 QCOMPARE(borderColorSpy.count(), 1);
                 QPen p = legend->pen();
                 p.setColor(QColor("aqua"));
                 legend->setPen(p);
                 QCOMPARE(borderColorSpy.count(), 2);
                 // labelColorChanged
                 legend->setLabelColor(QColor("lightsalmon"));
                 QCOMPARE(labelColorSpy.count(), 1);
                 b = legend->labelBrush();
                 b.setColor(QColor("lightseagreen"));
                 legend->setLabelBrush(b);
                 QCOMPARE(labelColorSpy.count(), 2);
                 // fontChanged
                 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
                 QFont f = legend->font();
                 f.setBold(!f.bold());
                 legend->setFont(f);
                 QCOMPARE(fontSpy.count(), 1);
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
                 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
                 QCOMPARE(deleteSpy1.count(), 1);
                 QCOMPARE(deleteSpy2.count(), 1);
                 QCOMPARE(deleteSpy3.count(), 1);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAbstractAxis *, axis);
                 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series);
                 m_chart->setAxisY(axis,series);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
                 QCOMPARE(deleteSpy.count(), 0);
             }
             void tst_QChart::scroll_data()
             {
             }
             void tst_QChart::scroll()
             {
                 qFatal("implement me");
                 createTestData();
                 //TODO qreal min = m_chart->axisY()->min();
                 m_chart->scroll(0,0);
                 //TODO QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 qFatal("implement me");
                 /*
                 QFETCH(QRectF, rect);
                 createTestData();
                 QRectF marigns = m_chart->margins();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<m_chart->axisX()->min());
                     QVERIFY(maxX>m_chart->axisX()->max());
                     QVERIFY(minY<m_chart->axisY()->min());
                     QVERIFY(maxY>m_chart->axisY()->max());
                 }
                 */
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 qFatal("implement me");
                 createTestData();
                 /*
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn();
                 QVERIFY(minX < m_chart->axisX()->min());
                 QVERIFY(maxX > m_chart->axisX()->max());
                 QVERIFY(minY < m_chart->axisY()->min());
                 QVERIFY(maxY > m_chart->axisY()->max());
                 m_chart->zoomOut();
                 // min x may be a zero value
                 if (qFuzzyIsNull(minX))
                     QVERIFY(qFuzzyIsNull(m_chart->axisX()->min()));
                 else
                     QCOMPARE(minX, m_chart->axisX()->min());
                 // min y may be a zero value
                 if (qFuzzyIsNull(minY))
                     QVERIFY(qFuzzyIsNull(m_chart->axisY()->min()));
                 else
                     QCOMPARE(minY, m_chart->axisY()->min());
                 QVERIFY(maxX == m_chart->axisX()->max());
                 QVERIFY(maxY == m_chart->axisY()->max());
                 */
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

tests/chartwidgettest/mainwidget.cpp +2 -2

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

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