HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r988:8a36a6921f5a

Renamed QSeries to QAbstractSeries

Tero Ahola -

r988:8a36a6921f5a

parent child

Context file:

r988:8a36a6921f5a

Expand all files

examples/piechartdrilldown/drilldownchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownchart.h"
             #include "drilldownslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 :QChart(parent, wFlags),
                 m_currentSeries(0)
             {
             }
             DrilldownChart::~DrilldownChart()
             {
             }
-            void DrilldownChart::changeSeries(QSeries* series)
+            void DrilldownChart::changeSeries(QAbstractSeries* series)
             {
                 // NOTE: if the series is owned by the chart it will be deleted
                 // here the "window" owns the series...
                 if (m_currentSeries)
                     removeSeries(m_currentSeries);
                 m_currentSeries = series;
                 addSeries(series);
                 setTitle(series->name());
             }
             void DrilldownChart::handleSliceClicked(QPieSlice* slice)
             {
                 DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
                 changeSeries(drilldownSlice->drilldownSeries());
             }
             #include "moc_drilldownchart.cpp"

examples/piechartdrilldown/drilldownchart.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 DRILLDOWNCHART_H
             #define DRILLDOWNCHART_H
             #include <QChart>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSeries;
+            class QAbstractSeries;
             class QPieSlice;
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownChart : public QChart
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~DrilldownChart();
-                void changeSeries(QSeries* series);
+                void changeSeries(QAbstractSeries* series);
             public Q_SLOTS:
                 void handleSliceClicked(QPieSlice* slice);
             private:
-                QSeries* m_currentSeries;
+                QAbstractSeries* m_currentSeries;
             };
             #endif // DRILLDOWNCHART_H

examples/piechartdrilldown/drilldownslice.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 "drilldownslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
-            DrilldownSlice::DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
+            DrilldownSlice::DrilldownSlice(qreal value, QString prefix, QAbstractSeries* drilldownSeries)
                 :m_drilldownSeries(drilldownSeries),
                 m_prefix(prefix)
             {
                 setValue(value);
                 updateLabel();
                 setLabelFont(QFont("Arial", 8));
                 connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
                 connect(this, SIGNAL(hoverEnter()), this, SLOT(showHighlight()));
                 connect(this, SIGNAL(hoverLeave()), this, SLOT(hideHighlight()));
             }
             DrilldownSlice::~DrilldownSlice()
             {
             }
-            QSeries* DrilldownSlice::drilldownSeries() const
+            QAbstractSeries* DrilldownSlice::drilldownSeries() const
             {
                 return m_drilldownSeries;
             }
             void DrilldownSlice::updateLabel()
             {
                 QString label = m_prefix;
                 label += " $";
                 label += QString::number(this->value());
                 label += ", ";
                 label += QString::number(this->percentage()*100, 'f', 1);
                 label += "%";
                 setLabel(label);
             }
             void DrilldownSlice::showHighlight()
             {
                 setExploded();
                 setLabelVisible();
             }
             void DrilldownSlice::hideHighlight()
             {
                 setExploded(false);
                 setLabelVisible(false);
             }
             #include "moc_drilldownslice.cpp"

examples/piechartdrilldown/drilldownslice.h +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DRILLDOWNSLICE_H
             #define DRILLDOWNSLICE_H
             #include <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSeries;
+            class QAbstractSeries;
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
-                DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries);
+                DrilldownSlice(qreal value, QString prefix, QAbstractSeries* drilldownSeries);
                 virtual ~DrilldownSlice();
-                QSeries* drilldownSeries() const;
+                QAbstractSeries* drilldownSeries() const;
             public Q_SLOTS:
                 void updateLabel();
                 void showHighlight();
                 void hideHighlight();
             private:
-                QSeries* m_drilldownSeries;
+                QAbstractSeries* m_drilldownSeries;
                 QString m_prefix;
             };
             #endif // DRILLDOWNSLICE_H

examples/presenterchart/chartview.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 "chartview.h"
             #include <QLineSeries>
             #include <QScatterSeries>
             #include <QSplineSeries>
             #include <QAreaSeries>
             #include <QTime>
             ChartView::ChartView(QChart* chart,QWidget* parent):QChartView(chart,parent),
             m_index(-1),m_chart(chart)
             {
                 m_chart->setTitle("Charts presenter");
                 QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(handleTimeout()));
                 m_timer.setInterval(3000);
             //![1]
                 QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QScatterSeries* series1 = new QScatterSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 series1->setBrush(Qt::white);
                 QSplineSeries* series2 = new QSplineSeries();
                 QPen green(Qt::green);
                 green.setWidth(3);
                 series2->setPen(green);
                 QAreaSeries* series3 = new QAreaSeries(series0);
                 QPen yellow(Qt::black);
                 yellow.setWidth(3);
                 series3->setPen(yellow);
                 series3->setBrush(Qt::yellow);
             //![1]
             //![2]
                 int numPoints = 10;
                 for (int x = 0; x <= numPoints; ++x) {
                     qreal y = qrand() % 100;
                     series0->append(x,y);
                     series1->append(x,y);
                     series2->append(x,y);
                 }
             //![2]
             //![3]
                 m_series<<series0;
                 m_titles<< m_chart->title()+": LineChart";
                 m_series<<series1;
                 m_titles<< m_chart->title()+": ScatterChart";
                 m_series<<series2;
                 m_titles<< m_chart->title()+": SplineChart";
                 m_series<<series3;
                 m_titles<< m_chart->title()+": AreaChart";
             //![3]
             //![4]
-                foreach (QSeries* series, m_series) {
+                foreach (QAbstractSeries* series, m_series) {
                     QObject::connect(series,SIGNAL(clicked(QPointF)),this,SLOT(handlePointClicked(QPointF)));
                 }
             //![4]
                 m_timer.start();
                 handleTimeout();
             }
             ChartView::~ChartView()
             {
                 if(m_series.size()==0) return;
                 m_chart->removeSeries(m_series.at(m_index));
                 m_series.removeLast();  //remove QAreaSeries instance since they will be deleted when QLineSeries instance is gone
                 qDeleteAll(m_series);
             }
             //![5]
             void ChartView::handleTimeout()
             {
                 if(m_series.size()==0) return;
                 if(m_index>=0)
                 m_chart->removeSeries(m_series.at(m_index));
                 m_index++;
                 m_index=m_index%m_series.size();
                 m_chart->addSeries(m_series.at(m_index));
                 m_chart->setTitle(m_titles.at(m_index));
             }
             //![5]
             //![6]
             void ChartView::handlePointClicked(const QPointF& point)
             {
                 m_chart->setTitle(m_titles.at(m_index) + QString(" x: %1 y: %2").arg(point.x()).arg(point.y()));
             }
             //![6]

examples/presenterchart/chartview.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 CHARTVIEW_H_
             #define CHARTVIEW_H_
             #include <QChartView>
             #include <QTimer>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //![1]
             class ChartView: public QChartView
             {
                 Q_OBJECT
             public:
                 ChartView(QChart* chart,QWidget* parent = 0);
                 virtual ~ChartView();
             public slots:
                 void handleTimeout();
                 void handlePointClicked(const QPointF& point);
             private:
                 QTimer m_timer;
-                QList<QSeries*> m_series;
+                QList<QAbstractSeries *> m_series;
                 QStringList m_titles;
                 int m_index;
                 QChart *m_chart;
             };
             //![1]
             #endif /* CHARTVIEW_H_ */

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownchart.h"
             #include <QChartAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QChart(parent, wFlags)
                 ,m_currentSeries(0)
             {
             }
-            void DrilldownChart::changeSeries(QSeries* series)
+            void DrilldownChart::changeSeries(QAbstractSeries *series)
             {
                 if (m_currentSeries)
                     removeSeries(m_currentSeries);
                 m_currentSeries = series;
                 addSeries(series);
                 setTitle(series->name());
                 axisY()->setNiceNumbersEnabled(true);
             }
             void DrilldownChart::handleClicked(QBarSet *barset, QString category, Qt::MouseButtons button)
             {
                 Q_UNUSED(barset)
                 Q_UNUSED(button)
                 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                 changeSeries(series->drilldownSeries(category));
             }
             #include "moc_drilldownchart.cpp"

examples/stackedbarchartdrilldown/drilldownchart.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$
             **
             ****************************************************************************/
             #ifndef DRILLDOWNCHART_H
             #define DRILLDOWNCHART_H
             #include <QChart>
             #include "drilldownseries.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             //! [2]
             class DrilldownChart : public QChart
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
-                void changeSeries(QSeries* series);
+                void changeSeries(QAbstractSeries *series);
             public Q_SLOTS:
                 void handleClicked(QBarSet *barset, QString category, Qt::MouseButtons button);
             private:
-                QSeries* m_currentSeries;
+                QAbstractSeries* m_currentSeries;
             };
             //! [2]
             #endif // DRILLDOWNCHART_H

qmlplugin/declarativeareaseries.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 "declarativeareaseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeAreaSeries::DeclarativeAreaSeries(QObject *parent) :
                 QAreaSeries(new QLineSeries(parent), new QLineSeries(parent))
             {
             }
-            QSeries *DeclarativeAreaSeries::series()
+            QAbstractSeries *DeclarativeAreaSeries::series()
             {
                 return this;
             }
             QDeclarativeListProperty<DeclarativeXyPoint> DeclarativeAreaSeries::points()
             {
                 return QDeclarativeListProperty<DeclarativeXyPoint>(this, 0, &DeclarativeAreaSeries::appendPoints);
             }
             QDeclarativeListProperty<DeclarativeXyPoint> DeclarativeAreaSeries::lowerPoints()
             {
                 return QDeclarativeListProperty<DeclarativeXyPoint>(this, 0, &DeclarativeAreaSeries::appendLowerPoints);
             }
             void DeclarativeAreaSeries::appendPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                                       DeclarativeXyPoint *element)
             {
                 QAreaSeries *series = qobject_cast<QAreaSeries *>(list->object);
                 if (series) {
                     QLineSeries *upper = series->upperSeries();
                     upper->append(element->x(), element->y());
                 }
             }
             void DeclarativeAreaSeries::appendLowerPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                                           DeclarativeXyPoint *element)
             {
                 QAreaSeries *series = qobject_cast<QAreaSeries *>(list->object);
                 if (series) {
                     QLineSeries *lower = series->lowerSeries();
                     lower->append(element->x(), element->y());
                 }
             }
             #include "moc_declarativeareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativeareaseries.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 DECLARATIVEAREASERIES_H
             #define DECLARATIVEAREASERIES_H
             #include "qchartglobal.h"
             #include "qareaseries.h"
             #include "declarativexyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeAreaSeries : public QAreaSeries, public DeclarativeXySeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QDeclarativeListProperty<DeclarativeXyPoint> points READ points)
                 Q_PROPERTY(QDeclarativeListProperty<DeclarativeXyPoint> lowerPoints READ lowerPoints)
             public:
                 explicit DeclarativeAreaSeries(QObject *parent = 0);
             public:
-                QSeries *series();
+                QAbstractSeries *series();
                 QDeclarativeListProperty<DeclarativeXyPoint> points();
                 QDeclarativeListProperty<DeclarativeXyPoint> lowerPoints();
             public Q_SLOTS:
                 static void appendPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                          DeclarativeXyPoint *element);
                 static void appendLowerPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                          DeclarativeXyPoint *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEAREASERIES_H

qmlplugin/declarativelineseries.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 "declarativelineseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeLineSeries::DeclarativeLineSeries(QObject *parent) :
                 QLineSeries(parent)
             {
             }
-            QSeries *DeclarativeLineSeries::series()
+            QAbstractSeries *DeclarativeLineSeries::series()
             {
                 return this;
             }
             QDeclarativeListProperty<DeclarativeXyPoint> DeclarativeLineSeries::points()
             {
                 return QDeclarativeListProperty<DeclarativeXyPoint>(this, 0, &DeclarativeXySeries::appendPoints);
             }
             #include "moc_declarativelineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativelineseries.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 DECLARATIVELINESERIES_H
             #define DECLARATIVELINESERIES_H
             #include "qchartglobal.h"
             #include "qlineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeLineSeries : public QLineSeries, public DeclarativeXySeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QDeclarativeListProperty<DeclarativeXyPoint> points READ points)
             public:
                 explicit DeclarativeLineSeries(QObject *parent = 0);
             public:
-                QSeries *series();
+                QAbstractSeries *series();
                 QDeclarativeListProperty<DeclarativeXyPoint> points();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVELINESERIES_H

qmlplugin/declarativescatterseries.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 "declarativescatterseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeScatterSeries::DeclarativeScatterSeries(QObject *parent) :
                 QScatterSeries(parent)
             {
             }
-            QSeries *DeclarativeScatterSeries::series()
+            QAbstractSeries *DeclarativeScatterSeries::series()
             {
                 return this;
             }
             QDeclarativeListProperty<DeclarativeXyPoint> DeclarativeScatterSeries::points()
             {
                 return QDeclarativeListProperty<DeclarativeXyPoint>(this, 0, &DeclarativeXySeries::appendPoints);
             }
             #include "moc_declarativescatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativescatterseries.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 DECLARATIVESCATTERSERIES_H
             #define DECLARATIVESCATTERSERIES_H
             #include "qchartglobal.h"
             #include "qscatterseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeScatterSeries : public QScatterSeries, public DeclarativeXySeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QDeclarativeListProperty<DeclarativeXyPoint> points READ points)
             public:
                 explicit DeclarativeScatterSeries(QObject *parent = 0);
             public:
-                QSeries *series();
+                QAbstractSeries *series();
                 QDeclarativeListProperty<DeclarativeXyPoint> points();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESCATTERSERIES_H

qmlplugin/declarativesplineseries.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 "declarativesplineseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeSplineSeries::DeclarativeSplineSeries(QObject *parent) :
                 QSplineSeries(parent)
             {
             }
-            QSeries *DeclarativeSplineSeries::series()
+            QAbstractSeries *DeclarativeSplineSeries::series()
             {
                 return this;
             }
             QDeclarativeListProperty<DeclarativeXyPoint> DeclarativeSplineSeries::points()
             {
                 return QDeclarativeListProperty<DeclarativeXyPoint>(this, 0, &DeclarativeXySeries::appendPoints);
             }
             #include "moc_declarativesplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativesplineseries.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 DECLARATIVESPLINESERIES_H
             #define DECLARATIVESPLINESERIES_H
             #include "qchartglobal.h"
             #include "qsplineseries.h"
             #include "declarativexyseries.h"
             #include <QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeSplineSeries : public QSplineSeries, public DeclarativeXySeries
             {
                 Q_OBJECT
                 Q_PROPERTY(QDeclarativeListProperty<DeclarativeXyPoint> points READ points)
             public:
                 explicit DeclarativeSplineSeries(QObject *parent = 0);
             public:
-                QSeries *series();
+                QAbstractSeries *series();
                 QDeclarativeListProperty<DeclarativeXyPoint> points();
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVESPLINESERIES_H

qmlplugin/declarativexyseries.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 "DeclarativeXySeries.h"
             #include "declarativexyseries.h"
             #include "qxyseries.h"
             #include "declarativechart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeXySeries::DeclarativeXySeries()
             {
             }
             DeclarativeXySeries::~DeclarativeXySeries()
             {
             }
             void DeclarativeXySeries::classBegin()
             {
             }
             void DeclarativeXySeries::componentComplete()
             {
-                QSeries *thisObj = reinterpret_cast<QSeries *>(series());
+                QAbstractSeries *thisObj = reinterpret_cast<QAbstractSeries *>(series());
                 DeclarativeChart *declarativeChart = qobject_cast<DeclarativeChart *>(thisObj->parent());
                 if (declarativeChart) {
                     QChart *chart = qobject_cast<QChart *>(declarativeChart->m_chart);
                     Q_ASSERT(chart);
                     chart->addSeries(thisObj);
                 }
             }
             void DeclarativeXySeries::appendPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                                       DeclarativeXyPoint *element)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(list->object);
                 if (series)
                     series->append(element->x(), element->y());
             }
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativexyseries.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$
             **
             ****************************************************************************/
             #ifndef DECLARATIVE_XY_SERIES_H
             #define DECLARATIVE_XY_SERIES_H
             #include "qchartglobal.h"
             #include "declarativexypoint.h"
             #include <QDeclarativeParserStatus>
             #include <QDeclarativeListProperty>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
-            class QSeries;
+            class QAbstractSeries;
             class DeclarativeXySeries : public QDeclarativeParserStatus
             {
                 Q_INTERFACES(QDeclarativeParserStatus)
             public:
                 explicit DeclarativeXySeries();
                 ~DeclarativeXySeries();
             public: // from QDeclarativeParserStatus
                 virtual void classBegin();
                 virtual void componentComplete();
             public:
-                virtual QSeries *series() = 0;
+                virtual QAbstractSeries *series() = 0;
                 virtual QDeclarativeListProperty<DeclarativeXyPoint> points() = 0;
             public Q_SLOTS:
                 static void appendPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                          DeclarativeXyPoint *element);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVE_XY_SERIES_H

src/areachart/qareaseries.cpp +5 -5

             /****************************************************************************
             **
             ** 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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
             	\image areachart.png
             	Creating basic area chart is simple:
             	\code
             	QLineSeries* lineSeries = new QLineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
             	QAreaSeries* areaSeries = new QAreaSeries(lineSeries);
             	...
             	chartView->addSeries(areaSeries);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QAreaSeries::type() const
                 \brief Returns type of series.
-                \sa QSeries, QSeriesType
+                \sa QAbstractSeries, QSeriesType
             */
             /*!
                \fn QLineSeries* QAreaSeries::upperSeries() const
                \brief Returns upperSeries used to define one of area boundaries.
             */
             /*!
                \fn QLineSeries* QAreaSeries::lowerSeries() const
                \brief Returns lowerSeries used to define one of area boundaries. Note if QAreaSeries where counstucted wihtout a\ lowerSeries
                 this function return Null pointer.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                \fn bool  QAreaSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
-                : QSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
+                : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
-            QSeries::QSeriesType QAreaSeries::type() const
+            QAbstractSeries::QSeriesType QAreaSeries::type() const
             {
-                return QSeries::SeriesTypeArea;
+                return QAbstractSeries::SeriesTypeArea;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             bool QAreaSeries::setModel(QAbstractItemModel* model)
             {
                 Q_UNUSED(model);
                 qWarning()<<"Not implemented";
                 return false;
             }
             QAbstractItemModel* QAreaSeries::model() const
             {
                 return 0;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
-                QSeriesPrivate(q),
+                QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
                 for (int i = 0; i < upperSeries->count(); i++)
                 {
                     qreal x = upperSeries->x(i);
                     qreal y = upperSeries->y(i);
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
                     for (int i = 0; i < lowerSeries->count(); i++)
                     {
                         qreal x = lowerSeries->x(i);
                         qreal y = lowerSeries->y(i);
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(area->upperLineItem());
                     if(q->lowerSeries())  presenter->animator()->addAnimation(area->lowerLineItem());
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.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 QAREASERIES_H
             #define QAREASERIES_H
             #include <qchartglobal.h>
-            #include <qseries.h>
+            #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QAreaSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
+            class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries = 0);
                 ~QAreaSeries();
             public:
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
                 QLineSeries* upperSeries() const;
                 QLineSeries* lowerSeries() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* model() const;
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void selected();
             private:
                 Q_DECLARE_PRIVATE(QAreaSeries);
                 Q_DISABLE_COPY(QAreaSeries);
                 friend class AreaLegendMarker;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/areachart/qareaseries_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 QAREASERIES_P_H
             #define QAREASERIES_P_H
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaSeries;
-            class QAreaSeriesPrivate: public QSeriesPrivate
+            class QAreaSeriesPrivate: public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
             Q_SIGNALS:
                 void updated();
             protected:
                 QBrush m_brush;
                 QPen m_pen;
                 QLineSeries* m_upperSeries;
                 QLineSeries* m_lowerSeries;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QAreaSeries);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/barchartmodel_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$
             **
             ****************************************************************************/
             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include <QStringList>
             #include "qchartglobal.h"
-            #include <qseries.h>
+            #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QStringList categories, QObject *parent = 0);
                 QStringList category();
                 void appendBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 QBarSet *barsetAt(int index) const;
                 QList<QBarSet *> barSets() const;
                 int barsetCount() const;          // Number of sets in model
                 int categoryCount() const;        // Number of categories
                 qreal max() const;                // Maximum value of all sets
                 qreal min() const;                // Minimum value of all sets
                 qreal valueAt(int set, int category) const;
                 qreal percentageAt(int set, int category) const;
                 qreal categorySum(int category) const;
                 qreal absoluteCategorySum(int category) const;
                 qreal maxCategorySum() const;     // returns maximum sum of sets in all categories.
                 QString categoryName(int category);
             Q_SIGNALS:
                 void modelUpdated();
             public Q_SLOTS:
             private:
                 QList<QBarSet *> m_dataModel;
                 QStringList m_category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/qbarseries.cpp +6 -5

             /****************************************************************************
             **
             ** 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 "barchartmodel_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include <QAbstractItemModel>
             #include <QModelIndex>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multiple
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, QString category, Qt::MouseButtons button)
                 The signal is emitted if the user clicks with a mouse \a button on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \fn void QBarSeries::selected()
                 The signal is emitted if the user selects/deselects the series. The logic for storing selections should be
                 implemented by the user of QBarSeries API.
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 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.
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategories categories, QObject *parent) :
-                QSeries(*new QBarSeriesPrivate(categories, this),parent)
+                QAbstractSeries(*new QBarSeriesPrivate(categories, this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
-                QSeries(d,parent)
+                QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
-            QSeries::QSeriesType QBarSeries::type() const
+            QAbstractSeries::QSeriesType QBarSeries::type() const
             {
-                return QSeries::SeriesTypeBar;
+                return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString, Qt::MouseButtons) signal
                 of \a set to this series
             */
             void QBarSeries::appendBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 d->m_internalModel->appendBarSet(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(valueChanged()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Disconnects the clicked(QString, Qt::MouseButtons) signal
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 d->m_internalModel->removeBarSet(set);
                 emit d->restructuredBars();
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Connects the clicked(QString, Qt::MouseButtons) signals
                 of \a sets to this series
             */
             void QBarSeries::appendBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* barset, sets) {
                     d->m_internalModel->appendBarSet(barset);
                     QObject::connect(barset, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
                 }
                 emit d->restructuredBars();
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
                 Disconnects the clicked(QString, Qt::MouseButtons) signal
                 of \a sets from this series
             */
             void QBarSeries::removeBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* barset, sets) {
                     d->m_internalModel->removeBarSet(barset);
                 }
                 emit d->restructuredBars();
             }
             /*!
                 Inserts new \a set on the \a i position.
                 The barset that is currently at this postion is moved to postion i + 1
             */
             void QBarSeries::insertBarSet(int i, QBarSet *set)
             {
                 Q_D(QBarSeries);
                 d->m_internalModel->insertBarSet(i, set);
                 emit d->barsetChanged();
             }
             /*!
                 Inserts new \a category on the \a i position.
                 The category that is currently at this postion is moved to postion i + 1
                 \sa removeCategory()
             */
             void QBarSeries::insertCategory(int i, QString category)
             {
                 Q_D(QBarSeries);
                 d->m_internalModel->insertCategory(i, category);
             }
             /*!
                 Removes the category specified by \a i
                 \sa insertCategory()
             */
             void QBarSeries::removeCategory(int i)
             {
                 Q_D(QBarSeries);
                 d->m_internalModel->removeCategory(i);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_internalModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_internalModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_internalModel->barSets();
             }
             /*!
                  \fn bool QBarSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QBarSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QBarSeries);
                 return d->setModel(model);
             }
             /*!
                  \fn bool QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
                  Sets column/row specified by \a categories to be used as a list of bar series categories.
                  Parameter \a bottomBoundry indicates the column/row where the first bar set is located in the model.
                  Parameter \a topBoundry indicates the column/row where the last bar set is located in the model.
                  All the columns/rows inbetween those two values are also used as data for bar sets.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QBarSeries::setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation)
             {
                 Q_D(QBarSeries);
                 d->setModelMapping(categories,bottomBoundary,topBoundary,orientation);
             }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 QBarCategories categories;
                 int count = d->m_internalModel->categoryCount();
                 for (int i=1; i <= count; i++) {
                       categories.insert(i, d->m_internalModel->categoryName(i - 1));
                 }
                 return categories;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 foreach (QBarSet* s, barSets()) {
                     s->setLabelsVisible(visible);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarSeriesPrivate::QBarSeriesPrivate(QBarCategories categories, QBarSeries *q) : QSeriesPrivate(q),
+            QBarSeriesPrivate::QBarSeriesPrivate(QBarCategories categories, QBarSeries *q) :
+                QAbstractSeriesPrivate(q),
                 m_internalModel(new BarChartModel(categories,this)),
                 m_model(0),
                 m_mapCategories(-1),
                 m_mapBarBottom(-1),
                 m_mapBarTop(-1),
                 m_mapFirst(0),
                 m_mapCount(0),
                 m_mapOrientation(Qt::Vertical)
             {
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_internalModel->barsetAt(index);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 return m_internalModel->categoryName(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 return m_internalModel->min();
             }
             qreal QBarSeriesPrivate::max()
             {
                 return m_internalModel->max();
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 return m_internalModel->valueAt(set, category);
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 return m_internalModel->percentageAt(set, category);
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 return m_internalModel->categorySum(category);
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 return m_internalModel->absoluteCategorySum(category);
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 return m_internalModel->maxCategorySum();
             }
             BarChartModel& QBarSeriesPrivate::modelInternal()
             {
                 return *m_internalModel;
             }
             bool QBarSeriesPrivate::setModel(QAbstractItemModel *model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     m_mapCategories = -1;
                     m_mapBarBottom = -1;
                     m_mapBarTop = -1;
                     m_mapFirst = 0;
                     m_mapCount = 0;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = 0;
                     return false;
                 }
             }
             void QBarSeriesPrivate::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             {
                 Q_Q(QBarSeries);
                 if (m_model == 0)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
             //    m_mapFirst = 1;
                 m_mapOrientation = orientation;
                 // connect the signals
                 if (m_mapOrientation == Qt::Vertical) {
                     m_mapCount = m_model->rowCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     m_mapCount = m_model->columnCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(m_model,SIGNAL(columnsInserted(QModelIndex,int,int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial bars
                 delete m_internalModel;
                 if (m_mapOrientation == Qt::Vertical) {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
                     m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
                         q->appendBarSet(barSet);
                     }
                 } else {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
                     m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
                         q->appendBarSet(barSet);
                     }
                 }
             }
             void QBarSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop && topLeft.row() >= m_mapFirst && topLeft.row() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.column() - m_mapBarBottom)->setValue(topLeft.row() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
                 else
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop && topLeft.column() >= m_mapFirst && topLeft.column() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.row() - m_mapBarBottom)->setValue(topLeft.column() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
             }
             void QBarSeriesPrivate::modelDataAdded(QModelIndex /*parent*/, int start, int /*end*/)
             {
                 Q_Q(QBarSeries);
                 if (m_mapOrientation == Qt::Vertical) {
                     q->insertCategory(start - m_mapFirst, QString("Row: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(start, i), Qt::DisplayRole).toDouble());
                     }
                 } else {
                     q->insertCategory(start - m_mapFirst, QString("Column: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(i, start), Qt::DisplayRole).toDouble());
                     }
                 }
                 emit restructuredBars();
             }
             void QBarSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_Q(QBarSeries);
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 q->removeCategory(start - m_mapFirst);
                 for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
                 {
                     barsetAt(i)->removeValue(start - m_mapFirst);
                 }
                 emit restructuredBars();
             }
             void QBarSeriesPrivate::barsetChanged()
             {
                 emit updatedBars();
             }
             void QBarSeriesPrivate::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 = m_internalModel->categoryCount();
                 qreal y = max();
                 minX = qMin(minX, x);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 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)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.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 BARSERIES_H
             #define BARSERIES_H
-            #include <qseries.h>
+            #include <qabstractseries.h>
             #include <QStringList>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             class QBarSeriesPrivate;
             // Container for series
-            class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
+            class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QBarSeries(QBarCategories categories, QObject *parent = 0);
                 virtual ~QBarSeries();
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
                 void appendBarSet(QBarSet *set);            // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void appendBarSets(QList<QBarSet* > sets);
                 void removeBarSets(QList<QBarSet* > sets);
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
                 bool setModel(QAbstractItemModel *model);
                 void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category, Qt::MouseButtons button);
                 void selected();
                 void hovered(QBarSet* barset, bool status);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarseries_p.h +3 -3

             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             #include <QStringList>
-            #include <QSeries>
+            #include <QAbstractSeries>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Container for series
-            class QBarSeriesPrivate : public QSeriesPrivate
+            class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarCategories categories, QBarSeries *parent);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 bool setModel(QAbstractItemModel *model);
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 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();
                 BarChartModel& modelInternal();
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category, Qt::MouseButtons button);
                 void selected();
                 void updatedBars();
                 void restructuredBars();
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
                 BarChartModel *m_internalModel;     // TODO: this may change... current "2 models" situation doesn't look good.
                 QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 int m_mapFirst;
                 int m_mapCount;
                 Qt::Orientation m_mapOrientation;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/barchart/qpercentbarseries.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpercentbarseries.h"
             #include "qpercentbarseries_p.h"
             #include "percentbarchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPercentBarSeries
                 \brief part of QtCommercial chart API.
                 QPercentBarSeries represents a series of data shown as bars. Each bar of QBarSet is shown as percentage
                 of all bars in category. One QPercentBarSeries can contain multiple QBarSet data sets.
                 QBarSeries groups the data from sets to categories, which are defined by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QBarSeries
             */
             /*!
                 \fn virtual QSeriesType QPercentBarSeries::type() const
                 \brief Returns type of series.
-                \sa QSeries, QSeriesType
+                \sa QAbstractSeries, QSeriesType
             */
             /*!
                 Constructs empty QPercentBarSeries. Parameter \a categories defines the categories for chart.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QBarCategories categories, QObject *parent)
                 : QBarSeries(*new QPercentBarSeriesPrivate(categories,this), parent)
             {
             }
-            QSeries::QSeriesType QPercentBarSeries::type() const
+            QAbstractSeries::QSeriesType QPercentBarSeries::type() const
             {
-                return QSeries::SeriesTypePercentBar;
+                return QAbstractSeries::SeriesTypePercentBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPercentBarSeriesPrivate::QPercentBarSeriesPrivate(QBarCategories categories, QPercentBarSeries *q) : QBarSeriesPrivate(categories,q)
             {
             }
             void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QPercentBarSeries);
                 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 = q->categoryCount();
                 minX = qMin(minX, x);
                 maxX = qMax(maxX, x);
                 minY = 0;
                 maxY = 100;
                 tickXCount = x+1;
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,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
             {
                 Q_OBJECT
             public:
                 explicit QPercentBarSeries(QBarCategories categories, QObject *parent = 0);
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QPercentBarSeries)
                 Q_DISABLE_COPY(QPercentBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qstackedbarseries.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qstackedbarseries.h"
             #include "qstackedbarseries_p.h"
             #include "stackedbarchartitem_p.h"
             #include "barchartmodel_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QStackedBarSeries
                 \brief part of QtCommercial chart API.
                 QStackedBarSeries represents a series of data shown as bars. All bars in same category are
                 stacked on top of each other. One QStackedBarSeries can contain multiple QBarSet data sets.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QStringList.
                 \mainclass
                 \sa QBarSet, QPercentBarSeries, QBarSeries
             */
             /*!
                 \fn virtual QSeriesType QStackedBarSeries::type() const
                 \brief Returns type of series.
-                \sa QSeries, QSeriesType
+                \sa QSeriesType
             */
             /*!
                 Constructs empty QStackedBarSeries. Parameter \a categories defines the categories for chart.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QBarCategories categories, QObject *parent)
                 : QBarSeries(*new QStackedBarSeriesPrivate(categories,this), parent)
             {
             }
-            QSeries::QSeriesType QStackedBarSeries::type() const
+            QAbstractSeries::QSeriesType QStackedBarSeries::type() const
             {
-                return QSeries::SeriesTypeStackedBar;
+                return QAbstractSeries::SeriesTypeStackedBar;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QStackedBarSeriesPrivate::QStackedBarSeriesPrivate(QBarCategories categories, QStackedBarSeries *q) : QBarSeriesPrivate(categories,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 = m_internalModel->categoryCount();
                 qreal y = maxCategorySum();
                 minX = qMin(minX, x);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,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
             {
                 Q_OBJECT
             public:
                 explicit QStackedBarSeries(QBarCategories categories, QObject *parent = 0);
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
             private:
                 Q_DECLARE_PRIVATE(QStackedBarSeries)
                 Q_DISABLE_COPY(QStackedBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARSERIES_H

src/chartdataset.cpp +16 -16

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             #include "qchartaxis_p.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QChartAxis(this)),
                 m_axisY(new QChartAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
-            void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
+            void ChartDataSet::addSeries(QAbstractSeries* series, QChartAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axisX()->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 series->d_ptr->scaleDomain(*domain);
-                if(series->type() == QSeries::SeriesTypeBar || series->type() == QSeries::SeriesTypeStackedBar || series->type() == QSeries::SeriesTypePercentBar)
+                if(series->type() == QAbstractSeries::SeriesTypeBar
+                        || series->type() == QAbstractSeries::SeriesTypeStackedBar
+                        || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
-                if (series->type()== QSeries::SeriesTypePie &&  m_seriesAxisMap.count()==0)
+                if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
-                QMapIterator<int, QSeries*> i(m_indexSeriesMap);
+                QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 emit seriesAdded(series,domain);
             }
-            QChartAxis* ChartDataSet::removeSeries(QSeries* series)
+            QChartAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 QList<QChartAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=axisY()){
                         axis->setParent(0);
                     }
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
-                QList<QSeries*> series =  m_seriesAxisMap.keys();
+                QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QChartAxis*> axes;
-                foreach(QSeries* s , series) {
+                foreach(QAbstractSeries *s , series) {
                     QChartAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QChartAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
-            int ChartDataSet::seriesCount(QSeries::QSeriesType type)
+            int ChartDataSet::seriesCount(QAbstractSeries::QSeriesType type)
             {
                 int count=0;
-                QMapIterator<QSeries*, QChartAxis*> i(m_seriesAxisMap);
+                QMapIterator<QAbstractSeries*, QChartAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
-            int ChartDataSet::seriesIndex(QSeries *series)
+            int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
-                QMapIterator<int, QSeries*> i(m_indexSeriesMap);
+                QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
-            QChartAxis* ChartDataSet::axisY(QSeries* series) const
+            QChartAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
-            Domain* ChartDataSet::domain(QSeries* series) const
+            Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QChartAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QChartAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
             	 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
             	 	while (i.hasNext()) {
             	        i.next();
             	        i.value()->move(dx,dy,size);
             	    }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +13 -13

             /****************************************************************************
             **
             ** 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 CHARTDATASET_P_H
             #define CHARTDATASET_P_H
-            #include "qseries.h"
+            #include "qabstractseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class QBarSeries;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
-                void addSeries(QSeries* series,QChartAxis *axisY = 0);
+                void addSeries(QAbstractSeries* series,QChartAxis *axisY = 0);
-                QChartAxis* removeSeries(QSeries* series);
+                QChartAxis* removeSeries(QAbstractSeries* series);
                 void removeAllSeries();
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(int dx,int dy,const QSizeF& size);
-                int seriesCount(QSeries::QSeriesType type);
+                int seriesCount(QAbstractSeries::QSeriesType type);
-                int seriesIndex(QSeries *series);
+                int seriesIndex(QAbstractSeries *series);
-                Domain* domain(QSeries* series) const;
+                Domain* domain(QAbstractSeries* series) const;
                 Domain* domain(QChartAxis* axis) const;
                 QChartAxis* axisX() const { return m_axisX; }
-                QChartAxis* axisY(QSeries* series = 0) const;
+                QChartAxis* axisY(QAbstractSeries *series = 0) const;
             Q_SIGNALS:
-                void seriesAdded(QSeries* series,Domain* domain);
+                void seriesAdded(QAbstractSeries* series, Domain* domain);
-                void seriesRemoved(QSeries* series);
+                void seriesRemoved(QAbstractSeries* series);
                 void axisAdded(QChartAxis* axis,Domain* domain);
                 void axisRemoved(QChartAxis* axis);
             private:
                 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
-                void calculateDomain(QSeries* series,Domain* domain);
+                void calculateDomain(QAbstractSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
-                QMap<QSeries*, QChartAxis*> m_seriesAxisMap;
+                QMap<QAbstractSeries *, QChartAxis *> m_seriesAxisMap;
-                QMap<QChartAxis*, Domain*> m_axisDomainMap;
+                QMap<QChartAxis*, Domain *> m_axisDomainMap;
-                QMap<int,QSeries*> m_indexSeriesMap;
+                QMap<int, QAbstractSeries *> m_indexSeriesMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartpresenter.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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "axis_p.h"
             #include "areachartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
             void ChartPresenter::setMinimumMarginWidth(Axis* axis, qreal width)
             {
                 switch(axis->axisType()){
                 case Axis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
                 case Axis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::setMinimumMarginHeight(Axis* axis, qreal height)
             {
                 switch(axis->axisType()){
                 case Axis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
                 case Axis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
                 item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 Axis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
-            void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
+            void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_chartItems.insert(series,item);
             }
-            void ChartPresenter::handleSeriesRemoved(QSeries* series)
+            void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
-                    if(series->type()==QSeries::SeriesTypeArea){
+                    if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
-                QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
+                QList<QChartAxis *> axisList = m_axisItems.uniqueKeys();
-                QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
+                QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
-                foreach(QChartAxis* axis, axisList) {
+                foreach(QChartAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
-                foreach(QSeries* series, seriesList) {
+                foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
                 }
             }
             void ChartPresenter::zoomIn()
             {
                 QRectF rect = chartGeometry();
                 rect.setWidth(rect.width()/2);
                 rect.setHeight(rect.height()/2);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
                 if(m_animator) {
                     QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
                     m_animator->setState(ChartAnimator::ZoomInState,point);
                 }
                 m_dataset->zoomInDomain(r,chartGeometry().size());
                 if(m_animator) {
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 if(m_animator)
                 {
                     m_animator->setState(ChartAnimator::ZoomOutState);
                 }
                 QSizeF size = chartGeometry().size();
                 QRectF rect = chartGeometry();
                 rect.translate(-m_chartMargins.topLeft());
                 m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
                 if(m_animator){
                     if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
                     if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
                     if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
                     if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
                 }
                 m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +5 -5

             /****************************************************************************
             **
             ** 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 CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "chartbackground_p.h" //TODO fix me
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
-            class QSeries;
+            class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class Axis;
             class ChartTheme;
             class ChartAnimator;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void scroll(int dx,int dy);
                 void setGeometry(const QRectF& rect);
                 QRectF chartGeometry() const { return m_chartRect; }
                 void setMinimumMarginHeight(Axis* axis, qreal height);
                 void setMinimumMarginWidth(Axis* axis, qreal width);
                 qreal minimumLeftMargin() const { return m_minLeftMargin; }
                 qreal minimumBottomMargin() const { return m_minBottomMargin; }
             public: //TODO: fix me
                 void resetAllElements();
                 void createChartBackgroundItem();
                 void createChartTitleItem();
                 QRectF margins() const { return m_chartMargins;}
             public Q_SLOTS:
-                void handleSeriesAdded(QSeries* series,Domain* domain);
+                void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
-                void handleSeriesRemoved(QSeries* series);
+                void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QChartAxis* axis,Domain* domain);
                 void handleAxisRemoved(QChartAxis* axis);
                 void updateLayout();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
-                QMap<QSeries*,Chart*> m_chartItems;
+                QMap<QAbstractSeries *, Chart *> m_chartItems;
-                QMap<QChartAxis*,Axis*> m_axisItems;
+                QMap<QChartAxis *, Axis *> m_axisItems;
                 QRectF m_rect;
                 QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 qreal m_minLeftMargin;
                 qreal m_minBottomMargin;
             public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme_p.h 0 -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 CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
-            class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarChartItem;
             class QBarSeries;
             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(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(QChartAxis *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_titleBrush;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 QPen m_gridLinePen;
                 bool m_force;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/legend/legendmarker.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 "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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            LegendMarker::LegendMarker(QSeries* series,QLegend *legend) : QGraphicsObject(legend),
+            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))
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
                 updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_textItem->setPen(pen);
                 updateLayout();
             }
             QPen LegendMarker::pen() const
             {
                 return m_textItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setLabel(const QString name)
             {
                 m_textItem->setText(name);
                 updateLayout();
             }
             void LegendMarker::setSize(const QSize& size)
             {
                 m_markerRect = QRectF(0,0,size.width(),size.height());
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::updateLayout()
             {
                 static const qreal margin = 2;
                 static const qreal space = 4;
                 const QRectF& textRect = m_textItem->boundingRect();
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
                 m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
                 m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 emit selected();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 QObject::connect(this, SIGNAL(selected()),barseries, SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(valueChanged()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(this, SIGNAL(selected()),pieslice, SIGNAL(selected()));
                 QObject::connect(pieslice, SIGNAL(changed()), 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()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
-                if(m_series->type()== QSeries::SeriesTypeScatter)
+                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 +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef LEGENDMARKER_P_H
             #define LEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSeries;
+            class QAbstractSeries;
             class QAreaSeries;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSlice;
             class QLegend;
             class QPieSeries;
             class LegendMarker : public QGraphicsObject
             {
                 Q_OBJECT
             public:
-                explicit LegendMarker(QSeries* m_series,QLegend *parent);
+                explicit LegendMarker(QAbstractSeries *m_series, QLegend *parent);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setSize(const QSize& size);
                 void setLabel(const QString label);
                 QString label() const;
-                QSeries* series() const { return m_series;}
+                QAbstractSeries *series() const { return m_series;}
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void updateLayout();
             protected:
                 // From QGraphicsObject
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void selected();
             public Q_SLOTS:
                 virtual void updated() = 0;
             protected:
-                QSeries* m_series;
+                QAbstractSeries *m_series;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
                 QLegend* m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
             };
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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);
             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

src/legend/qlegend.cpp +10 -10

             /****************************************************************************
              **
              ** 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 "qlegend.h"
             #include "qlegend_p.h"
-            #include "qseries.h"
+            #include "qabstractseries.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \class QLegend
              \brief part of QtCommercial chart API.
              QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
              series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
              handle the drawing manually.
              User isn't supposed to create or delete legend objects, but can reference it via QChart class.
              \mainclass
-             \sa QChart, QSeries
+             \sa QChart, QAbstractSeries
              */
             /*!
              \enum QLegend::Alignment
              This enum describes the possible position for legend inside chart.
              \value AlignmentTop
              \value AlignmentBottom
              \value AlignmentLeft
              \value AlignmentRight
              */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 setEnabled(false); // By default legend is disabled
                 setVisible(false);
-                QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QSeries*,Domain*)));
+                QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries *, Domain *)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries *,Domain*)));
-                QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QSeries*)));
+                QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries *)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries *)));
             }
             QLegend::~QLegend()
             {
             }
             /*!
              Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRect(boundingRect());
             }
             /*!
              Bounding rect of legend.
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
              Sets the \a alignment for legend. Legend tries to paint itself on the defined position in chart.
              \sa QLegend::Alignment
              */
             void QLegend::setAlignment(QLegend::Alignments alignment)
             {
                 if(d_ptr->m_alignment!=alignment && d_ptr->m_attachedToChart) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              Returns the preferred layout for legend
              */
             QLegend::Alignments QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             void QLegend::setOffset(const QPointF& point)
             {
                 d_ptr->setOffset(point.x(),point.y());
             }
             QPointF QLegend::offset() const
             {
                 return QPointF(d_ptr->m_offsetX,d_ptr->m_offsetY);
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible!=visible)
                 {
                     d_ptr->m_backgroundVisible=visible;
                     update();
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter,QLegend *q):
             q_ptr(q),
             m_presenter(presenter),
             m_markers(new QGraphicsItemGroup(q)),
             m_alignment(QLegend::AlignmentTop),
             m_offsetX(0),
             m_offsetY(0),
             m_minWidth(0),
             m_minHeight(0),
             m_width(0),
             m_height(0),
             m_attachedToChart(true),
             m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         if(m_width<=m_rect.width()) return;
                         if (x != m_offsetX) {
                             m_offsetX = qBound(qreal(0), x, m_width - m_rect.width());
                             m_markers->setPos(-m_offsetX,m_rect.top());
                         }
                         break;
                     }
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         if(m_height<=m_rect.height()) return;
                         if (y != m_offsetY) {
                             m_offsetY = qBound(qreal(0), y, m_height - m_rect.height());
                             m_markers->setPos(m_rect.left(),-m_offsetY);
                         }
                         break;
                     }
                 }
             }
             void QLegendPrivate::updateLayout()
             {
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             m_minWidth=qMax(m_minWidth,w);
                             m_minHeight=qMax(m_minHeight,rect.height());
                             m_width+=w;
                             point.setX(point.x() + w);
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point);
                             const QRectF& rect = item->boundingRect();
                             qreal h = rect.height();
                             m_minWidth=qMax(m_minWidth,rect.width());
                             m_minHeight=qMax(m_minHeight,h);
                             m_height+=h;
                             point.setY(point.y() + h);
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_presenter->updateLayout();
             }
-            void QLegendPrivate::handleSeriesAdded(QSeries *series, Domain *domain)
+            void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker , markers)
                     m_markers->addToGroup(marker);
-                if(series->type()==QSeries::SeriesTypePie)
+                if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
                     QObject::connect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
                 }
                 updateLayout();
             }
-            void QLegendPrivate::handleSeriesRemoved(QSeries *series)
+            void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
-                if(series->type()==QSeries::SeriesTypePie)
+                if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
                     QObject::disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleUpdateSeries()
             {
                 //TODO: reimplement to be optimal
-                QSeries* series = qobject_cast<QSeries *> (sender());
+                QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series,0);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h 0 -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$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
-            class QSeries;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 // We only support these alignments (for now)
                 enum Alignment {
                     AlignmentTop = Qt::AlignTop,
                     AlignmentBottom = Qt::AlignBottom,
                     AlignmentLeft = Qt::AlignLeft,
                     AlignmentRight = Qt::AlignRight
                 };
                 Q_DECLARE_FLAGS(Alignments, Alignment)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setAlignment(QLegend::Alignments alignment);
                 QLegend::Alignments alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 qreal minWidth() const;
                 qreal minHeight() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setOffset(const QPointF& point);
                 QPointF offset() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend);
                 friend class LegendScroller;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +3 -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 QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
+            class QAbstractSeries;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *chart,QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
                 void updateLayout();
             public Q_SLOTS:
-                void handleSeriesAdded(QSeries *series, Domain *domain);
+                void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
-                void handleSeriesRemoved(QSeries *series);
+                void handleSeriesRemoved(QAbstractSeries *series);
                 void handleUpdateSeries(); //TODO remove this function
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 QGraphicsItemGroup* m_markers;
                 QLegend::Alignments m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QRectF m_rect;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minWidth;
                 qreal m_minHeight;
                 qreal m_width;
                 qreal m_height;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
             friend class QLegend;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "linechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QLineSeries* series = new QLineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
-                \sa QSeries, QSeriesType
+                \sa QAbstractSeries, QSeriesType
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QLineSeries::QLineSeries(QObject *parent) : QXYSeries(*new QLineSeriesPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QLineSeries::QLineSeries(QLineSeriesPrivate &d,QObject *parent) : QXYSeries (d,parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
             }
-            QSeries::QSeriesType QLineSeries::type() const
+            QAbstractSeries::QSeriesType QLineSeries::type() const
             {
-                return QSeries::SeriesTypeLine;
+                return QAbstractSeries::SeriesTypeLine;
             }
             /*
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.d_func()->m_x.size() == series.d_func()->m_y.size());
                 int size = series.d_func()->m_x.size();
                 for (int i=0; i<size; i++) {
                     debug.nospace() << "(" << series.d_func()->m_x.at(i) << ','<< series.d_func()->m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             */
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* q):QXYSeriesPrivate(q)
             {
             };
             Chart* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QLineSeries);
                 LineChartItem* line = new LineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(line);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return line;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.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 QLINESERIES_H
             #define QLINESERIES_H
             #include <qchartglobal.h>
             #include <qxyseries.h>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
             public:
                 explicit QLineSeries(QObject *parent = 0);
                 ~QLineSeries();
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
             protected:
                 QLineSeries(QLineSeriesPrivate &d,QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QLineSeries);
                 Q_DISABLE_COPY(QLineSeries);
                 friend class LineChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/qpieseries.cpp +5 -5

             /****************************************************************************
             **
             ** 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 "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
-                QSeries(*new QPieSeriesPrivate(this),parent)
+                QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
-            QSeries::QSeriesType QPieSeries::type() const
+            QAbstractSeries::QSeriesType QPieSeries::type() const
             {
-                return QSeries::SeriesTypePie;
+                return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 append(slices);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                     connect(s, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 }
                 emit added(slices);
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QPieSlice* slice)
             {
                 append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(index <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                 connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 0;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeHorPos, relativePosition, 1.0))
                     emit piePositionChanged();
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeVerPos, relativePosition, 1.0))
                     emit piePositionChanged();
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeSize, relativeSize, 1.0))
                     emit pieSizeChanged();
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieStartAngle, angle, d->m_pieEndAngle))
                     d->updateDerivativeData();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieEndAngle, angle, 360.0, d->m_pieStartAngle))
                     d->updateDerivativeData();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice, Qt::MouseButtons buttons)
                 This signal is emitted when a \a slice has been clicked with mouse \a buttons.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices has been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices has been removed from the series.
                 \sa remove(), clear()
             */
             /*!
                 \fn void QPieSeries::piePositionChanged()
                 This signal is emitted when pie position has changed.
                 \sa verticalPosition(), setVerticalPosition(), horizontalPosition(), setHorizontalPosition()
             */
             /*!
                 \fn void QPieSeries::pieSizeChanged()
                 This signal is emitted when pie size has changed.
                 \sa pieSize(), setPieSize()
             */
             /*!
                  \fn bool QPieSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(d->m_model)
                 {
                     disconnect(d->m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     d->m_model = model;
                     return true;
                 }
                 else
                 {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
                  Sets column/row specified by \a modelValuesLine to be used as a list of pie slice values for the pie.
                  Parameter \a modelValuesLine indicates the column/row where the values for the pie slices are located in the model.
                  Parameter \a modelLabelsLine indicates the column/row where the labels for the pie slices are located in the model.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
                 // connect the signals
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial slices set
                 if (d->m_mapOrientation == Qt::Vertical) {
                     for (int i = 0; i < d->m_model->rowCount(); i++)
                         append(d->m_model->data(d->m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
                 } else {
                     for (int i = 0; i < d->m_model->columnCount(); i++)
                         append(d->m_model->data(d->m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent)
+            QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
-                :QSeriesPrivate(parent),
+                QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_mapValues(0),
                 m_mapLabels(0),
                 m_mapOrientation(Qt::Horizontal)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_sum = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate sum of all slices
                 foreach (QPieSlice* s, m_slices)
                     m_sum += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_sum;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     PieSliceData::data(s).emitChangedSignal(s);
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice, buttons);
             }
             void QPieSeriesPrivate::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverEnter(slice);
             }
             void QPieSeriesPrivate::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverLeave(slice);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     if (topLeft.column() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.column() == m_mapLabels)
                         m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     if (topLeft.row() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.row() == m_mapLabels)
                         m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 q->insert(start, newSlice);
             }
             void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 q->remove(m_slices.at(start));
             }
             bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)
             {
                 // Remove rounding errors
                 qreal roundedValue = newValue;
                 if (qFuzzyIsNull(min) && qFuzzyIsNull(newValue))
                     roundedValue = 0.0;
                 else if (qFuzzyCompare(newValue, max))
                     roundedValue = max;
                 else if (qFuzzyCompare(newValue, min))
                     roundedValue = min;
                 // Check if the position is valid after removing the rounding errors
                 if (roundedValue < min || roundedValue > max) {
                     qWarning("QPieSeries: Illegal value");
                     return false;
                 }
                 if (!qFuzzyIsNull(value - roundedValue)) {
                     value = roundedValue;
                     return true;
                 }
                 // The change was so small it is considered a rounding error
                 return false;
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
             #ifndef QT_NO_DEBUG
                 qWarning() << __FILE__<<__FUNCTION__<<"not implemented";
             #endif
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.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$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
-            #include <qseries.h>
+            #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
-            class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
+            class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
                 Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
                 Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
                 Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
                 Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 // slice setters
                 void append(QPieSlice* slice);
                 void append(QList<QPieSlice*> slices);
                 void insert(int index, QPieSlice* slice);
                 void replace(QList<QPieSlice*> slices);
                 void remove(QPieSlice* slice);
                 void clear();
                 // slice getters
                 QList<QPieSlice*> slices() const;
                 // calculated data
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
                 // pie customization
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 // convenience function
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* append(qreal value, QString name);
                 void setLabelsVisible(bool visible = true);
                 // data from model
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
             Q_SIGNALS:
                 void clicked(QPieSlice* slice, Qt::MouseButtons buttons);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void piePositionChanged();
                 void pieSizeChanged();
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseries_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$
             **
             ****************************************************************************/
             #ifndef QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QPieSeriesPrivate : public QSeriesPrivate
+            class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 void updateDerivativeData();
             public Q_SLOTS:
                 void sliceChanged();
                 void sliceClicked(Qt::MouseButtons buttons);
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 bool setRealValue(qreal &value, qreal newValue, qreal max, qreal min = 0.0);
             public:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
                 // model map
                 int m_mapValues;
                 int m_mapLabels;
                 Qt::Orientation m_mapOrientation;
             private:
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

src/qabstractseries.cpp ~~src/qseries.cpp~~ renamed +17 -17

             /****************************************************************************
             **
             ** 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 "qseries.h"
+            #include "qabstractseries.h"
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
-                \class QSeries
+                \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
-                \enum QSeries::QSeriesType
+                \enum QAbstractSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
-                \fn QSeriesType QSeries::type() const
+                \fn QSeriesType QAbstractSeries::type() const
                 \brief The type of the series.
             */
             /*!
-                \fn bool QSeries::setModel(QAbstractItemModel *model)
+                \fn bool QAbstractSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
-                \property QSeries::name
+                \property QAbstractSeries::name
                 \brief name of the series property
             */
             /*!
-                \fn void QSeries::setName(const QString& name)
+                \fn void QAbstractSeries::setName(const QString& name)
                 \brief Sets a \a name for the series.
                 The name of a series is shown in the legend for QXYSeries.
                 \sa QChart::setTitle()
                 \sa QPieSlice::setLabel()
                 \sa QBarSet::setName()
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
-            QSeries::QSeries(QSeriesPrivate &d, QObject *parent) :
+            QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
-            QSeries::~QSeries()
+            QAbstractSeries::~QAbstractSeries()
             {
             }
             /*!
                 \brief Returns the pointer to the model that is used as the series data source
             */
-            QAbstractItemModel* QSeries::model() const
+            QAbstractItemModel* QAbstractSeries::model() const
             {
                 return d_ptr->m_model;
             }
-            void QSeries::setName(const QString& name)
+            void QAbstractSeries::setName(const QString& name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 \brief Returns the name of the series.
                 \sa setName()
             */
-            QString QSeries::name() const
+            QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
-            QSeriesPrivate::QSeriesPrivate(QSeries* q): q_ptr(q),m_model(0)
+            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q): q_ptr(q),m_model(0)
             {
             }
-            QSeriesPrivate::~QSeriesPrivate()
+            QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
-            #include "moc_qseries.cpp"
+            #include "moc_qabstractseries.cpp"
-            #include "moc_qseries_p.cpp"
+            #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries.h ~~src/qseries.h~~ renamed +7 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
-            #ifndef QSERIES_H
+            #ifndef QABSTRACTSERIES_H
-            #define QSERIES_H
+            #define QABSTRACTSERIES_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSeriesPrivate;
+            class QAbstractSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
+            class QTCOMMERCIALCHART_EXPORT QAbstractSeries : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName)
                 Q_ENUMS(QSeriesType)
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
-                QSeries(QSeriesPrivate &d, QObject *parent = 0);
+                QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent = 0);
             public:
-                ~QSeries();
+                ~QAbstractSeries();
                 virtual QSeriesType type() const = 0;
                 virtual bool setModel(QAbstractItemModel* model) = 0;
                 QAbstractItemModel* model() const;
                 void setName(const QString& name);
                 QString name() const;
             protected:
-                QScopedPointer<QSeriesPrivate> d_ptr;
+                QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qabstractseries_p.h ~~src/qseries_p.h~~ renamed +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$
             **
             ****************************************************************************/
             //  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 QSERIES_P_H
+            #ifndef QABSTRACTSERIES_P_H
-            #define QSERIES_P_H
+            #define QABSTRACTSERIES_P_H
-            #include "qseries.h"
+            #include "qabstractseries.h"
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class ChartPresenter;
             class Chart;
             class LegendMarker;
             class QLegend;
-            class QSeriesPrivate : public QObject
+            class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
-                QSeriesPrivate(QSeries *q);
+                QAbstractSeriesPrivate(QAbstractSeries *q);
-                ~QSeriesPrivate();
+                ~QAbstractSeriesPrivate();
                 virtual void scaleDomain(Domain& domain) = 0;
                 virtual Chart* createGraphics(ChartPresenter* presenter) = 0;
                 virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
             protected:
-                QSeries *q_ptr;
+                QAbstractSeries *q_ptr;
                 QAbstractItemModel *m_model;
                 QString m_name;
-                friend class QSeries;
+                friend class QAbstractSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchart.cpp +5 -5

             /****************************************************************************
             **
             ** 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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of QChartSeries and other chart related objects like
              QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
             }
             /*!
              Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              */
-            void QChart::addSeries(QSeries* series, QChartAxis* axisY)
+            void QChart::addSeries(QAbstractSeries *series, QChartAxis *axisY)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series, axisY);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
-            void QChart::removeSeries(QSeries* series)
+            void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
                 return (d_ptr->m_presenter->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setPen(pen);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
                 return d_ptr->m_presenter->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setText(title);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 //TODO: refactor me
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->text();
                 else
                     return QString();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setFont(font);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->font();
                 else
                     return QFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setBrush(brush);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_titleItem) return QBrush();
                 return d_ptr->m_presenter->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa theme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setTheme()
              */
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn();
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut();
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QChartAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the \a series
              If no \a series is provided then default Y axis of the chart is returned.
              */
-            QChartAxis* QChart::axisY(QSeries* series) const
+            QChartAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart to the left by the distance between two x axis ticks
              */
             void QChart::scrollLeft()
             {
                 d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart to the right by the distance between two x axis ticks
              */
             void QChart::scrollRight()
             {
                 d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart up by the distance between two y axis ticks
              */
             void QChart::scrollUp()
             {
                 d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart down by the distance between two y axis ticks
              */
             void QChart::scrollDown()
             {
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Sets the chart background visibility state to \a visible
              */
             void QChart::setBackgroundVisible(bool visible)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             /*!
                 Returns the chart's background visibility state
              */
             bool QChart::isBackgroundVisible() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return false;
                 return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
-                QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_presenter,SLOT(handleSeriesAdded(QSeries*,Domain*)));
+                QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries *, Domain *)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries *, Domain *)));
-                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_presenter,SLOT(handleSeriesRemoved(QSeries*)));
+                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries *)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries *)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),m_presenter,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +5 -5

             /****************************************************************************
             **
             ** 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 QCHART_H
             #define QCHART_H
-            #include <QSeries>
+            #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSeries;
+            class QAbstractSeries;
             class QChartAxis;
             class QLegend;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
             public:
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
-                void addSeries(QSeries *series, QChartAxis *axisY = 0);
+                void addSeries(QAbstractSeries *series, QChartAxis *axisY = 0);
-                void removeSeries(QSeries *series);
+                void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF &rect);
                 void zoomOut();
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
                 QChartAxis* axisX() const;
-                QChartAxis* axisY(QSeries* series = 0) const;
+                QChartAxis* axisY(QAbstractSeries* series = 0) const;
                 QLegend* legend() const;
                 QRectF margins() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class ChartPresenter;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/qchartview.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 QCHARTVIEW_H
             #define QCHARTVIEW_H
             #include <QChartAxis>
-            #include <QSeries>
+            #include <QAbstractSeries>
             #include <QChart>
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             struct QChartViewPrivate;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
                 Q_OBJECT
             public:
                 enum  RubberBand{
                     NoRubberBand = 0x0,
                     VerticalRubberBand = 0x1,
                     HorizonalRubberBand = 0x2,
                     RectangleRubberBand = 0x3
                 };
                 Q_DECLARE_FLAGS(RubberBands, RubberBand)
                 explicit QChartView(QChart *chart,QWidget *parent = 0);
                 ~QChartView();
                 void setRubberBand(const RubberBands& rubberBands);
                 RubberBands rubberBand() const;
                 QChart* chart() const;
             protected:
                 void resizeEvent(QResizeEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
             protected:
                 QScopedPointer<QChartViewPrivate> d_ptr;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/scatterseries/qscatterseries.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "scatterchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
-                \sa QSeries, QSeriesType
+                \sa QAbstractSeries, QSeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
             }
-            QSeries::QSeriesType QScatterSeries::type() const
+            QAbstractSeries::QSeriesType QScatterSeries::type() const
             {
-                return QSeries::SeriesTypeScatter;
+                return QAbstractSeries::SeriesTypeScatter;
             }
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_shape;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
                 Q_D(QScatterSeries);
                 if (d->m_shape != shape) {
                     d->m_shape = shape;
                     emit d->updated();
                 }
             }
             /*!
                 Returns the size of the marker items.
             */
             qreal QScatterSeries::size() const
             {
                 Q_D(const QScatterSeries);
                 return d->m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 15.
             */
             void QScatterSeries::setSize(qreal size)
             {
                 Q_D(QScatterSeries);
                 if (!qFuzzyIsNull(d->m_size - size)) {
                     d->m_size = size;
                     emit d->updated();
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q):QXYSeriesPrivate(q),
                m_shape(QScatterSeries::MarkerShapeCircle),
                m_size(15.0)
             {
             };
             Chart* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(scatter);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.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 QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include <qchartglobal.h>
             #include <qxyseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
             public:
                 enum MarkerShape {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             public:
                 explicit QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
                 MarkerShape shape() const;
                 void setShape(MarkerShape shape);
                 qreal size() const;
                 void setSize(qreal size);
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries);
                 Q_DISABLE_COPY(QScatterSeries);
                 friend class ScatterChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/splinechart/qsplineseries.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 "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
             */
             /*!
               \fn QSeriesType QSplineSeries::type() const
               Returns the type of the series
               */
             /*!
               \fn QSeriesType QSplineSeries::controlPoint(int index) const
               Returns the control point specified by \a index
               */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
             }
-            QSeries::QSeriesType QSplineSeries::type() const
+            QAbstractSeries::QSeriesType QSplineSeries::type() const
             {
-                return QSeries::SeriesTypeSpline;
+                return QAbstractSeries::SeriesTypeSpline;
             }
             QPointF QSplineSeries::controlPoint(int index) const
             {
                 Q_D(const QSplineSeries);
                 return d->m_controlPoints[index];
             }
             void QSplineSeries::setModelMappingRange(int first, int count)
             {
                 Q_D(QSplineSeries);
                 QLineSeries::setModelMappingRange(first, count);
                 d->calculateControlPoints();
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
                 QObject::connect(this,SIGNAL(pointAdded(int)), this, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), this, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), this, SLOT(updateControlPoints()));
             };
             /*!
               \internal
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 // Based on http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit
                 // CPOL License
                 int n = q->count() - 1;
                 if (n == 1)
                 { // Special case: Bezier curve should be a straight line.
                     //            firstControlPoints = new Point[1];
                     // 3P1 = 2P0 + P3
                     m_controlPoints.append(QPointF((2 * q->x(0) + q->x(1)) / 3, (2 * q->y(0) + q->y(1)) / 3));
                     // P2 = 2P1  P0
                     m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - q->x(0), 2 * m_controlPoints[0].y() - q->y(0)));
                     return;
                 }
                 // Calculate first Bezier control points
                 // Right hand side vector
                 //  Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QList<qreal> rhs;
                 rhs.append(q->x(0) + 2 * q->x(1));
                 // Set right hand side X values
                 for (int i = 1; i < n - 1; ++i)
                     rhs.append(4 * q->x(i) + 2 * q->x(i + 1));
                 rhs.append((8 * q->x(n - 1) + q->x(n)) / 2.0);
                 // Get first control points X-values
                 QList<qreal> xControl = getFirstControlPoints(rhs);
                 rhs[0] = q->y(0) + 2 * q->y(1);
                 // Set right hand side Y values
                 for (int i = 1; i < n - 1; ++i)
                     rhs[i] = 4 * q->y(i) + 2 * q->y(i + 1);
                 rhs[n - 1] = (8 * q->y(n - 1) + q->y(n)) / 2.0;
                 // Get first control points Y-values
                 QList<qreal> yControl = getFirstControlPoints(rhs);
                 // Fill output arrays.
                 for (int i = 0; i < n; ++i) {
                     // First control point
                     m_controlPoints.append(QPointF(xControl[i], yControl[i]));
                     // Second control point
                     if (i < n - 1)
                         m_controlPoints.append(QPointF(2 * q->x(i + 1) - xControl[i + 1], 2 * q->y(i + 1) - yControl[i + 1]));
                     else
                         m_controlPoints.append(QPointF((q->x(n) + xControl[n - 1]) / 2, (q->y(n) + yControl[n - 1]) / 2));
                 }
             }
             /*!
               \internal
               */
             QList<qreal> QSplineSeriesPrivate::getFirstControlPoints(QList<qreal> rhs)
             {
                 QList<qreal> x; // Solution vector.
                 QList<qreal> tmp; // Temp workspace.
                 qreal b = 2.0;
                 x.append(rhs[0] / b);
                 tmp.append(0);
                 for (int i = 1; i < rhs.size(); i++) {
                     // Decomposition and forward substitution.
                     tmp.append(1 / b);
                     b = (i < rhs.size() - 1 ? 4.0 : 3.5) - tmp[i];
                     x.append((rhs[i] - x[i - 1]) / b);
                 }
                 for (int i = 1; i < rhs.size(); i++)
                     x[rhs.size() - i - 1] -= tmp[rhs.size() - i] * x[rhs.size() - i]; // Backsubstitution.
                 return x;
             }
             /*!
               \internal
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.clear();
                     calculateControlPoints();
                 }
             }
             /*//!
                  \fn bool QSplineSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
                  \sa setModelMapping(), setModelMappingRange()
              */
             //bool QSplineSeries::setModel(QAbstractItemModel* model)
             //{
             //    QXYSeries::setModel(model);
             ////    calculateControlPoints();
             //    return true;
             //}
             /*//!
                  \fn bool QSplineSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation parameter specifies whether the data
                  is in columns or in rows.
              */
             //void QSplineSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             //{
             //    QLineSeries::setModelMapping(modelX, modelY, orientation);
             ////    calculateControlPoints();
             //}
             /*!
                  \fn bool QSplineSeries::setModelMappingRange(int first, int count)
                  Allows limiting the model mapping.
                  Parameter \a first specifies which element of the model should be used as a first one of the series.
                  Parameter \a count specifies how many elements should be mapped. If count is not specified (defaults to -1)
                  then all the items following \a first item in a model are used.
                  \sa setModel(), setModelMapping()
              */
             Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(spline);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.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 QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include <qchartglobal.h>
             #include <qlineseries.h>
             #include <QList>
             #include <QPointF>
             #include <QtGlobal>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
             public:
                 explicit QSplineSeries(QObject *parent = 0);
-                QSeries::QSeriesType type() const;
+                QAbstractSeries::QSeriesType type() const;
                 QPointF controlPoint(int index) const;
                 void setModelMappingRange(int first, int count);
             private:
                 Q_DECLARE_PRIVATE(QSplineSeries);
                 Q_DISABLE_COPY(QSplineSeries);
                 friend class SplineChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/src.pro +3 -3

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             win32-msvc*: LIBS += User32.lib
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/charttheme.cpp \
                 $$PWD/domain.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
-                $$PWD/qseries.cpp \
+                $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chart.cpp \
                 $$PWD/scroller.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/charttheme_p.h \
                 $$PWD/domain_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chart_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
-                $$PWD/qseries_p.h
+                $$PWD/qabstractseries_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
-                $$PWD/qseries.h \
+                $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h
             include(animations/animations.pri)
             include(areachart/areachart.pri)
             include(axis/axis.pri)
             include(barchart/barchart.pri)
             include(legend/legend.pri)
             include(linechart/linechart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             include(xychart/xychart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += ../include .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             #qt public headers
             #this is very primitive and lame parser , TODO: make perl script insted
             !exists($$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal)
             {
                 system($$QMAKE_MKDIR $$CHART_BUILD_PUBLIC_HEADER_DIR)
                  win32:{
                     command = "echo $${LITERAL_HASH}include \"qchartglobal.h\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"qchartglobal.h\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }
                 system($$command)
             }
             for(file, PUBLIC_HEADERS) {
                 name = $$split(file,'/')
                 name = $$last(name)
                 class = "$$cat($$file)"
                 class = $$find(class,class)
                 !isEmpty(class){
                 class = $$split(class,QTCOMMERCIALCHART_EXPORT)
                 class = $$member(class,1)
                 class = $$split(class,' ')
                 class = $$replace(class,' ','')
                 class = $$member(class,0)
                 win32:{
                     command = "echo $${LITERAL_HASH}include \"$$name\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"$$name\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class
                 system($$command)
                 }
             }
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target public_headers
             install_build_public_headers.name = build_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = buld_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers \
             !win32-msvc*: {
                 # There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
                 # This is the case at least with shadow builds.
                 # http://qt-project.org/wiki/jom
                 chartversion.target = $$PWD/qchartversion_p.h
                 unix:{
                     chartversion.commands = @echo \
                         "const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" \\; \
                          const char *gitHead = \\\"`git rev-parse HEAD`\\\" \\; " \
                         > \
                         $$chartversion.target;
                 }else{
                     chartversion.commands = @echo \
                         "const char *buildTime = \"%date%_%time%\" ; \
                          const char *gitHead = \"unknown\" ; " \
                         > \
                         $$chartversion.target
                 }
                 chartversion.depends = $$HEADERS \
                     $$SOURCES
                 PRE_TARGETDEPS += $$PWD/qchartversion_p.h
                 QMAKE_CLEAN += $$PWD/qchartversion_p.h
                 QMAKE_EXTRA_TARGETS += chartversion
             }
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
                 QMAKE_CXXFLAGS += -Werror
             }

src/xychart/qxyseries.cpp +9 -10

             /****************************************************************************
             **
             ** 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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QXYSeries API.
             */
             /*!
                 \fn void QXYSeriesPrivate::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \fn int QXYSeries::mapFirst() const
                 Returns the index of the model's item that is used as a first one for the series.
                 \sa mapCount()
             */
             /*!
                 \fn int QXYSeries::mapCount() const
                 Returns the number of the items that are taken from the model.
                 If -1 it means all the items of the model following the first one are used.
                 \sa mapFirst()
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
-            QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent):QSeries(d,parent)
+            QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 d->m_x<<x;
                 d->m_y<<y;
                 emit d->pointAdded(d->m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 append(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     append(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 d->m_x[index] = x;
                 d->m_y[index] = y;
                 emit d->pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF &point)
             {
                 replace(point.x(),point.y());
             }
             /*!
               Removes first \a x value and related y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 if (index == -1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index =-1;
                 do {
                     index = d->m_x.indexOf(x,index+1);
                 } while (index !=-1 && d->m_y.at(index)!=y);
                 if (index==-1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 remove(point.x(),point.y());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 Q_D(QXYSeries);
                 d->m_x.clear();
                 d->m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return d->m_model->data(d->m_model->index(d->m_mapX, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_x.at(pos);
                 }
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return d->m_model->data(d->m_model->index(d->m_mapY, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_y.at(pos);
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical) {
                         // data is in a column. Return the number of mapped items if the model's column have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapLimited)
                             return qMin(d->m_mapCount, qMax(d->m_model->rowCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->rowCount() - d->m_mapFirst, 0);
                     } else {
                         // data is in a row. Return the number of mapped items if the model's row have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapLimited)
                             return qMin(d->m_mapCount, qMax(d->m_model->columnCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->columnCount() - d->m_mapFirst, 0);
                     }
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return d->m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 Q_D(QXYSeries);
                 QList<QPointF> data;
                 for (int i(0); i < d->m_x.count() && i < d->m_y.count(); i++)
                     data.append(QPointF(d->m_x.at(i), d->m_y.at(i)));
                 return data;
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns true if drawing the data points of the series is enabled.
             */
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 append(points);
                 return *this;
             }
             /*!
                \internal
              */
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 Q_D(QXYSeries);
                 if (d->m_mapOrientation == Qt::Vertical) {
                     if (topLeft.row() >= d->m_mapFirst && (!d->m_mapLimited || topLeft.row() < d->m_mapFirst + d->m_mapCount))
                         emit d->pointReplaced(topLeft.row() - d->m_mapFirst);
                 } else {
                     if (topLeft.column() >= d->m_mapFirst && (!d->m_mapLimited || topLeft.column() < d->m_mapFirst + d->m_mapCount))
                         emit d->pointReplaced(topLeft.column() - d->m_mapFirst);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAboutToBeAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it and update is needed
                         // check how many mapped items there is currently (before new items are added)
                         // if the number of items currently is equal the m_mapCount then some needs to be removed from xychartitem
                         // internal storage before new ones can be added
                         int itemsToRemove = qMin(count() - qMax(start - d->m_mapFirst, 0), end - start + 1);
                         if (d->m_mapCount == count()) {
                             for (int i = 0; i < itemsToRemove; i++)
                                 emit d->pointRemoved(qMin(end, count()) - i);
                         }
                     }
                 } else {
                     // map is not limited (it includes all the items starting from m_mapFirst till the end of model)
                     // nothing to do
                     //        emit pointAdded(qMax(start - m_mapFirst, 0));
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it
                         // update needed
                         if (count() > 0) {
                             int toBeAdded = qMin(d->m_mapCount - (start - d->m_mapFirst), end - start + 1);
                             for (int i = 0; i < toBeAdded; i++)
                                 if (start + i >= d->m_mapFirst)
                                     emit d->pointAdded(start + i);
                         }
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit d->pointAdded(start + i);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataAboutToBeRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 Q_D(QXYSeries);
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the removed data is in the mapped area or before it
                         // update needed
                         // check how many items need to be removed from the xychartitem storage
                         // the number equals the number of items that are removed and that lay before
                         // or in the mapped area. Items that lay beyond the map do not count
                         // the max is the current number of items in storage (count())
                         int itemsToRemove = qMin(count(), qMin(end, d->m_mapFirst + d->m_mapCount - 1) - start + 1);
                         for (int i = 0; i < itemsToRemove; i++)
                             emit d->pointRemoved(start);
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit d->pointRemoved(start);
                 }
             }
             /*!
                \internal
              */
             void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_D(QXYSeries);
                 // how many items there were before data was removed
                 //    int oldCount = count() - 1;
                 if (d->m_mapLimited) {
                     if (start >= d->m_mapFirst + d->m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // if the current items count in the whole model is bigger than the index of the last item
                         // that was removed than it means there are some extra items available
                         int removedItemsCount = qMin(count(), qMin(end, d->m_mapFirst + d->m_mapCount - 1) - start + 1);
                         int extraItemsAvailable = 0;
                         if (d->m_mapOrientation == Qt::Vertical) {
                             extraItemsAvailable = qMax(d->m_model->rowCount() + (end - start + 1) - qMax(end + 1, d->m_mapFirst + d->m_mapCount), 0);
                         } else {
                             extraItemsAvailable = qMax(d->m_model->columnCount() + (end - start + 1) - qMax(end + 1, d->m_mapFirst + d->m_mapCount), 0);
                         }
                         // if there are excess items available (below the mapped area) use them to repopulate mapped area
                         int toBeAdded = qMin(extraItemsAvailable, removedItemsCount);
                         for (int k = 0; k < toBeAdded; k++)
                             emit d->pointAdded(d->m_mapFirst + d->m_mapCount - removedItemsCount + k);
                     }
                 } else {
                     // data was removed from XYSeries interal storage. Nothing more to do
                 }
             }
             /*!
                  \fn bool QXYSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
                  \sa setModelMapping(), setModelMappingRange()
              */
             bool QXYSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QXYSeries);
                 // disconnect signals from old model
                 if (d->m_model) {
                     QObject::disconnect(d->m_model, 0, this, 0);
                     d->m_mapX = -1;
                     d->m_mapY = -1;
                     d->m_mapFirst = 0;
                     d->m_mapCount = 0;
                     d->m_mapLimited = false;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if (model) {
                     d->m_model = model;
                     return true;
                 } else {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation parameter specifies whether the data
                  is in columns or in rows.
                  \sa setModel(), setModelMappingRange()
              */
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 Q_D(QXYSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapX = modelX;
                 d->m_mapY = modelY;
                 d->m_mapFirst = 0;
                 d->m_mapOrientation = orientation;
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model,SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(d->m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model,SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(d->m_model,SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
             }
             /*!
                  \fn bool QXYSeries::setModelMappingRange(int first, int count)
                  Allows limiting the model mapping.
                  Parameter \a first specifies which element of the model should be used as a first one of the series.
                  Parameter \a count specifies how many elements should be mapped. If count is not specified (defaults to -1)
                  then all the items following \a first item in a model are used.
                  \sa setModel(), setModelMapping()
              */
             void QXYSeries::setModelMappingRange(int first, int count)
             {
                 Q_D(QXYSeries);
                 d->m_mapFirst = first;
                 if (count == 0) {
                     d->m_mapLimited = false;
                 } else {
                     d->m_mapCount = count;
                     d->m_mapLimited = true;
                 }
             }
             int QXYSeries::mapFirst() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapFirst;
             }
             int QXYSeries::mapCount() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapCount;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q): QSeriesPrivate(q),
+            QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) : QAbstractSeriesPrivate(q),
-            m_mapX(-1),
+                m_mapX(-1),
-            m_mapY(-1),
+                m_mapY(-1),
-            m_mapFirst(0),
+                m_mapFirst(0),
-            m_mapCount(0),
+                m_mapCount(0),
-            m_mapLimited(false),
+                m_mapLimited(false),
-            m_mapOrientation( Qt::Vertical),
+                m_mapOrientation( Qt::Vertical),
-            m_pointsVisible(false)
+                m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::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());
                 Q_Q(QXYSeries);
                 for (int i = 0; i < q->count(); i++)
                 {
                     qreal x = q->x(i);
                     qreal y = q->y(i);
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.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$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
-            #include <qseries.h>
+            #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
+            class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d,QObject *parent = 0);
                 ~QXYSeries();
             public:
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF &point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 bool setModel(QAbstractItemModel *model);
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 virtual void setModelMappingRange(int first, int count = 0);
                 int mapFirst() const;
                 int mapCount() const;
             private Q_SLOTS:
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAboutToBeAdded(QModelIndex parent, int start, int end);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataAboutToBeRemoved(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void selected();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries);
                 Q_DISABLE_COPY(QXYSeries);
                 friend class XYLegendMarker;
                 friend class XYChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries_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 QXYSERIES_P_H
             #define QXYSERIES_P_H
-            #include "qseries_p.h"
+            #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeries;
-            class QXYSeriesPrivate: public QSeriesPrivate
+            class QXYSeriesPrivate: public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QXYSeriesPrivate(QXYSeries* q);
                 void scaleDomain(Domain& domain);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
             Q_SIGNALS:
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 int m_mapX;
                 int m_mapY;
                 int m_mapFirst;
                 int m_mapCount;
                 bool m_mapLimited;
                 Qt::Orientation m_mapOrientation;
                 int tempItemsRemoved;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QXYSeries);
                 friend class QScatterSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/auto/chartdataset/tst_chartdataset.cpp +22 -22

             /****************************************************************************
             **
             ** 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 <qchartaxis.h>
             #include <qlineseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
-            Q_DECLARE_METATYPE(Domain*)
+            Q_DECLARE_METATYPE(Domain *)
-            Q_DECLARE_METATYPE(QChartAxis*)
+            Q_DECLARE_METATYPE(QChartAxis *)
-            Q_DECLARE_METATYPE(QSeries*)
+            Q_DECLARE_METATYPE(QAbstractSeries *)
-            Q_DECLARE_METATYPE(QLineSeries*)
+            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 removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
             	void axisY_data();
             	void axisY();
                 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();
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
             	qRegisterMetaType<QChartAxis*>();
             	qRegisterMetaType<QSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
             }
             void tst_ChartDataSet::cleanup()
             {
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	ChartDataSet dataSet;
             	QVERIFY2(dataSet.axisX(), "Missing axisX.");
             	QVERIFY2(dataSet.axisY(), "Missing axisY.");
             	//check if not dangling pointer
             	dataSet.axisX()->objectName();
             	dataSet.axisY()->objectName();
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(dataSet.seriesIndex(series),-1);
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QLineSeries*>("series0");
                 QTest::addColumn<QChartAxis*>("axis0");
                 QTest::addColumn<QLineSeries*>("series1");
                 QTest::addColumn<QChartAxis*>("axis1");
                 QTest::addColumn<QLineSeries*>("series2");
                 QTest::addColumn<QChartAxis*>("axis2");
                 QTest::addColumn<int>("axisCount");
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QChartAxis* axis0 = new QChartAxis(this);
                 QChartAxis* axis1 = new QChartAxis(this);
                 QChartAxis* axis2 = new QChartAxis(this);
             	QTest::newRow("default axis Y: series0,series1,series2") << series0 << (QChartAxis*)0 << series1 << (QChartAxis*)0  << series2 << (QChartAxis*)0 << 2;
             	QTest::newRow("default axis Y: series0, axis 0: series1,series2") << series0 << (QChartAxis*)0 << series1 << axis0 << series2 << axis0 << 3;
             	QTest::newRow("axis0: series0, axis1: series1, axis2: series2") << series0 << axis0 << series1 << axis1 << series2 << axis2 << 4;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
+                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
                 QCOMPARE(spy0.count(), axisCount);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 3);
                 QCOMPARE(spy3.count(), 0);
                 if(axis0==0) axis0 = dataSet.axisY();
                 if(axis1==0) axis1 = dataSet.axisY();
                 if(axis2==0) axis2 = dataSet.axisY();
                 QVERIFY(axis0 == dataSet.removeSeries(series0));
                 QVERIFY(axis1 == dataSet.removeSeries(series1));
                 QVERIFY(axis2 == dataSet.removeSeries(series2));
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
+                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), axisCount);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 QChartAxis* axis0 = new QChartAxis(this);
                 QChartAxis* axis1 = new QChartAxis(this);
                 QChartAxis* axis2 = new QChartAxis(this);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
+                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.removeAllSeries();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 4);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::axisY_data()
             {
                 QTest::addColumn<QChartAxis*>("axis0");
                 QTest::addColumn<QChartAxis*>("axis1");
                 QTest::addColumn<QChartAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QChartAxis*)0 << new QChartAxis() << new QChartAxis();
                 QTest::newRow("3 optional") << new QChartAxis() << new QChartAxis() << new QChartAxis();
             }
             void tst_ChartDataSet::axisY()
             {
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QChartAxis*, axis2);
                 ChartDataSet dataSet;
                 QChartAxis* defaultAxisY = dataSet.axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 dataSet.addSeries(series0,axis0);
                 QLineSeries* series1 = new QLineSeries();
                 dataSet.addSeries(series1,axis1);
                 QLineSeries* series2 = new QLineSeries();
                 dataSet.addSeries(series2,axis2);
                 if(!axis0) axis0=defaultAxisY ;
                 if(!axis1) axis1=defaultAxisY ;
                 if(!axis2) axis2=defaultAxisY ;
                 QVERIFY(dataSet.axisY(series0) == axis0);
                 QVERIFY(dataSet.axisY(series1) == axis1);
                 QVERIFY(dataSet.axisY(series2) == axis2);
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
+                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(dataSet.seriesCount(series0->type()),3);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 //TODO: rewrite this series_index_data to match better
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),-1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.removeSeries(series1);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),-1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.addSeries(series1, axis1);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.removeSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.removeSeries(series0);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.addSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),0);
                 dataSet.addSeries(series0);
                 QCOMPARE(dataSet.seriesIndex(series0),2);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
-                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
+                QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QVERIFY(dataSet.domain(axis0)==dataSet.domain(series0));
                 QVERIFY(dataSet.domain(axis1)==dataSet.domain(series1));
                 QVERIFY(dataSet.domain(axis2)==dataSet.domain(series2));
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = 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)));
                 dataSet.zoomInDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = 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)));
                 dataSet.zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(QLineSeries*, series0);
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
                 QFETCH(QChartAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = 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)));
                 dataSet.scrollDomain(10,10,QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

test/auto/qchart/tst_qchart.cpp +16 -16

             #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>
             QTCOMMERCIALCHART_USE_NAMESPACE
-            Q_DECLARE_METATYPE(QChartAxis*)
+            Q_DECLARE_METATYPE(QChartAxis *)
-            Q_DECLARE_METATYPE(QSeries*)
+            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 scrollDown_data();
                 void scrollDown();
                 void scrollLeft_data();
                 void scrollLeft();
                 void scrollRight_data();
                 void scrollRight();
                 void scrollUp_data();
                 void scrollUp();
                 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->scrollDown();
                 m_chart->scrollLeft();
                 m_chart->scrollRight();
                 m_chart->scrollUp();
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
-                QTest::addColumn<QSeries*>("series");
+                QTest::addColumn<QAbstractSeries *>("series");
-                QTest::addColumn<QChartAxis*>("axis");
+                QTest::addColumn<QChartAxis *>("axis");
-                QSeries* series0 = new QLineSeries(this);
+                QAbstractSeries* series0 = new QLineSeries(this);
-                QSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
+                QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
-                QSeries* series2 = new QScatterSeries(this);
+                QAbstractSeries* series2 = new QScatterSeries(this);
-                QSeries* series3 = new QSplineSeries(this);
+                QAbstractSeries* series3 = new QSplineSeries(this);
-                QSeries* series4 = new QPieSeries(this);
+                QAbstractSeries* series4 = new QPieSeries(this);
-                QSeries* series5 = new QBarSeries(QBarCategories(),this);
+                QAbstractSeries* series5 = new QBarSeries(QBarCategories(),this);
-                QSeries* series6 = new QPercentBarSeries(QBarCategories(),this);
+                QAbstractSeries* series6 = new QPercentBarSeries(QBarCategories(),this);
-                QSeries* series7 = new QStackedBarSeries(QBarCategories(),this);
+                QAbstractSeries* series7 = new QStackedBarSeries(QBarCategories(),this);
                 QChartAxis* axis = new QChartAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QChartAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
                 QTest::newRow("default axis: areaSeries") << series1 << (QChartAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
                 QTest::newRow("default axis: scatterSeries") << series2 << (QChartAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
                 QTest::newRow("default axis: splineSeries") << series3 << (QChartAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
                 QTest::newRow("default axis: pieSeries") << series4 << (QChartAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
                 QTest::newRow("default axis: barSeries") << series5 << (QChartAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
                 QTest::newRow("default axis: percentBarSeries") << series6 << (QChartAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
                 QTest::newRow("default axis: stackedBarSeries") << series7 << (QChartAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
-                QFETCH(QSeries*, series);
+                QFETCH(QAbstractSeries *, series);
-                QFETCH(QChartAxis*, axis);
+                QFETCH(QChartAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
             }
             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());
                 QChartAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
                 QTest::addColumn<QChartAxis*>("axis0");
                 QTest::addColumn<QChartAxis*>("axis1");
                 QTest::addColumn<QChartAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QChartAxis*)0 << new QChartAxis() << new QChartAxis();
                 QTest::newRow("3 optional") << new QChartAxis() << new QChartAxis() << new QChartAxis();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QChartAxis*, axis0);
                 QFETCH(QChartAxis*, axis1);
                 QFETCH(QChartAxis*, axis2);
                 QChartAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0, axis0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1, axis1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2, axis2);
                 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()
             {
                 QVERIFY(m_chart->legend());
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
             {QTest::addColumn<int>("seriesCount");
             QTest::newRow("0") << 0;
             QTest::newRow("-1") << -1;
                 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);
                 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);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
-                QFETCH(QSeries*, series);
+                QFETCH(QAbstractSeries *, series);
-                QFETCH(QChartAxis*, axis);
+                QFETCH(QChartAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
             }
             void tst_QChart::scrollDown_data()
             {
             }
             void tst_QChart::scrollDown()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollDown();
                 QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::scrollLeft_data()
             {
             }
             void tst_QChart::scrollLeft()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollLeft();
                 QVERIFY(m_chart->axisX()->min()<min);
             }
             void tst_QChart::scrollRight_data()
             {
             }
             void tst_QChart::scrollRight()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollRight();
                 QVERIFY(m_chart->axisX()->min()>min);
             }
             void tst_QChart::scrollUp_data()
             {
             }
             void tst_QChart::scrollUp()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollUp();
                 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()
             {
                 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()
             {
                 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();
                 QVERIFY(minX==m_chart->axisX()->min());
                 QVERIFY(maxX==m_chart->axisX()->max());
                 QVERIFY(minY==m_chart->axisY()->min());
                 QVERIFY(maxY==m_chart->axisY()->max());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

test/tablemodelchart/tablewidget.h 0 -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 TABLEWIDGET_H
             #define TABLEWIDGET_H
             #include <QtGui/QWidget>
             #include "qchartview.h"
             #include "qxyseries.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             class CustomTableModel;
             class QTableView;
             class QRadioButton;
             class QSpinBox;
-            //class QSeries;
             class TableWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 TableWidget(QWidget *parent = 0);
                 ~TableWidget();
                 public slots:
                 void addRowAbove();
                 void addRowBelow();
                 void removeRow();
                 void updateChartType(bool toggle);
                 private:
                 QChartView* m_chartView;
                 QChart* m_chart;
                 QXYSeries* m_series;
                 CustomTableModel* m_model;
                 QTableView* m_tableView;
                 QRadioButton* m_lineRadioButton;
                 QRadioButton* m_splineRadioButton;
                 QRadioButton* m_scatterRadioButton;
                 QRadioButton* m_pieRadioButton;
                 QRadioButton* m_areaRadioButton;
                 QRadioButton* m_barRadioButton;
                 QSpinBox* m_linesCountSpinBox;
             };
             #endif // TABLEWIDGET_H

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