HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r360:6630f89603b4

Rename QChartSeries to QSeries

Michal Klocek -

r360:6630f89603b4

parent child

Context file:

r360:6630f89603b4

Expand all files

example/presenterchart/chartview.h +1 -1

             #ifndef CHARTVIEW_H_
             #define CHARTVIEW_H_
             #include <qchartview.h>
             #include <QTimer>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class ChartView: public QChartView
             {
                 Q_OBJECT
             public:
                 ChartView(QWidget* parent=0);
                 virtual ~ChartView();
             public slots:
                 void handleTimeout();
             private:
                 QTimer m_timer;
-                QList<QChartSeries*> m_series;
+                QList<QSeries*> m_series;
                 int m_index;
             };
             #endif /* CHARTVIEW_H_ */

src/barchart/qbarseries.cpp +3 -3

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QBarCategory class.
                 \mainclass
                 \sa QBarCategory, QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
-                \fn virtual QChartSeriesType QBarSeries::type() const
+                \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
-                \sa QChartSeries, QChartSeriesType
+                \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::changed(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QBarSeries::floatingValuesEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::toolTipEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::separatorsEnabled(bool enabled)
                 \brief \internal \a enabled
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a category defines the categories for chart.
                 Takes ownership of \a category.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategory *category, QObject *parent)
-                : QChartSeries(parent)
+                : QSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::countSets()
             {
                 return mModel->countSets();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 Returns legend of series. Legend is a list of set names in series.
             */
             QList<QString> QBarSeries::legend()
             {
                 return mModel->legend();
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::label(int category)
             {
                 return mModel->label(category);
             }
             /*!
                 Enables or disables floating values depending on parameter \a enabled.
                 Floating values are bar values, that are displayed on top of each bar.
                 Calling without parameter \a enabled, enables the floating values
             */
             void QBarSeries::setFloatingValuesEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(clicked()),set,SIGNAL(toggleFloatingValues()));
                     }
                 } else {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(clicked()),set,SIGNAL(toggleFloatingValues()));
                     }
                 }
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 if (enabled) {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->countSets(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsEnabled(bool enabled)
             {
                 emit separatorsEnabled(enabled);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +3 -3

             #ifndef BARSERIES_H
             #define BARSERIES_H
-            #include "qchartseries.h"
+            #include "qseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
             // Container for series
-            class QTCOMMERCIALCHART_EXPORT QBarSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QBarCategory *category, QObject* parent=0);
-                virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeBar; }
+                virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int countSets();
                 int countCategories();
                 QList<QBarSet*> barSets();
                 QList<QString> legend();                    // Returns legend of series (ie. names of all sets in series)
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet *barsetAt(int index);
                 QString label(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             signals:
                 void changed(int index);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void floatingValuesEnabled(bool enabled);
                 void toolTipEnabled(bool enabled);
                 void separatorsEnabled(bool enabled);
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setFloatingValuesEnabled(bool enabled=true);    // enables floating values on top of bars
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 void setSeparatorsEnabled(bool enabled=true);        // enables separators between categories
             protected:
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qpercentbarseries.cpp +2 -2

             #include "qpercentbarseries.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 multible QBarSet data sets.
                 QBarSeries groups the data from sets to categories, which are defined by QBarCategory class.
                 \mainclass
                 \sa QBarCategory, QBarSet, QStackedBarSeries, QBarSeries
             */
             /*!
-                \fn virtual QChartSeriesType QPercentBarSeries::type() const
+                \fn virtual QSeriesType QPercentBarSeries::type() const
                 \brief Returns type of series.
-                \sa QChartSeries, QChartSeriesType
+                \sa QSeries, QSeriesType
             */
             /*!
                 Constructs empty QPercentBarSeries. Parameter \a category defines the categories for chart.
                 QPercentBarSeries is QObject which is a child of a \a parent.
             */
             QPercentBarSeries::QPercentBarSeries(QBarCategory *category, QObject *parent)
                 : QBarSeries(category, parent)
             {
             }
             #include "moc_qpercentbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qpercentbarseries.h +1 -1

             #ifndef PERCENTBARSERIES_H
             #define PERCENTBARSERIES_H
             #include "qbarseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QBarSeries
             {
                 Q_OBJECT
             public:
                 QPercentBarSeries(QBarCategory *category, QObject* parent=0);
-                virtual QChartSeriesType type() const { return QChartSeries::SeriesTypePercentBar; }
+                virtual QSeriesType type() const { return QSeries::SeriesTypePercentBar; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qstackedbarseries.cpp +2 -2

             #include "qstackedbarseries.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 multible QBarSet data sets.
                 QStackedBarSeries groups the data from sets to categories, which are defined by QBarCategory class.
                 \mainclass
                 \sa QBarCategory, QBarSet, QPercentBarSeries, QBarSeries
             */
             /*!
-                \fn virtual QChartSeriesType QStackedBarSeries::type() const
+                \fn virtual QSeriesType QStackedBarSeries::type() const
                 \brief Returns type of series.
-                \sa QChartSeries, QChartSeriesType
+                \sa QSeries, QSeriesType
             */
             /*!
                 Constructs empty QStackedBarSeries. Parameter \a category defines the categories for chart.
                 QStackedBarSeries is QObject which is a child of a \a parent.
             */
             QStackedBarSeries::QStackedBarSeries(QBarCategory *category, QObject *parent)
                 : QBarSeries(category, parent)
             {
             }
             #include "moc_qstackedbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qstackedbarseries.h +1 -1

             #ifndef STACKEDBARSERIES_H
             #define STACKEDBARSERIES_H
             #include "qbarseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QBarSeries
             {
                 Q_OBJECT
             public:
                 QStackedBarSeries(QBarCategory *category, QObject* parent=0);
-                virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeStackedBar; }
+                virtual QSeriesType type() const { return QSeries::SeriesTypeStackedBar; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARSERIES_H

src/chartdataset.cpp +15 -15

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.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()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
             	int i = m_domainMap.count(axisY);
             	if(i == 0){
             		return Domain();
             	}
             	i = i - m_domainIndex -1;
                 return m_domainMap.values(axisY).at(i);
             }
-            void ChartDataSet::addSeries(QChartSeries* series, QChartAxis *axisY)
+            void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this); // take ownership
                 clearDomains();
                 if(axisY==0) axisY = m_axisY;
                 axisY->setParent(this); // take ownership
-                QList<QChartSeries*>  seriesList = m_seriesMap.values(axisY);
+                QList<QSeries*>  seriesList = m_seriesMap.values(axisY);
                 QList<Domain> domainList = m_domainMap.values(axisY);
                 Q_ASSERT(domainList.size()<=1);
                 Domain domain;
                 if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
-                    case QChartSeries::SeriesTypeLine: {
+                    case QSeries::SeriesTypeLine: {
                         QLineSeries* xyseries = static_cast<QLineSeries*>(series);
                         for (int i = 0; i < xyseries->count(); i++)
                         {
                             qreal x = xyseries->x(i);
                             qreal y = xyseries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
-                    case QChartSeries::SeriesTypeBar: {
+                    case QSeries::SeriesTypeBar: {
                     qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->countCategories();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
-                    case QChartSeries::SeriesTypeStackedBar: {
+                    case QSeries::SeriesTypeStackedBar: {
                     qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->countCategories();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
-                    case QChartSeries::SeriesTypePercentBar: {
+                    case QSeries::SeriesTypePercentBar: {
                     qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->countCategories();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                         break;
                     }
-                    case QChartSeries::SeriesTypePie: {
+                    case QSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
-                    case QChartSeries::SeriesTypeScatter: {
+                    case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain.m_minX = qMin(domain.m_minX, point.x());
                             domain.m_maxX = qMax(domain.m_maxX, point.x());
                             domain.m_minY = qMin(domain.m_minY, point.y());
                             domain.m_maxY = qMax(domain.m_maxY, point.y());
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 if(!m_domainMap.contains(axisY))
                 {
                     emit axisAdded(axisY);
                     QObject::connect(axisY,SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
                     QObject::connect(axisY,SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
                     QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                 }
                 m_domainMap.replace(axisY,domain);
                 m_seriesMap.insert(axisY,series);
                 if(!m_axisXInitialized)
                 {
                     emit axisAdded(axisX());
                     QObject::connect(axisX(),SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
                     QObject::connect(axisX(),SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
                     QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                     m_axisXInitialized=true;
                 }
                 emit seriesAdded(series);
                 QStringList ylabels = createLabels(axisY,domain.m_minY,domain.m_maxY);
                 QStringList xlabels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisY,ylabels);
                 emit axisLabelsChanged(axisX(),xlabels);
                 emit seriesDomainChanged(series,domain);
             }
-            void ChartDataSet::removeSeries(QChartSeries* series)
+            void ChartDataSet::removeSeries(QSeries* series)
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         emit seriesRemoved(series);
                         m_seriesMap.remove(axis,series);
                         //remove axis if no longer there
                         if(!m_seriesMap.contains(axis)){
                             emit axisRemoved(axis);
                             m_domainMap.remove(axis);
                             if(axis != m_axisY)
                             delete axis;
                         }
                         series->setParent(0);
                         break;
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
-                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     for(int i =0 ; i < seriesList.size();i++ )
                     {
                         emit seriesRemoved(seriesList.at(i));
                         delete(seriesList.at(i));
                     }
                     m_seriesMap.remove(axis);
                     m_domainMap.remove(axis);
                     emit axisRemoved(axis);
                     if(axis != m_axisY) delete axis;
                     }
                 m_domainIndex=0;
             }
             bool ChartDataSet::nextDomain()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 Domain domain;
                 foreach (QChartAxis* axis , domainList) {
                     int i = m_domainMap.count(axis) - index -1;
                     Q_ASSERT(i>=0);
                     domain = m_domainMap.values(axis).at(i);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
-                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    QList<QSeries*> seriesList = m_seriesMap.values(axis);
-                    foreach(QChartSeries* series, seriesList) {
+                    foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     emit axisLabelsChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisX(),labels);
             }
             void ChartDataSet::clearDomains(int toIndex)
             {
                 Q_ASSERT(toIndex>=0);
                 m_domainIndex = toIndex;
                 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* key , keys)
                 {
                     QList<Domain> domains = m_domainMap.values(key);
                     m_domainMap.remove(key);
                     int i = domains.size() - toIndex - 1;
                     while(i--){
                         domains.removeFirst();
                     }
                     for(int j=domains.size()-1; j>=0 ;j--)
                         m_domainMap.insert(key,domains.at(j));
                 }
             }
             void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
             {
                 Q_ASSERT(rect.isValid());
                 Q_ASSERT(viewport.isValid());
                 clearDomains(m_domainIndex);
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 Domain domain;
                 foreach (QChartAxis* axis , domainList){
                     domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
-                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    QList<QSeries*> seriesList = m_seriesMap.values(axis);
-                    foreach(QChartSeries* series, seriesList){
+                    foreach(QSeries* series, seriesList){
                         emit seriesDomainChanged(series,domain);
                     }
                     emit axisLabelsChanged(axis,labels);
                     m_domainMap.insert(axis,domain);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisX(),labels);
                 m_domainIndex++;
             }
-            QChartAxis* ChartDataSet::axisY(QChartSeries* series) const
+            QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         return axis;
                     }
                 }
                 return 0;
             }
             QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
             {
                 Q_ASSERT(max>=min);
                 QStringList labels;
                 int ticks = axis->ticksCount()-1;
                 for(int i=0; i<= ticks; i++){
                     qreal value = min + (i * (max - min)/ ticks);
                     QString label = axis->axisTickLabel(value);
                     if(label.isEmpty()){
                         labels << QString::number(value);
                     }else{
                         labels << label;
                     }
                 }
                 return labels;
             }
             void ChartDataSet::handleMinChanged(qreal min)
             {
             }
             void ChartDataSet::handleMaxChanged(qreal max)
             {
             }
             void ChartDataSet::handleTickChanged(QChartAxis* axis)
             {
                 Domain domain = m_domainMap.value(axisY());
                 if(axis==axisX()){
                     QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
                     emit axisLabelsChanged(axis,labels);
                 }else{
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     emit axisLabelsChanged(axis,labels);
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +8 -8

             #ifndef CHARTDATASET_P_H_
             #define CHARTDATASET_P_H_
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
-                void addSeries(QChartSeries* series,QChartAxis *axisY = 0);
+                void addSeries(QSeries* series,QChartAxis *axisY = 0);
-                void removeSeries(QChartSeries* series);
+                void removeSeries(QSeries* series);
                 void removeAllSeries();
                 void addDomain(const QRectF& rect, const QRectF& viewport);
                 bool nextDomain();
                 bool previousDomain();
                 void clearDomains(int toIndex =0);
                 const Domain domain(QChartAxis *axisY) const;
                 int domainIndex() const {return m_domainIndex;}
                 void setDomain(int index);
                 QChartAxis* axisX() const { return m_axisX;};
-                QChartAxis* axisY(QChartSeries* series = 0) const;
+                QChartAxis* axisY(QSeries* series = 0) const;
             signals:
-                void seriesAdded(QChartSeries* series);
+                void seriesAdded(QSeries* series);
-                void seriesRemoved(QChartSeries* series);
+                void seriesRemoved(QSeries* series);
                 void axisAdded(QChartAxis* axis);
                 void axisRemoved(QChartAxis* axis);
                 void axisLabelsChanged(QChartAxis* axis, const QStringList& labels);
-                void seriesDomainChanged(QChartSeries* series,const Domain& domain);
+                void seriesDomainChanged(QSeries* series,const Domain& domain);
             private slots:
             	void handleMinChanged(qreal min);
             	void handleMaxChanged(qreal max);
             	void handleTickChanged(QChartAxis*);
             private:
                 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
             private:
                 QMultiMap<QChartAxis*, Domain> m_domainMap;
-                QMultiMap<QChartAxis*, QChartSeries*> m_seriesMap;
+                QMultiMap<QChartAxis*, QSeries*> m_seriesMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartpresenter.cpp +16 -16

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(0)
             {
             	createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
-                QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
+                QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*)),this,SLOT(handleSeriesAdded(QSeries*)));
-                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
+                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
-                QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QChartSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QChartSeries*,const Domain&)));
+                QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
-            void ChartPresenter::handleSeriesAdded(QChartSeries* series)
+            void ChartPresenter::handleSeriesAdded(QSeries* series)
             {
                 switch(series->type())
                 {
-                    case QChartSeries::SeriesTypeLine: {
+                    case QSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         LineChartItem* item;
                         if(m_options.testFlag(QChart::SeriesAnimations)){
                             item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         }else{
                             item = new LineChartItem(this,lineSeries,m_chart);
                         }
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
-                    case QChartSeries::SeriesTypeBar: {
+                    case QSeries::SeriesTypeBar: {
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         BarPresenter* item = new BarPresenter(barSeries,m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
-                    case QChartSeries::SeriesTypeStackedBar: {
+                    case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
-                    case QChartSeries::SeriesTypePercentBar: {
+                    case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
-                    case QChartSeries::SeriesTypeScatter: {
+                    case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(scatterPresenter, SIGNAL(clicked()), scatterSeries, SIGNAL(clicked()));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
-                    case QChartSeries::SeriesTypePie: {
+                    case QSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         // Hide all from background when there is only piechart
                         // TODO: refactor this ugly code... should be one setting for this
                         if (m_chartItems.count() == 0) {
                             m_chart->axisX()->setAxisVisible(false);
                             m_chart->axisY()->setAxisVisible(false);
                             m_chart->axisX()->setGridVisible(false);
                             m_chart->axisY()->setGridVisible(false);
                             m_chart->axisX()->setLabelsVisible(false);
                             m_chart->axisY()->setLabelsVisible(false);
                             m_chart->axisX()->setShadesVisible(false);
                             m_chart->axisY()->setShadesVisible(false);
                             m_chart->setChartBackgroundBrush(Qt::transparent);
                         }
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
-            void ChartPresenter::handleSeriesRemoved(QChartSeries* series)
+            void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
-            void ChartPresenter::handleSeriesChanged(QChartSeries* series)
+            void ChartPresenter::handleSeriesChanged(QSeries* series)
             {
                 //TODO:
             }
-            void ChartPresenter::handleSeriesDomainChanged(QChartSeries* series, const Domain& domain)
+            void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
-                QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
+                QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
-                    QList<QChartSeries*> seriesList = m_chartItems.uniqueKeys();
+                    QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
-                    foreach(QChartSeries* series, seriesList) {
+                    foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +6 -6

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
-            class QChartSeries;
+            class QSeries;
             class ChartDataSet;
             //class QChart;
             class Domain;
             class AxisItem;
             class ChartTheme;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues { BackgroundZValue = -1 , ShadesZValue, GridZValue,  AxisZValue , LineChartZValue };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 void setMargin(int margin);
                 int margin() const;
                 QRectF geometry() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
             private:
                 void createConnections();
             public slots:
-                void handleSeriesAdded(QChartSeries* series);
+                void handleSeriesAdded(QSeries* series);
-                void handleSeriesRemoved(QChartSeries* series);
+                void handleSeriesRemoved(QSeries* series);
                 void handleAxisAdded(QChartAxis* axis);
                 void handleAxisRemoved(QChartAxis* axis);
-                void handleSeriesDomainChanged(QChartSeries* series, const Domain& domain);
+                void handleSeriesDomainChanged(QSeries* series, const Domain& domain);
                 void handleAxisLabelsChanged(QChartAxis* axis, const QStringList& labels);
-                void handleSeriesChanged(QChartSeries* series);
+                void handleSeriesChanged(QSeries* series);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
-                QMap<QChartSeries*,ChartItem*> m_chartItems;
+                QMap<QSeries*,ChartItem*> m_chartItems;
                 QMap<QChartAxis*,AxisItem*> m_axisItems;
                 QChart* m_chart;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 int m_marginSize;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme.cpp +7 -7

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "scatterpresenter_p.h"
             #include "piepresenter_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
-            void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
+            void ChartTheme::decorate(ChartItem* item, QSeries* series,int count)
             {
                 switch(series->type())
                 {
-                    case QChartSeries::SeriesTypeLine: {
+                    case QSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
-                    case QChartSeries::SeriesTypeBar: {
+                    case QSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
-                    case QChartSeries::SeriesTypeStackedBar: {
+                    case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
-                    case QChartSeries::SeriesTypePercentBar: {
+                    case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
-                    case QChartSeries::SeriesTypeScatter: {
+                    case QSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
-                    case QChartSeries::SeriesTypePie: {
+                    case QSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->countSets(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +2 -2

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
-            class QChartSeries;
+            class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
             class ChartTheme
             {
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
-                void decorate(ChartItem* item, QChartSeries* series,int count);
+                void decorate(ChartItem* item, QSeries* series,int count);
                 void decorate(BarPresenter* item, QBarSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count);
                 void decorate(LineChartItem* item, QLineSeries*, int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis* axis,AxisItem* item);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/linechart/qlineseries.cpp +3 -3

             #include "qlineseries.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
                 To create line charts, users need to first QLineSeries object.
                 \snippet ../example/linechart/main.cpp 1
                 Populate with the data
                 \snippet ../example/linechart/main.cpp 2
                 Add created series objects to QChartView or QChart instance.
                 \snippet ../example/linechart/main.cpp 3
             */
             /*!
-                \fn virtual QChartSeriesType QLineSeries::type() const
+                \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
-                \sa QChartSeries, QChartSeriesType
+                \sa QSeries, QSeriesType
             */
             /*!
                \fn QPen QLineSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn bool  QLineSeries::isPointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QLineSeries::changed(int index)
                 \brief \internal \a index
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
-            QLineSeries::QLineSeries(QObject* parent):QChartSeries(parent),
+            QLineSeries::QLineSeries(QObject* parent):QSeries(parent),
             m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QLineSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QLineSeries::add(const QPointF& point)
             {
                 m_x<<point.x();
                 m_y<<point.y();
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QLineSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit changed(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QLineSeries::replace(const QPointF& point)
             {
                 int index = m_x.indexOf(point.x());
                 m_x[index]=point.x();
                 m_y[index]=point.y();
                 emit changed(index);
             }
             /*!
               Removes current \a x and y value.
             */
             void QLineSeries::remove(qreal x)
             {
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QLineSeries::remove(const QPointF& point)
             {
             }
             /*!
               Clears all the data.
             */
             void QLineSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QLineSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QLineSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QLineSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             /*!
                 Sets \a pen used for drawing given series..
             */
             void QLineSeries::setPen(const QPen& pen)
             {
                 m_pen=pen;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QLineSeries::setPointsVisible(bool visible)
             {
                 m_pointsVisible=visible;
             }
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
             	Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +5 -5

-            #ifndef QLINECHARTSERIES_H_
+            #ifndef QLINESERIES_H_
-            #define QLINECHARTSERIES_H_
+            #define QLINESERIES_H_
             #include "qchartglobal.h"
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QLineSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QLineSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QLineSeries(QObject* parent=0);
                 virtual ~QLineSeries();
             public: // from QChartSeries
-                virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeLine;}
+                virtual QSeriesType type() const { return QSeries::SeriesTypeLine;}
                 void add(qreal x, qreal y);
                 void add(const QPointF& point);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF& point);
                 void remove(qreal x);
                 void remove(const QPointF& point);
                 void clear();
                 void setPen(const QPen& pen);
                 QPen pen() const { return m_pen;}
                 void setPointsVisible(bool visible);
                 bool isPointsVisible() const {return m_pointsVisible;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QLineSeries series);
             signals:
                 void changed(int index);
             private:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/qpieseries.cpp +3 -3

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \enum QPieSeries::PiePosition
                 This enum describes pie position within its bounding rectangle
                 \value PiePositionMaximized
                 \value PiePositionTopLeft
                 \value PiePositionTopRight
                 \value PiePositionBottomLeft
                 \value PiePositionBottomRight
             */
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are 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 (span) is determined by that relative value.
                 By default the pie is defined as full but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Example on how to create a chart with pie series:
                 \snippet ../example/piechart/main.cpp 1
                 To help with the most common user intercation scenarions there some convenience functions. Specifically
                 exploding and higlighting:
                 \snippet ../example/piechart/main.cpp 2
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
-                QChartSeries(parent),
+                QSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized),
                 m_pieStartAngle(0),
                 m_pieAngleSpan(360)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
-            QChartSeries::QChartSeriesType QPieSeries::type() const
+            QSeries::QSeriesType QPieSeries::type() const
             {
-                return QChartSeries::SeriesTypePie;
+                return QSeries::SeriesTypePie;
             }
             /*!
                 \internal \a data
             */
             bool QPieSeries::setData(QList<qreal> data)
             {
                 // TODO: remove this function
                 QList<QPieSlice*> slices;
                 foreach (qreal value, data)
                     slices << new QPieSlice(value, QString::number(value));
                 replace(slices);
                 return true;
             }
             /*!
                 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();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                     changeSet.appendAdded(s);
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit changed(changeSet);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 ChangeSet changeSet;
                 changeSet.appendRemoved(slice);
                 emit changed(changeSet);
                 delete slice;
                 slice = NULL;
                 updateDerivativeData();
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, m_slices) {
                     changeSet.appendRemoved(s);
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the size \a factor of the pie. 1.0 is the default value.
                 Note that the pie will not grow beyond its absolute maximum size.
                 In practice its use is to make the pie appear smaller.
                 \sa sizeFactor()
             */
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor < 0.0)
                     return;
                 if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
                     emit sizeFactorChanged();
                 }
             }
             /*!
                 Gets the size factor of the pie.
                 \sa setSizeFactor()
             */
             qreal QPieSeries::sizeFactor() const
             {
                 return m_sizeFactor;
             }
             /*!
                 Sets the \a position of the pie within its bounding rectangle.
                 \sa PiePosition, position()
             */
             void QPieSeries::setPosition(PiePosition position)
             {
                 if (m_position != position) {
                     m_position = position;
                     emit positionChanged();
                 }
             }
             /*!
                 Gets the position of the pie within its bounding rectangle.
                 \sa PiePosition, setPosition()
             */
             QPieSeries::PiePosition QPieSeries::position() const
             {
                 return m_position;
             }
             /*!
                 Sets the \a startAngle and \a angleSpan of this series.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
             */
             void QPieSeries::setSpan(qreal startAngle, qreal angleSpan)
             {
                 if (startAngle >= 0 && startAngle < 360 &&
                     angleSpan > 0 && angleSpan <= 360) {
                     m_pieStartAngle = startAngle;
                     m_pieAngleSpan = angleSpan;
                     updateDerivativeData();
                 }
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Convenience method for exploding a slice when user clicks the pie. Set \a enable to true to
                 explode slices by clicking.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded(), QPieSlice::setExplodeDistance()
             */
             void QPieSeries::enableClickExplodes(bool enable)
             {
                 if (enable)
                     connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
                 else
                     disconnect(this, SLOT(toggleExploded(QPieSlice*)));
             }
             /*!
                 Convenience method for highlighting a slice when user hovers over the slice.
                 It changes the slice color to be lighter and shows the label of the slice.
                 Set \a enable to true to highlight a slice when user hovers on top of it.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded()
             */
             void QPieSeries::enableHoverHighlight(bool enable)
             {
                 if (enable) {
                     connect(this, SIGNAL(hoverEnter(QPieSlice*)), this, SLOT(highlightOn(QPieSlice*)));
                     connect(this, SIGNAL(hoverLeave(QPieSlice*)), this, SLOT(highlightOff(QPieSlice*)));
                 } else {
                     disconnect(this, SLOT(hoverEnter(QPieSlice*)));
                     disconnect(this, SLOT(hoverLeave(QPieSlice*)));
                 }
             }
             /*!
                 \fn void QPieSeries::changed(const QPieSeries::ChangeSet& changeSet)
                 This signal emitted when something has changed in the series.
                 The \a changeSet contains the details of which slices have been added, changed or removed.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \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::sizeFactorChanged()
                 This signal is emitted when size factor has been changed.
                 \sa sizeFactor(), setSizeFactor()
             */
             /*!
                 \fn void QPieSeries::positionChanged()
                 This signal is emitted when position of the pie has been changed.
                 \sa position(), setPosition()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 ChangeSet changeSet;
                 changeSet.appendChanged(slice);
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::toggleExploded(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 slice->setExploded(!slice->isExploded());
             }
             void QPieSeries::highlightOn(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().lighter();
                 slice->setBrush(c);
                 slice->setLabelVisible(true);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
                 slice->setLabelVisible(false);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
                 Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = m_pieAngleSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         changed = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 -3

             #ifndef PIESERIES_H
             #define PIESERIES_H
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #include <QBrush>
             #include <QSignalMapper>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice;
             class QPieSlice;
-            class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
                 class ChangeSet
                 {
                 public:
                     // TODO: these should not really be exposed to the public API
                     void appendAdded(QPieSlice* slice);
                     void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                     QList<QPieSlice*> added() const;
                     QList<QPieSlice*> changed() const;
                     QList<QPieSlice*> removed() const;
                     bool isEmpty() const;
                 private:
                     QList<QPieSlice*> m_added;
                     QList<QPieSlice*> m_changed;
                     QList<QPieSlice*> m_removed;
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
-                QChartSeriesType type() const;
+                QSeriesType type() const;
                 virtual bool setData(QList<qreal> data);  // TODO: remove this
             public:
                 void replace(QList<QPieSlice*> slices);
                 void add(QList<QPieSlice*> slices);
                 void add(QPieSlice* slice);
                 QPieSlice* add(qreal value, QString name);
                 void remove(QPieSlice* slice);
                 void clear();
                 int count() const;
                 QList<QPieSlice*> slices() const;
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const;
                 void setPosition(PiePosition position);
                 PiePosition position() const;
                 void setSpan(qreal startAngle, qreal angleSpan);
                 void setLabelsVisible(bool visible);
                 void enableClickExplodes(bool enable);
                 void enableHoverHighlight(bool enable);
                 // TODO: find slices?
                 // QList<QPieSlice*> findByValue(qreal value);
                 // ...
                 // TODO: sorting slices?
                 // void sort(QPieSeries::SortByValue|label|??)
                 // TODO: general graphics customization
                 // setDrawStyle(2d|3d)
                 // setDropShadows(bool)
             Q_SIGNALS:
                 void changed(const QPieSeries::ChangeSet& changeSet);
                 void clicked(QPieSlice* slice);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void sizeFactorChanged();
                 void positionChanged();
             private Q_SLOTS: // TODO: should be private and not visible in the interface at all
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void toggleExploded(QPieSlice* slice);
                 void highlightOn(QPieSlice* slice);
                 void highlightOff(QPieSlice* slice);
             private:
                 void updateDerivativeData();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class PiePresenter;
                 friend class PieSlice;
                 QList<QPieSlice*> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
                 qreal m_total;
                 qreal m_pieStartAngle;
                 qreal m_pieAngleSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/qchart.cpp +2 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
                 \value ChartThemeDefault
                 \value ChartThemeVanilla
                 \value ChartThemeIcy
                 \value ChartThemeGrayscale
                 \value ChartThemeScientific
             */
             /*!
                 \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),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
             }
             /*!
                 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(QChartSeries* series, QChartAxis* axisY)
+            void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 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(QChartSeries* series)
+            void QChart::removeSeries(QSeries* series)
             {
                 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()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the chart \a title. The description text that is rendered above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setPlainText(title);
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa setMargin()
             */
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             /*!
                 Sets the chart \a margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa margin()
             */
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_presenter->geometry();
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_presenter->geometry().center());
                     zoomIn(rect);
                 }
             }
             /*!
                 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;
                    QRectF r = rect.normalized();
                    int margin = m_presenter->margin();
                    r.translate(-margin, -margin);
                    m_dataset->addDomain(r,m_presenter->geometry());
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             /*!
                 Resets to the default view.
             */
             void QChart::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +4 -4

             #ifndef QCHART_H
             #define QCHART_H
             #include <qchartglobal.h>
-            #include <qchartseries.h>
+            #include <qseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
-            class QChartSeries;
+            class QSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific
                     //ChartThemeUnnamed1
                     /*! The default theme follows the GUI style of the Operating System */
                 };
                 enum  AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                     };
                     Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
-                void addSeries(QChartSeries* series, QChartAxis* axisY = 0);
+                void addSeries(QSeries* series, QChartAxis* axisY = 0);
-                void removeSeries(QChartSeries* series); //returns ownership , deletes axis if no series attached
+                void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsTextItem* m_titleItem;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/qchartview.cpp +2 -2

             #include "qchartview.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             /*!
                 \enum QChartView::RubberBandPolicy
                 This enum describes the different types of rubber bands that can be used for zoom rect selection
                 \value NoRubberBand
                 \value VerticalRubberBand
                 \value HorizonalRubberBand
                 \value RectangleRubberBand
             */
             /*!
                 \class QChartView
                 \brief Standalone charting widget.
                 QChartView is a standalone widget that can display charts. It does not require separate
                 QGraphicsScene to work. It manages the graphical representation of different types of
                 QChartSeries and other chart related objects like QChartAxis and QChartLegend. If you want to
                 display a chart in your existing QGraphicsScene, you can use the QChart class instead.
                 \sa QChart
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a chartView object which is a child of a\a parent.
             */
             QChartView::QChartView(QWidget *parent) :
             QGraphicsView(parent),
             m_scene(new QGraphicsScene(this)),
             m_chart(new QChart()),
             m_rubberBand(0),
             m_verticalRubberBand(false),
             m_horizonalRubberBand(false)
             {
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChartView::~QChartView()
             {
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             /*!
                 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).
                 \sa removeSeries(), removeAllSeries()
             */
-            void QChartView::addSeries(QChartSeries* series,QChartAxis *axisY)
+            void QChartView::addSeries(QSeries* series,QChartAxis *axisY)
             {
                 m_chart->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 QChartView::removeSeries(QChartSeries* series)
+            void QChartView::removeSeries(QSeries* series)
             {
                 m_chart->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 QChartView::removeAllSeries()
             {
                 m_chart->removeAllSeries();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChartView::zoomIn(const QRect& rect)
             {
                 m_chart->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
             */
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             /*!
                 Sets the chart \a title. A description text that is rendered above the chart.
             */
             void QChartView::setChartTitle(const QString& title)
             {
                 m_chart->setChartTitle(title);
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChartView::setChartTitleFont(const QFont& font)
             {
                 m_chart->setChartTitleFont(font);
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area of the QChartView widget.
             */
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
                 m_chart->setChartBackgroundBrush(brush);
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area of the QChartView widget.
             */
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
                 m_chart->setChartBackgroundPen(pen);
             }
             /*!
                 Sets the RubberBandPlicy to \a policy. Selected policy determines the way zooming is performed.
             */
             void QChartView::setRubberBandPolicy(const RubberBandPolicy policy)
             {
                 switch(policy) {
                     case VerticalRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = false;
                     break;
                     case HorizonalRubberBand:
                     m_verticalRubberBand = false;
                     m_horizonalRubberBand = true;
                     break;
                     case RectangleRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = true;
                     break;
                     case NoRubberBand:
                     default:
                     delete m_rubberBand;
                     m_rubberBand=0;
                     m_horizonalRubberBand = false;
                     m_verticalRubberBand = false;
                     return;
                 }
                 if(!m_rubberBand) {
                     m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     m_rubberBand->setEnabled(true);
                 }
             }
             /*!
                 Returns the RubberBandPolicy that is currently being used by the widget.
             */
             QChartView::RubberBandPolicy QChartView::rubberBandPolicy() const
             {
                 if(m_horizonalRubberBand && m_verticalRubberBand) return RectangleRubberBand;
                 if(m_horizonalRubberBand) return HorizonalRubberBand;
                 if(m_verticalRubberBand) return VerticalRubberBand;
                 return NoRubberBand;
             }
             /*!
                 If Left mouse button is pressed and the RubberBandPolicy is enabled the \a event is accepted and the rubber band is displayed on the screen allowing the user to select the zoom area.
                 If different mouse button is pressed and/or the RubberBandPolicy is disabled then the \a event is passed to QGraphicsView::mousePressEvent() implementation is called.
             */
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_rubberBandOrigin = event->pos();
                         m_rubberBand->setGeometry(QRect(m_rubberBandOrigin, QSize()));
                         m_rubberBand->show();
                         event->accept();
                     }
                 }
                 else {
                     QGraphicsView::mousePressEvent(event);
                 }
             }
             /*!
                 If RubberBand rectange specification has been initiated in pressEvent then \a event data is used to update RubberBand geometry.
                 In other case the defualt QGraphicsView::mouseMoveEvent implementation is called.
             */
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();
                     if(!m_verticalRubberBand) {
                         m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if(!m_horizonalRubberBand) {
                         m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     m_rubberBand->setGeometry(QRect(m_rubberBandOrigin.x(),m_rubberBandOrigin.y(), width,height).normalized());
                 }
                 else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             /*!
                 If left mouse button is release and RubberBand is enabled then \a event is accepted and the view is zoomed in to rect specified by RubberBand
                 If it is the right mouse button \a event then RubberBand is dissmissed and zoom is canceled.
             */
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_rubberBand) {
                     if (event->button() == Qt::LeftButton && m_rubberBand->isVisible()) {
                         m_rubberBand->hide();
                         QRect rect = m_rubberBand->geometry();
                         m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
                 }
                 else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             /*!
                 Pressing + and - keys performs zoomIn() and zoomOut() respectivly.
                 In other \a event is passed to the QGraphicsView::keyPressEvent() implementation
             */
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Plus:
                     zoomIn();
                     break;
                     case Qt::Key_Minus:
                     zoomOut();
                     break;
                     default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa QChart::ChartTheme, chartTheme()
             */
             void QChartView::setChartTheme(QChart::ChartTheme theme)
             {
                 m_chart->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa setChartTheme()
             */
             QChart::ChartTheme QChartView::chartTheme() const
             {
                 return m_chart->chartTheme();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChartView::axisX() const
             {
                 return m_chart->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChartView::axisY() const
             {
                 return m_chart->axisY();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChartView::setAnimationOptions(QChart::AnimationOptions options)
             {
                 m_chart->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChartView::animationOptions() const
             {
                 return m_chart->animationOptions();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +3 -3

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include "qchart.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
             public:
                 enum  RubberBandPolicy { NoRubberBand, VerticalRubberBand, HorizonalRubberBand, RectangleRubberBand };
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
-                void addSeries(QChartSeries* series,QChartAxis* axisY=0);// takes series ownership , takes axis ownership
+                void addSeries(QSeries* series,QChartAxis* axisY=0);// takes series ownership , takes axis ownership
-                void removeSeries(QChartSeries* series); //returns ownership , deletes axis if no series attached
+                void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 int margin() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomIn();
                 void zoomIn(const QRect& rect);
                 void zoomOut();
                 void setRubberBandPolicy(const RubberBandPolicy );
                 RubberBandPolicy rubberBandPolicy() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QPoint m_rubberBandOrigin;
                 QRubberBand* m_rubberBand;
                 bool m_verticalRubberBand;
                 bool m_horizonalRubberBand;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qseries.cpp ~~src/qchartseries.cpp~~ renamed +8 -8

-            #include "qchartseries.h"
+            #include "qseries.h"
             /*!
-                \class QChartSeries
+                \class QSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QScatterSeries
             */
             /*!
-                \enum QChartSeries::QChartSeriesType
+                \enum QSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
-                \fn QChartSeries::QChartSeries(QObject *parent)
+                \fn QSeries::QSeries(QObject *parent)
                 \brief Constructs ChartSeries object with \a parent.
             */
             /*!
-                \fn QChartSeries::~QChartSeries()
+                \fn QSeries::~QSeries()
                 \brief Virtual destructor for the chart series.
             */
             /*!
-                \fn QChartSeriesType QChartSeries::type() const
+                \fn QSeriesType QSeries::type() const
                 \brief The type of the series.
             */
             /*!
-                \fn bool QChartSeries::setModel(QAbstractItemModel *model)
+                \fn bool QSeries::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.
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            #include "moc_qchartseries.cpp"
+            #include "moc_qseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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

-            #ifndef QCHARTSERIES_H
+            #ifndef QSERIES_H
-            #define QCHARTSERIES_H
+            #define QSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QChartSeries : public QObject
+            class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
             {
                 Q_OBJECT
             public:
-                enum QChartSeriesType {
+                enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
-                QChartSeries(QObject *parent = 0) : QObject(parent) {}
+                QSeries(QObject *parent = 0) : QObject(parent) {}
             public:
-                virtual ~QChartSeries() {}
+                virtual ~QSeries() {}
-                virtual QChartSeriesType type() const = 0;
+                virtual QSeriesType type() const = 0;
                 // TODO
                 virtual bool setModel(QAbstractItemModel* /*model*/) { return false; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterseries/qscatterseries.cpp +1 -1

             #include "qscatterseries.h"
             #include "scatterseries_p.h"
             #include "qchart.h"
             /*!
                 \class QScatterSeries
                 \brief QtCommercial Chart series API for showing scatter series.
                 \mainclass
                 Example on how to create a chart with scatter series:
                 \snippet ../example/scatter/main.cpp 1
                 The example code would result the following:
                 \image scatter_example1.jpg
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeDefault
                 \value MarkerShapePoint
                 \value MarkerShapeX
                 \value MarkerShapeRectangle
                 \value MarkerShapeTiltedRectangle
                 \value MarkerShapeTriangle
                 \value MarkerShapeCircle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
             */
             /*!
                 \fn void QScatterSeries::clicked()
                 \brief TODO
             */
             /*!
                 \fn void QScatterSeries::changed()
                 \brief TODO
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QScatterSeriesPrivate::QScatterSeriesPrivate() :
                 m_data(QList<QPointF>()),
                 m_markerPen(QPen()),
                 m_markerBrush(QBrush()),
                 m_markerShape(QScatterSeries::MarkerShapeDefault)
             {
                 // Initialize pen color to invalid to use a theme color by default
                 m_markerPen.setColor(QColor::Invalid);
                 m_markerBrush.setColor(QColor::Invalid);
             }
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
-                QChartSeries(parent),
+                QSeries(parent),
                 d(new QScatterSeriesPrivate())
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             /*!
                 Add single data point with \a x and \a y coordinates to the series.
             */
             void QScatterSeries::add(qreal x, qreal y)
             {
                 d->m_data.append(QPointF(x, y));
                 emit changed();
             }
             /*!
                 Add single data point with \a value to the series.
             */
             void QScatterSeries::add(QPointF value)
             {
                 d->m_data.append(value);
                 emit changed();
             }
             /*!
                 Add list of \a points to the series.
             */
             void QScatterSeries::add(QList<QPointF> points)
             {
                 d->m_data.append(points);
                 emit changed();
             }
             /*!
                 Stream operator for adding a data point with \a value to the series.
                 \sa add()
                 For example:
                 \snippet ../example/scatter/main.cpp 3
             */
             QScatterSeries& QScatterSeries::operator << (const QPointF &value)
             {
                 d->m_data.append(value);
                 emit changed();
                 return *this;
             }
             /*!
                 Stream operator for adding a list of points to the series.
                 \sa add()
             */
             QScatterSeries& QScatterSeries::operator << (QList<QPointF> value)
             {
                 d->m_data.append(value);
                 emit changed();
                 return *this;
             }
             /*!
                 Replaces the data of the series with the given list of data \a points.
             */
             void QScatterSeries::setData(QList<QPointF> points)
             {
                 d->m_data = points;
                 emit changed();
             }
             /*!
                 Returns the current list of data points of the series.
             */
             QList<QPointF> QScatterSeries::data()
             {
                 return d->m_data;
             }
             /*!
                 Overrides the default pen used for drawing a marker item with a user defined \a pen. The
                 default pen is defined by chart theme setting.
                 For example:
                 \snippet ../example/scatter/main.cpp 5
                 Would present your scatter markers with an opaque, uglyish green outlines instead of the
                 beatiful markers defined by the chart's theme:
                 \image scatter_example_pen.jpg
                 \sa setBrush()
                 \sa QChart::setChartTheme()
             */
             void QScatterSeries::setPen(QPen pen)
             {
                 d->m_markerPen = pen;
             }
             /*!
                 Returns the pen used for drawing markers.
             */
             QPen QScatterSeries::pen()
             {
                 return d->m_markerPen;
             }
             /*!
                 Overrides the default brush of the marker items with a user defined \a brush. The default brush
                 is defined by chart theme setting.
                 For example:
                 \snippet ../example/scatter/main.cpp 4
                 Would fill your scatter markers with an opaque red color:
                 \image scatter_example_brush.jpg
                 \sa setPen()
                 \sa QChart::setChartTheme()
             */
             void QScatterSeries::setBrush(QBrush brush)
             {
                 d->m_markerBrush = brush;
             }
             /*!
                 Returns the brush used for drawing markers.
             */
             QBrush QScatterSeries::brush()
             {
                 return d->m_markerBrush;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
                 For example:
                 \snippet ../example/scatter/main.cpp 6
                 Would make your scatter marker items rectangle:
                 \image scatter_example_shape.jpg
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
                 d->m_markerShape = shape;
             }
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape()
             {
                 return (QScatterSeries::MarkerShape) d->m_markerShape;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +3 -3

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 enum MarkerShape {
                     // TODO: to be defined by the graphics design
                     // TODO: marker shapes: "x", star, rectangle, tilted rect, triangle, circle, dot
                     MarkerShapeDefault = 0,
                     MarkerShapePoint,
                     MarkerShapeX,
                     MarkerShapeRectangle,
                     MarkerShapeTiltedRectangle,
                     MarkerShapeTriangle,
                     MarkerShapeCircle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
-                QChartSeriesType type() const { return QChartSeries::SeriesTypeScatter; }
+                QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
                 void add(qreal x, qreal y);
                 void add(QPointF value);
                 void add(QList<QPointF> points);
                 void setData(QList<QPointF> points);
                 QScatterSeries& operator << (const QPointF &value);
                 QScatterSeries& operator << (QList<QPointF> points);
                 QList<QPointF> data();
                 //TODO: insert, replace, remove, clear...?
                 QPen pen();
                 void setPen(QPen pen);
                 QBrush brush();
                 void setBrush(QBrush brush);
                 MarkerShape shape();
                 void setShape(MarkerShape shape);
                 // TODO: marker size?
             Q_SIGNALS:
                 void clicked(/* TODO: parameters? */);
                 // TODO: move to PIMPL for simplicity or does the user ever need changed signals?
                 // TODO: more finegrained signaling for performance reasons
                 // (check QPieSeries implementation with change sets)
                 void changed();
             private:
                 Q_DECLARE_PRIVATE(QScatterSeries)
                 Q_DISABLE_COPY(QScatterSeries)
                 QScatterSeriesPrivate *const d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterseries/scatterseries_p.h +1 -1

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartglobal.h"
-            #include "qchartseries.h"
+            #include "qseries.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
             class QScatterSeriesPrivate
             {
             public:
                 QScatterSeriesPrivate();
             public:
                 QList<QPointF> m_data;
                 QPen m_markerPen;
                 QBrush m_markerBrush;
                 int m_markerShape;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIESPRIVATE_H

src/src.pro +9 -14

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
-            SOURCES += \
+            SOURCES += axisitem.cpp \
-                axisitem.cpp \
                 axisanimationitem.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartaxis.cpp \
-                qchartseries.cpp \
+                qchartview.cpp \
-                qchartview.cpp
+                qseries.cpp
-            PRIVATE_HEADERS += \
+            PRIVATE_HEADERS += axisitem_p.h \
-                axisitem_p.h \
                 axisanimationitem_p.h \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h
-            PUBLIC_HEADERS += \
+            PUBLIC_HEADERS += qchart.h \
-                qchart.h \
                 qchartaxis.h \
                 qchartglobal.h \
-                qchartseries.h \
+                qseries.h \
-                qchartview.h \
+                qchartview.h
             include(linechart/linechart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             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
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_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 = bild_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
+            QMAKE_EXTRA_COMPILERS += install_build_public_headers \
+                install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += 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

test/auto/chartdataset/tst_chartdataset.cpp +24 -25

             #include <QtTest/QtTest>
             #include <qchartaxis.h>
-            #include <qchartseries.h>
             #include <qlineseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain)
             Q_DECLARE_METATYPE(QChartAxis*)
-            Q_DECLARE_METATYPE(QChartSeries*)
+            Q_DECLARE_METATYPE(QSeries*)
             Q_DECLARE_METATYPE(QLineSeries*)
             class tst_ChartDataSet: public QObject {
             Q_OBJECT
             public slots:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private slots:
             	void chartdataset_data();
             	void chartdataset();
             	void addDomain_data();
             	void addDomain();
             	void addSeries_data();
             	void addSeries();
             	void axisY_data();
             	void axisY();
             	void clearDomains_data();
             	void clearDomains();
             	void domain_data();
             	void domain();
             	void nextpreviousDomain_data();
             	void nextpreviousDomain();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
             };
             void tst_ChartDataSet::initTestCase()
             {
             	qRegisterMetaType<Domain>("Domain");
             	qRegisterMetaType<QChartAxis*>();
-            	qRegisterMetaType<QChartSeries*>();
+            	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();
             	QVERIFY(dataSet.domain(dataSet.axisX())==Domain());
             	QVERIFY(dataSet.domain(dataSet.axisY())==Domain());
             	QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::addDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::addDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineSeries series;
             	series.add(0, 0);
             	series.add(1000, 1000);
             	dataSet.addSeries(&series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 2);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 1);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<int>("seriesCount");
             	QTest::addColumn<int>("axisYCount");
             	QTest::newRow("2 series, default axis") << 2 << 0;
             	QTest::newRow("2 series, 2 new axis") << 2 << 2;
             	QTest::newRow("2 series, 1 new axis") << 2 << 2;
             	QTest::newRow("3 series, 3 new axis") << 3 << 3;
             	QTest::newRow("3 series, 2 new axis") << 3 << 2;
             	QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::addSeries()
             {
             	QFETCH(int, seriesCount);
             	QFETCH(int, axisYCount);
             	ChartDataSet dataSet;
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	QList<QChartAxis*> axisList;
             	for (int i = 0; i < axisYCount; i++) {
             		QChartAxis* axis = new QChartAxis();
             		axisList << axis;
             	}
             	QList<QChartAxis*>::iterator iterator = axisList.begin();
             	for (int i = 0; i < seriesCount; i++) {
             		QChartAxis* axisY = 0;
             		QLineSeries* series = new QLineSeries();
             		if (iterator != axisList.end()) {
             			axisY = *iterator;
             			iterator++;
             		} else if (axisList.count() > 0) {
             			iterator--;
             			axisY = *iterator;
             			iterator++;
             		}
             		dataSet.addSeries(series, axisY);
             	}
             	//default axis
             	if (axisYCount == 0)
             		axisYCount+=2;
             	else
             	    axisYCount++;
             	QCOMPARE(spy0.count(), axisYCount);
             	QCOMPARE(spy1.count(), seriesCount*2);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), seriesCount);
             	QCOMPARE(spy4.count(), seriesCount);
             	QCOMPARE(spy5.count(), 0);
             	QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::axisY_data()
             {
             	QTest::addColumn<QChartAxis*>("axisY");
             	QTest::newRow("axisY1") << new QChartAxis();
             	QTest::newRow("axisY2") << new QChartAxis();
             }
             void tst_ChartDataSet::axisY()
             {
             	QFETCH(QChartAxis*, axisY);
             	ChartDataSet dataSet;
             	QChartAxis* defaultAxisY = dataSet.axisY();
             	QVERIFY2(defaultAxisY, "Missing axisY.");
             	QLineSeries* series1 = new QLineSeries();
             	dataSet.addSeries(series1);
             	QLineSeries* series2 = new QLineSeries();
             	dataSet.addSeries(series2, axisY);
             	QVERIFY(dataSet.axisY(series1) == defaultAxisY);
             	QVERIFY(dataSet.axisY(series2) == axisY);
             }
             void tst_ChartDataSet::clearDomains_data()
             {
             	QTest::addColumn<int>("indexCount");
             	QTest::newRow("0") << 0;
             	QTest::newRow("1") << 1;
             	QTest::newRow("5") << 2;
             	QTest::newRow("8") << 3;
             }
             void tst_ChartDataSet::clearDomains()
             {
             	QFETCH(int, indexCount);
             	Domain domain1(0, 100, 0, 100);
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 0);
             	series->add(100, 100);
             	ChartDataSet dataSet;
             	QCOMPARE(dataSet.domainIndex(), 0);
             	dataSet.addSeries(series);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domain1);
             	QList<Domain> domains;
             	domains << domain1;
             	for (int i = 0; i < indexCount; i++) {
             		dataSet.addDomain(QRect(0, 0, 10, 10), QRect(0, 0, 100, 100));
             		domains << dataSet.domain(dataSet.axisY());
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	dataSet.clearDomains(indexCount);
             	QCOMPARE(dataSet.domainIndex(), indexCount);
             	domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domains.at(indexCount));
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::domain_data()
             {
             	QTest::addColumn<Domain>("domain1");
             	QTest::addColumn<Domain>("domain2");
             	QTest::addColumn<Domain>("domain3");
             	QTest::addColumn<Domain>("domain");
             	QTest::newRow("Domain(0,10,0,10)") << Domain(0, 10, 0, 10)
             			<< Domain(0, 5, 0, 5) << Domain(0, 3, 0, 3) << Domain(0, 10, 0, 10);
             	QTest::newRow("Domain(-1,11,0,11)") << Domain(-1, 10, 0, 10)
             			<< Domain(0, 11, 0, 11) << Domain(0, 3, 0, 3)
             			<< Domain(-1, 11, 0, 11);
             	QTest::newRow("Domain(-5,5,1,8)") << Domain(-5, 0, 1, 1)
             			<< Domain(0, 5, 0, 8) << Domain(1, 2, 1, 2) << Domain(-5, 5, 0, 8);
             }
             void tst_ChartDataSet::domain()
             {
             	QFETCH(Domain, domain1);
             	QFETCH(Domain, domain2);
             	QFETCH(Domain, domain3);
             	QFETCH(Domain, domain);
             	ChartDataSet dataSet;
             	QLineSeries* series1 = new QLineSeries();
             	series1->add(domain1.m_minX, domain1.m_minY);
             	series1->add(domain1.m_maxX, domain1.m_maxY);
             	QLineSeries* series2 = new QLineSeries();
             	series2->add(domain2.m_minX, domain2.m_minY);
             	series2->add(domain2.m_maxX, domain2.m_maxY);
             	QLineSeries* series3 = new QLineSeries();
             	series3->add(domain3.m_minX, domain3.m_minY);
             	series3->add(domain3.m_maxX, domain3.m_maxY);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	dataSet.addSeries(series1);
             	dataSet.addSeries(series2);
             	dataSet.addSeries(series3);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QVERIFY2(dataSet.domain(dataSet.axisY()) == domain, "Domain not equal");
             	QCOMPARE(spy0.count(), 2);
             	QCOMPARE(spy1.count(), 6);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 3);
             	QCOMPARE(spy4.count(), 3);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::nextpreviousDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::nextpreviousDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 0);
             	series->add(1000, 1000);
             	dataSet.addSeries(series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	Domain domain5 = dataSet.domain(dataSet.axisY());
             	Domain domain6 = domain3.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain5 == domain6);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 3);
             	Domain domain7 = dataSet.domain(dataSet.axisY());
             	Domain domain8 = domain5.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain7 == domain8);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	Domain domain;
             	bool previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain5);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain3);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, false);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	bool next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),1);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),2);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),3);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, false);
             	QCOMPARE(dataSet.domainIndex(),3);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 12);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 6);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
             	QTest::addColumn<int>("seriesCount");
             	QTest::addColumn<int>("axisYCount");
             	QTest::newRow("2 series, default axis") << 2 << 0;
             	QTest::newRow("2 series, 2 new axis") << 2 << 2;
             	QTest::newRow("2 series, 1 new axis") << 2 << 2;
             	QTest::newRow("3 series, 3 new axis") << 3 << 3;
             	QTest::newRow("3 series, 2 new axis") << 3 << 2;
             	QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::removeSeries()
             {
             	QFETCH(int, seriesCount);
             	QFETCH(int, axisYCount);
             	ChartDataSet dataSet;
             	QList<QChartAxis*> axisList;
-            	QList<QChartSeries*> seriesList;
+            	QList<QSeries*> seriesList;
             	for (int i = 0; i < axisYCount; i++) {
             		QChartAxis* axis = new QChartAxis();
             		axisList << axis;
             	}
             	QList<QChartAxis*>::iterator iterator = axisList.begin();
             	for (int i = 0; i < seriesCount; i++) {
             		QChartAxis* axisY = 0;
             		QLineSeries* series = new QLineSeries();
             		if (iterator != axisList.end()) {
             			axisY = *iterator;
             			iterator++;
             		} else if (axisList.count() > 0) {
             			iterator--;
             			axisY = *iterator;
             			iterator++;
             		}
             		dataSet.addSeries(series, axisY);
             		seriesList << series;
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+            	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
             	QSignalSpy spy4(&dataSet,
-            			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+            			SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+            	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
             	for (int i = 0; i < seriesCount; i++) {
             		dataSet.removeSeries(seriesList.at(i));
             	}
                 //default axis
                 if (axisYCount == 0)
                     axisYCount++;
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), axisYCount);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), seriesCount);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	qDeleteAll(seriesList);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
                 QTest::addColumn<int>("seriesCount");
                 QTest::addColumn<int>("axisYCount");
                 QTest::newRow("2 series, default axis") << 2 << 0;
                 QTest::newRow("2 series, 2 new axis") << 2 << 2;
                 QTest::newRow("2 series, 1 new axis") << 2 << 2;
                 QTest::newRow("3 series, 3 new axis") << 3 << 3;
                 QTest::newRow("3 series, 2 new axis") << 3 << 2;
                 QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QFETCH(int, seriesCount);
                 QFETCH(int, axisYCount);
                 ChartDataSet dataSet;
                 QList<QChartAxis*> axisList;
                 for (int i = 0; i < axisYCount; i++) {
                     QChartAxis* axis = new QChartAxis();
                     axisList << axis;
                 }
                 QList<QChartAxis*>::iterator iterator = axisList.begin();
                 for (int i = 0; i < seriesCount; i++) {
                     QChartAxis* axisY = 0;
                     QLineSeries* series = new QLineSeries();
                     if (iterator != axisList.end()) {
                         axisY = *iterator;
                         iterator++;
                     } else if (axisList.count() > 0) {
                         iterator--;
                         axisY = *iterator;
                         iterator++;
                     }
                     dataSet.addSeries(series, axisY);
                 }
                 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
                 QSignalSpy spy1(&dataSet, SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
                 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
-                QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
-                QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+                QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
-                QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+                QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 dataSet.removeAllSeries();
                 //default axis
                 if (axisYCount == 0)
                     axisYCount++;
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), axisYCount);
                 QCOMPARE(spy3.count(), 0);
                 QCOMPARE(spy4.count(), 0);
                 QCOMPARE(spy5.count(), seriesCount);
                 QCOMPARE(dataSet.domainIndex(), 0);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

test/chartwidgettest/mainwidget.cpp +7 -8

             #include "mainwidget.h"
             #include "dataseriedialog.h"
-            #include "qchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include <qlineseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 m_chartWidget = new QChartView(this);
                 m_chartWidget->setRubberBandPolicy(QChartView::HorizonalRubberBand);
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
                 connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartWidget, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 // Init series type specific controls
                 initPieControls();
                 mainLayout->addLayout(m_pieLayout, 2, 0);
                 // Scatter series specific settings
             //    m_scatterLayout = new QGridLayout();
             //    m_scatterLayout->addWidget(new QLabel("scatter"), 0, 0);
             //    m_scatterLayout->setEnabled(false);
             //    mainLayout->addLayout(m_scatterLayout, 1, 0);
                 // Add layouts and the chart widget to the main layout
                 mainLayout->addWidget(m_chartWidget, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Vanilla");
                 chartTheme->addItem("Icy");
                 chartTheme->addItem("Grayscale");
                 chartTheme->addItem("Scientific");
                 chartTheme->addItem("Unnamed1");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             void MainWidget::initPieControls()
             {
                 // Pie series specific settings
                 // Pie size factory
                 QDoubleSpinBox *pieSizeSpin = new QDoubleSpinBox();
                 pieSizeSpin->setMinimum(LONG_MIN);
                 pieSizeSpin->setMaximum(LONG_MAX);
                 pieSizeSpin->setValue(1.0);
                 pieSizeSpin->setSingleStep(0.1);
                 connect(pieSizeSpin, SIGNAL(valueChanged(double)), this, SLOT(setPieSizeFactor(double)));
                 // Pie position
                 QComboBox *piePosCombo = new QComboBox(this);
                 piePosCombo->addItem("Maximized");
                 piePosCombo->addItem("Top left");
                 piePosCombo->addItem("Top right");
                 piePosCombo->addItem("Bottom left");
                 piePosCombo->addItem("Bottom right");
                 connect(piePosCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(setPiePosition(int)));
                 m_pieLayout = new QGridLayout();
                 m_pieLayout->setEnabled(false);
                 m_pieLayout->addWidget(new QLabel("Pie size factor"), 0, 0);
                 m_pieLayout->addWidget(pieSizeSpin, 0, 1);
                 m_pieLayout->addWidget(new QLabel("Pie position"), 1, 0);
                 m_pieLayout->addWidget(piePosCombo, 1, 1);
             }
             void MainWidget::addSeries()
             {
                 DataSerieDialog dialog(m_defaultSeriesName, this);
                 connect(&dialog, SIGNAL(accepted(QString, int, int, QString, bool)),
                         this, SLOT(addSeries(QString, int, int, QString, bool)));
                 dialog.exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 5);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName.contains("line", Qt::CaseInsensitive)) {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         for (int i(0); i < column.count(); i++) {
                             series->add(i, column.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName.contains("scatter", Qt::CaseInsensitive)) {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         for (int i(0); i < column.count(); i++) {
                            (*series) << QPointF(i, column.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName.contains("pie", Qt::CaseInsensitive)) {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++) {
                             series->add(column.at(i), labels.at(i));
                         }
                         m_chartWidget->addSeries(series);
                         setCurrentSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     // TODO: replace QBarCategory with QStringList?
                     QBarCategory *category = new QBarCategory;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         *category << label;
                     QBarSeries* series = 0;
                     if (seriesName == "Bar")
                         series = new QBarSeries(category, this);
                     else if (seriesName == "Stacked bar")
                         series = new QStackedBarSeries(category, this);
                     else
                         series = new QPercentBarSeries(category, this);
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++) {
                             *set << column.at(i);
                         }
                         series->addBarSet(set);
                     }
                     series->enableFloatingValues();
                     series->setToolTipEnabled();
                     series->enableSeparators(false);
                     m_chartWidget->addSeries(series);
                     setCurrentSeries(series);
                 }
                 // TODO: spline and area
             }
-            void MainWidget::setCurrentSeries(QChartSeries *series)
+            void MainWidget::setCurrentSeries(QSeries *series)
             {
                 if (series) {
                     m_currentSeries = series;
                     switch (m_currentSeries->type()) {
-                    case QChartSeries::SeriesTypeLine:
+                    case QSeries::SeriesTypeLine:
                         break;
-                    case QChartSeries::SeriesTypeScatter:
+                    case QSeries::SeriesTypeScatter:
                         break;
-                    case QChartSeries::SeriesTypePie:
+                    case QSeries::SeriesTypePie:
                         break;
-                    case QChartSeries::SeriesTypeBar:
+                    case QSeries::SeriesTypeBar:
                         qDebug() << "setCurrentSeries (bar)";
                         break;
-                    case QChartSeries::SeriesTypeStackedBar:
+                    case QSeries::SeriesTypeStackedBar:
                         qDebug() << "setCurrentSeries (Stackedbar)";
                         break;
-                    case QChartSeries::SeriesTypePercentBar:
+                    case QSeries::SeriesTypePercentBar:
                         qDebug() << "setCurrentSeries (Percentbar)";
                         break;
                     default:
                         Q_ASSERT(false);
                         break;
                     }
                 }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chartWidget->setChartTheme((QChart::ChartTheme) themeIndex);
                 //TODO: remove this hack. This is just to make it so that theme change is seen immediately.
                 QSize s = size();
                 s.setWidth(s.width()+1);
                 resize(s);
             }
             void MainWidget::setPieSizeFactor(double size)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setSizeFactor(qreal(size));
             }
             void MainWidget::setPiePosition(int position)
             {
                 QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
                 if (pie)
                     pie->setPosition((QPieSeries::PiePosition) position);
             }

test/chartwidgettest/mainwidget.h +2 -2

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <QWidget>
             class QSpinBox;
             class QCheckBox;
             class QGridLayout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define RealList QList<qreal>
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private:
                 void initBackroundCombo(QGridLayout *grid);
                 void initScaleControls(QGridLayout *grid);
                 void initThemeCombo(QGridLayout *grid);
                 void initPieControls();
             private slots:
                 void addSeries();
                 void addSeries(QString series, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled);
                 void backgroundChanged(int itemIndex);
                 void autoScaleChanged(int value);
                 void xMinChanged(int value);
                 void xMaxChanged(int value);
                 void yMinChanged(int value);
                 void yMaxChanged(int value);
-                void setCurrentSeries(QChartSeries *series);
+                void setCurrentSeries(QSeries *series);
                 void changeChartTheme(int themeIndex);
                 void setPieSizeFactor(double margin);
                 void setPiePosition(int position);
                 QList<RealList> generateTestData(int columnCount, int rowCount, QString dataCharacteristics);
                 QStringList generateLabels(int count);
             private:
                 QChartView *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
                 QString m_defaultSeriesName;
-                QChartSeries *m_currentSeries;
+                QSeries *m_currentSeries;
                 QGridLayout *m_scatterLayout;
                 QGridLayout *m_pieLayout;
             };
             #endif // MAINWIDGET_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