HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r349:7594bc4927de

Rename QLineChartSeries to QLineSeries

Michal Klocek -

r349:7594bc4927de

parent child

Context file:

r349:7594bc4927de

Expand all files

charts.pro +2 -2

             !include(common.pri) {
                 error('missing common.pri')
             }
             TEMPLATE = subdirs
             SUBDIRS += src example test qmlplugin
             integrated_build:{
                 message('Configured for integrated build')
             } else {
                 message('Please build example test and qmlplugin after installing library.')
             }
             CONFIG += ordered
             QMAKE_CXXFLAGS += -g -Wall
-            unix:QMAKE_DISTCLEAN += -r build bin doc/html
+            unix:QMAKE_DISTCLEAN += -r build bin include lib doc/html
-            win32:QMAKE_DISTCLEAN += /Q /s build bin doc\\html
+            win32:QMAKE_DISTCLEAN += /Q /s build bin include lib doc\\html
             # install feature file
             feature.path = $$[QT_INSTALL_DATA]/mkspecs/features
             feature.files = $$PWD/features/qtcommercialchart.prf
             INSTALLS += feature
             doc.target = doc
             win32:{
                 doc.commands = qdoc3 $$CHART_BUILD_DOC_DIR\\qcharts.qdocconf
             }else{
                 doc.commands = qdoc3 $$CHART_BUILD_DOC_DIR/qcharts.qdocconf
             }
             doc.depends = FORCE
             QMAKE_EXTRA_TARGETS += doc

example/axischart/main.cpp +3 -3

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <qchart.h>
             #include <qchartaxis.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 int numPoints = 100;
                 for (int x = 0; x <= numPoints; ++x) {
                 	  series0->add(x, fabs(sin(PI/50*x)*100));
                 	  series1->add(x, fabs(cos(PI/50*x)*100));
                 }
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("This is custom axis chart example");
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, Qt::white);
                 backgroundGradient.setColorAt(1.0, QRgb(0xffff80));
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chartView->setChartBackgroundBrush(backgroundGradient);
                 QChartAxis* axisX = chartView->axisX();
                 axisX->setLabelsAngle(45);
                 axisX->setGridPen(Qt::DashLine);
                 axisX->addAxisTickLabel(0,"low");
                 axisX->addAxisTickLabel(50,"medium");
                 axisX->addAxisTickLabel(100,"High");
                 QChartAxis* axisY = chartView->axisY();
                 axisY->setLabelsAngle(45);
                 axisY->setShadesBrush(Qt::yellow);
                 axisY->addAxisTickLabel(0,"low");
                 axisY->addAxisTickLabel(50,"medium");
                 axisY->addAxisTickLabel(100,"High");
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/chartview/main.cpp +2 -2

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <qscatterseries.h>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qbarcategory.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 //! [1]
                 // Create chart view
                 QChartView *chartView = new QChartView();
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("Simple Line Chart");
                 // Add series to the chart
-                QLineChartSeries *line = new QLineChartSeries();
+                QLineSeries *line = new QLineSeries();
                 line->add(0.0, 0.8);
                 line->add(1.1, 1.1);
                 line->add(2.0, 2.5);
                 chartView->addSeries(line);
                 //! [1]
                 chartView->setChartTitle("\'Scietific\' theme");
                 //! [2]
                 // Change theme
                 chartView->setChartTheme(QChart::ChartThemeScientific);
                 //! [2]
                 chartView->setChartTitle("Simple Pie Chart");
                 //! [3]
                 // Add pie series
                 // ...
                 QPieSeries *pie = new QPieSeries();
                 pie->add(3.4, "slice1");
                 pie->add(6.7, "slice2");
                 chartView->addSeries(pie);
                 //! [3]
                 chartView->setChartTitle("Simple Scatter Chart");
                 //! [4]
                 // Add scatter series
                 // ...
                 QScatterSeries *scatter = new QScatterSeries();
                 for (qreal x(0); x < 100; x += 0.5) {
                     qreal y = rand() % 100;
                     *(scatter) << QPointF(x, y);
                 }
                 chartView->addSeries(scatter);
                 //! [4]
                 chartView->setChartTitle("Simple Bar Chart");
                 //! [5]
                 // ...
                 // Add bar series
                 QBarCategory *barCategory = new QBarCategory();
                 *barCategory << "Jan"
                              << "Feb"
                              << "Mar";
                 QBarSeries *bar = new QBarSeries(barCategory);
                 QBarSet *barSet = new QBarSet("Sales");
                 *barSet << 123.2
                         << 301.3
                         << 285.8;
                 bar->addBarSet(barSet);
                 chartView->addSeries(bar);
                 //! [5]
                 QMainWindow w;
                 w.resize(400, 300);
                 w.setCentralWidget(chartView);
                 w.setWindowFlags(Qt::FramelessWindowHint);
                 w.show();
                 return a.exec();
             }

example/colorlinechart/main.cpp +3 -3

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <qchart.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 int numPoints = 100;
                 for (int x = 0; x <= numPoints; ++x) {
                 	  series0->add(x, fabs(sin(PI/50*x)*100));
                 	  series1->add(x, fabs(cos(PI/50*x)*100));
                 }
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 QFont font;
                 font.setPixelSize(18);
                 chartView->setChartTitleFont(font);
                 chartView->setChartTitle("Custom color line chart example");
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, Qt::blue);
                 backgroundGradient.setColorAt(1.0, Qt::yellow);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chartView->setChartBackgroundBrush(backgroundGradient);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/dynamiclinechart/main.cpp +3 -3

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <qchart.h>
             #include <cmath>
             #include "wavegenerator.h"
             #include <QGLWidget>
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 WaveGenerator generator(series0,series1);
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setViewport( new QGLWidget() );
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("This is wave generator buahha.");
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/dynamiclinechart/wavegenerator.h +4 -4

             #include <QTimer>
             #include <QTime>
             #include <QObject>
             #include <cmath>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             static const int numPoints =100;
             class WaveGenerator: public QObject
             {
                 Q_OBJECT
             public:
-                WaveGenerator(QLineChartSeries* series1, QLineChartSeries* series2) :
+                WaveGenerator(QLineSeries* series1, QLineSeries* series2) :
                     m_series1(series1),
                     m_series2(series2),
                     m_wave(0),
                     m_step(2*PI/numPoints)
                 {
                     QTime now = QTime::currentTime();
                     qsrand((uint)now.msec());
                     int fluctuate = 100;
                     for (qreal x = 0; x <= 2*PI; x+=m_step) {
                           series1->add(x, fabs(sin(x)*fluctuate));
                           series2->add(x, fabs(cos(x)*fluctuate));
                     }
                     QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(update()));
                     m_timer.setInterval(5000);
                     m_timer.start();
                 };
             public slots:
                 void update()
                 {
                     int fluctuate;
                     for (qreal i = 0, x = 0; x <= 2*PI; x+=m_step, i++) {
                         fluctuate = qrand() % 100;
                         m_series1->replace(x, fabs(sin(x)*fluctuate));
                         fluctuate = qrand() % 100;
                         m_series2->replace(x, fabs(cos(x)*fluctuate));
                     }
                 }
             private:
-                QLineChartSeries* m_series1;
+                QLineSeries* m_series1;
-                QLineChartSeries* m_series2;
+                QLineSeries* m_series2;
                 int m_wave;
                 qreal m_step;
                 QTimer m_timer;
             };

example/linechart/main.cpp +3 -3

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <qchart.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
             //![1]
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
             //![1]
             //![2]
                 series0->add(0, 6);
                 series0->add(2, 4);
                 series0->add(3, 8);
                 series0->add(7, 4);
                 series0->add(10,5);
                 series1->add(1, 1);
                 series1->add(3, 3);
                 series1->add(7, 6);
                 series1->add(8, 3);
                 series1->add(10,2);
             //![2]
             //![3]
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("Basic line chart example");
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
             //![3]
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

example/presenterchart/chartview.cpp +4 -4

             #include "chartview.h"
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <QTime>
             ChartView::ChartView(QWidget* parent):QChartView(parent),
             m_index(0)
             {
                 QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(handleTimeout()));
                 m_timer.setInterval(3000);
                 QTime now = QTime::currentTime();
                 qsrand((uint)now.msec());
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
-                QLineChartSeries* series2 = new QLineChartSeries();
+                QLineSeries* series2 = new QLineSeries();
                 QPen green(Qt::green);
                 green.setWidth(3);
                 series2->setPen(green);
                 int numPoints = 10;
                 for (int x = 0; x <= numPoints; ++x) {
                     series0->add(x,  qrand() % 100);
                     series1->add(x,  qrand() % 100);
                     series2->add(x,  qrand() % 100);
                 }
                 addSeries(series0);
                 m_series<<series0;
                 m_series<<series1;
                 m_series<<series2;
                 m_timer.start();
             }
             ChartView::~ChartView()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 qDeleteAll(m_series);
             }
             void ChartView::handleTimeout()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 m_index++;
                 m_index=m_index%m_series.size();
                 addSeries(m_series.at(m_index));
             }

example/zoomlinechart/main.cpp +3 -3

             #include "chartwidget.h"
             #include <QApplication>
             #include <QMainWindow>
-            #include <qlinechartseries.h>
+            #include <qlineseries.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
-                QLineChartSeries* series0 = new QLineChartSeries();
+                QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
-                QLineChartSeries* series1 = new QLineChartSeries();
+                QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 int numPoints = 100;
                 for (int x = 0; x <= numPoints; ++x) {
                 	  series0->add(x, fabs(sin(PI/50*x)*100));
                 	  series1->add(x, fabs(cos(PI/50*x)*100));
                  }
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->setRenderHint(QPainter::Antialiasing);
                 chartWidget->setChartTitle("Zoom in/out line chart example");
                 chartWidget->addSeries(series0);
                 chartWidget->addSeries(series1);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

qmlplugin/declarativelineseries.cpp +2 -2

             #include "declarativelineseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
-            #include "qlinechartseries.h"
+            #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeLineSeries::DeclarativeLineSeries(QDeclarativeItem *parent) :
                 QDeclarativeItem(parent)
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
                 connect(this, SIGNAL(parentChanged()),
                         this, SLOT(setParentForSeries()));
             }
             void DeclarativeLineSeries::setParentForSeries()
             {
                 if (!m_series) {
                     DeclarativeChart *declarativeChart = qobject_cast<DeclarativeChart *>(parent());
                     if (declarativeChart) {
                         QChart *chart = qobject_cast<QChart *>(declarativeChart->m_chart);
                         qDebug() << "creating line series for chart: " << chart;
                         Q_ASSERT(chart);
-                        m_series = new QLineChartSeries();
+                        m_series = new QLineSeries();
                         Q_ASSERT(m_series);
                         for (int i(0); i < m_data.count(); i++) {
                             ScatterElement *element = m_data.at(i);
                             m_series->add(element->x(), element->y());
                         }
                         chart->addSeries(m_series);
                     }
                 }
             }
             QDeclarativeListProperty<ScatterElement> DeclarativeLineSeries::data()
             {
                 return QDeclarativeListProperty<ScatterElement>(this, 0, &DeclarativeLineSeries::appendData);
             }
             void DeclarativeLineSeries::appendData(QDeclarativeListProperty<ScatterElement> *list,
                                                    ScatterElement *element)
             {
                 DeclarativeLineSeries *series = qobject_cast<DeclarativeLineSeries *>(list->object);
                 if (series) {
                     series->m_data.append(element);
                     if (series->m_series)
                         series->m_series->add(element->x(), element->y());
                 }
             }
             #include "moc_declarativelineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativelineseries.h +2 -2

             #ifndef DECLARATIVELINESERIES_H
             #define DECLARATIVELINESERIES_H
             #include "qchartglobal.h"
             #include "scatterelement.h" // TODO: rename header
             #include <QDeclarativeItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
-            class QLineChartSeries;
+            class QLineSeries;
             class DeclarativeLineSeries : public QDeclarativeItem
             {
                 Q_OBJECT
                 Q_PROPERTY(QDeclarativeListProperty<ScatterElement> data READ data)
             public:
                 explicit DeclarativeLineSeries(QDeclarativeItem *parent = 0);
                 QDeclarativeListProperty<ScatterElement> data();
             signals:
             public slots:
                 static void appendData(QDeclarativeListProperty<ScatterElement> *list,
                                        ScatterElement *element);
             private slots:
                 void setParentForSeries();
             private:
                 QChart *m_chart;
-                QLineChartSeries *m_series;
+                QLineSeries *m_series;
                 QList<ScatterElement *> m_data;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVELINESERIES_H

src/chartdataset.cpp +2 -2

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
-            #include "qlinechartseries.h"
+            #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)
             {
                 // 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<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: {
-                        QLineChartSeries* xyseries = static_cast<QLineChartSeries*>(series);
+                        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: {
                     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: {
                     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: {
                     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: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QChartSeries::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)
             {
                 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);
                     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);
                     foreach(QChartSeries* 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);
                     foreach(QChartSeries* 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
             {
                 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/chartpresenter.cpp +2 -2

             #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 "qlinechartseries.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.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(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
                 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(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)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
-                        QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
+                        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: {
                         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: {
                         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: {
                         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: {
                         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: {
                         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)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::handleSeriesDomainChanged(QChartSeries* 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);
                 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();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
                     foreach(QChartSeries* 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/charttheme.cpp +3 -3

             #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 "qlinechartseries.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.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)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
-                        QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
+                        QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::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: {
                         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, QLineChartSeries* series,int count)
+            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)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==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 LineChartItem;
-            class QLineChartSeries;
+            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(LineChartItem* item, QLineChartSeries*, 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/linechart.pri +2 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/linechartanimationitem.cpp \
                 $$PWD/linechartitem.cpp \
-                $$PWD/qlinechartseries.cpp
+                $$PWD/qlineseries.cpp
             PRIVATE_HEADERS += \
                 $$PWD/linechartitem_p.h \
                 $$PWD/linechartanimationitem_p.h
             PUBLIC_HEADERS += \
-                $$PWD/qlinechartseries.h  
  No newline at end of file
+                $$PWD/qlineseries.h  
  No newline at end of file

src/linechart/linechartanimationitem.cpp +1 -1

             #include "linechartanimationitem_p.h"
             #include "linechartitem_p.h"
             #include <QPropertyAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 500;
-            LineChartAnimationItem::LineChartAnimationItem(ChartPresenter* presenter, QLineChartSeries* series,QGraphicsItem *parent):
+            LineChartAnimationItem::LineChartAnimationItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):
             LineChartItem(presenter,series,parent)
             {
             }
             LineChartAnimationItem::~LineChartAnimationItem()
             {
             }
             void LineChartAnimationItem::addPoints(const QVector<QPointF>& points)
             {
                 m_data=points;
                 clearView();
                 QPropertyAnimation *animation = new QPropertyAnimation(this, "a_addPoints", parent());
                 animation->setDuration(duration);
                 //animation->setEasingCurve(QEasingCurve::InOutBack);
                 animation->setKeyValueAt(0.0, 0);
                 animation->setKeyValueAt(1.0, m_data.size());
                 animation->start(QAbstractAnimation::DeleteWhenStopped);
             }
             void LineChartAnimationItem::setPoint(int index,const QPointF& point)
             {
                 AnimationHelper* helper = new AnimationHelper(this,index);
                 QPropertyAnimation *animation = new QPropertyAnimation(helper, "point", parent());
                 animation->setDuration(duration);
                 //animation->setEasingCurve(QEasingCurve::InOutBack);
                 animation->setKeyValueAt(0.0, points().value(index));
                 animation->setKeyValueAt(1.0, point);
                 animation->start(QAbstractAnimation::DeleteWhenStopped);
             }
             void LineChartAnimationItem::aw_addPoints(int points)
             {
                 int index = count();
                 for(int i = index;i< points ;i++){
                     LineChartItem::addPoint(m_data.at(i));
                 }
                 updateGeometry();
                 update();
             }
             void LineChartAnimationItem::aw_setPoint(int index,const QPointF& point)
             {
                 LineChartItem::setPoint(index,point);
                 updateGeometry();
                 update();
             }
             #include "moc_linechartanimationitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartanimationitem_p.h +1 -1

             #ifndef LINECHARTANIMATIONITEM_P_H_
             #define LINECHARTANIMATIONITEM_P_H_
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class LineChartItem;
             class LineChartAnimationItem : public LineChartItem {
                 Q_OBJECT
                 Q_PROPERTY(int a_addPoints READ ar_addPoints WRITE aw_addPoints);
                // Q_PROPERTY(QPointF a_setPoint READ ar_setPoint WRITE aw_setPoint);
             public:
-            	LineChartAnimationItem(ChartPresenter* presenter, QLineChartSeries *series, QGraphicsItem *parent = 0);
+            	LineChartAnimationItem(ChartPresenter* presenter, QLineSeries *series, QGraphicsItem *parent = 0);
             	virtual ~LineChartAnimationItem();
             	void addPoints(const QVector<QPointF>& points);
             	void setPoint(int index,const QPointF& point);
             	//void removePoint(const QPointF& point){};
             	//void setPoint(const QPointF& oldPoint, const QPointF& newPoint){};
             	int ar_addPoints() const { return m_addPoints;}
             	void aw_addPoints(int points);
             	const QPointF& ar_setPoint() const { return m_setPoint;}
                 void aw_setPoint(int index,const QPointF& point);
             private:
             	QVector<QPointF> m_data;
             	Domain m_domain;
             	int m_addPoints;
             	QPointF m_setPoint;
             	int m_setPoint_index;
             };
             class AnimationHelper: public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QPointF point READ point WRITE setPoint);
             public:
                 AnimationHelper(LineChartAnimationItem* item,int index):m_item(item),m_index(index){};
                 void setPoint(const QPointF& point){
                     m_item->aw_setPoint(m_index,point);
                 }
                 QPointF point(){return m_point;}
                 QPointF m_point;
                 LineChartAnimationItem* m_item;
                 int m_index;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/linechartitem.cpp +4 -4

             #include "linechartitem_p.h"
-            #include "qlinechartseries.h"
+            #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimazie : remove points which are not visible
-            LineChartItem::LineChartItem(ChartPresenter* presenter, QLineChartSeries* series,QGraphicsItem *parent):ChartItem(parent),
+            LineChartItem::LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_dirtyData(false),
             m_dirtyGeometry(false),
             m_dirtyDomain(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::addPoints(const QVector<QPointF>& points)
             {
                 m_data = points;
                 for(int i=0; i<m_data.size();i++){
                 const QPointF& point =m_data[i];
                 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
                 item->setPos(point.x()-1,point.y()-1);;
                 if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
                 m_points << item;
                 }
             }
             void LineChartItem::addPoint(const QPointF& point)
             {
             	m_data << point;
             	QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
             	m_clipRect.contains(point);
             	item->setPos(point.x()-1,point.y()-1);
             	if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
             	m_points << item;
             }
             void LineChartItem::removePoint(const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(point,0);
                 m_data.remove(index);
                 delete(m_points.takeAt(index));
             }
             void LineChartItem::setPoint(const QPointF& oldPoint,const QPointF& newPoint)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(oldPoint,0);
                 if(index > -1){
                 m_data.replace(index,newPoint);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(newPoint.x()-1,newPoint.y()-1);
                 }
             }
             void LineChartItem::setPoint(int index,const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 Q_ASSERT(index>=0);
                 m_data.replace(index,point);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(point.x()-1,point.y()-1);
             }
             void LineChartItem::clear()
             {
             	 qDeleteAll(m_points);
             	 m_points.clear();
             	 m_hash.clear();
             	 m_path = QPainterPath();
             	 m_rect = QRect();
             	 m_data.clear();
             }
             void LineChartItem::clearView()
             {
                  qDeleteAll(m_points);
                  m_points.clear();
                  m_path = QPainterPath();
                  m_rect = QRect();
                  m_data.clear();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
-            void LineChartItem::calculatePoint(QPointF& point, int index, const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
+            void LineChartItem::calculatePoint(QPointF& point, int index, const QLineSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 qreal x = (series->x(index) - domain.m_minX)* deltaX;
                 qreal y = (series->y(index) - domain.m_minY)*-deltaY + size.height();
                 point.setX(x);
                 point.setY(y);
             }
-            void LineChartItem::calculatePoints(QVector<QPointF>& points, QHash<int,int>& hash,const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
+            void LineChartItem::calculatePoints(QVector<QPointF>& points, QHash<int,int>& hash,const QLineSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 for (int i = 0; i < series->count(); ++i) {
                   qreal x = (series->x(i) - domain.m_minX)* deltaX;
                   qreal y = (series->y(i) - domain.m_minY)*-deltaY + size.height();
                   hash[i] = points.size();
                   points << QPointF(x,y);
                 }
             }
             void LineChartItem::updateDomain()
             {
                 clear();
                 prepareGeometryChange();
             	calculatePoints(m_data,m_hash,m_series,m_size, m_domain);
             	addPoints(m_data);
             }
             void LineChartItem::updateData()
             {
                 //for now the same
                 updateDomain();
             }
             void LineChartItem::updateGeometry()
             {
                if(m_data.size()==0) return;
                prepareGeometryChange();
                QPainterPath path;
                const QPointF& point = m_data.at(0);
                path.moveTo(point);
                foreach( const QPointF& point , m_data) {
                    path.lineTo(point);
                }
                m_path = path;
                m_rect = path.boundingRect();
             }
             void LineChartItem::setPen(const QPen& pen)
             {
                 m_pen = pen;
             }
             //handlers
             void LineChartItem::handleModelChanged(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 if(m_hash.contains(index)){
                     int i = m_hash.value(index);
                     QPointF point;
                     calculatePoint(point,index,m_series,m_size,m_domain);
                     setPoint(i,point);
                 }
                 update();
             }
             void LineChartItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 updateDomain();
                 update();
             }
             void LineChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 updateDomain();
                 updateGeometry();
                 setPos(rect.topLeft());
                 update();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +5 -5

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
-            class QLineChartSeries;
+            class QLineSeries;
             class LineChartAnimationItem;
             class LineChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
-                LineChartItem(ChartPresenter* presenter, QLineChartSeries* series,QGraphicsItem *parent = 0);
+                LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent = 0);
                 ~ LineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setPen(const QPen& pen);
                 const Domain& domain() const { return m_domain;}
                 virtual void addPoint(const QPointF& );
                 virtual void addPoints(const QVector<QPointF>& points);
                 virtual void removePoint(const QPointF& point);
                 virtual void setPoint(const QPointF& oldPoint, const QPointF& newPoint);
                 virtual void setPoint(int index,const QPointF& point);
                 void setPointsVisible(bool visible);
                 void clear();
                 void clearView();
                 int count() const { return m_data.size();}
                 const QVector<QPointF>& points(){ return m_data;}
             protected:
                 virtual void updateGeometry();
                 virtual void updateData();
                 virtual void updateDomain();
                 //refactor
-                void calculatePoint(QPointF& point, int index, const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const;
+                void calculatePoint(QPointF& point, int index, const QLineSeries* series,const QSizeF& size, const Domain& domain) const;
-                void calculatePoints(QVector<QPointF>& points,QHash<int,int>& hash,const QLineChartSeries* series, const QSizeF& size, const Domain& domain) const;
+                void calculatePoints(QVector<QPointF>& points,QHash<int,int>& hash,const QLineSeries* series, const QSizeF& size, const Domain& domain) const;
             protected slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 ChartPresenter* m_presenter;
                 QPainterPath m_path;
                 QSizeF m_size;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 Domain m_domain;
                 QList<QGraphicsItem*> m_points;
                 QVector<QPointF> m_data;
                 QHash<int,int> m_hash;
-                QLineChartSeries* m_series;
+                QLineSeries* m_series;
                 QPen m_pen;
                 bool m_dirtyData;
                 bool m_dirtyGeometry;
                 bool m_dirtyDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp ~~src/linechart/qlinechartseries.cpp~~ renamed +17 -17

-            #include "qlinechartseries.h"
+            #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineChartSeries
                 \brief The QLineChartSeries 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 QLineChartSeries 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 QLineChartSeries::type() const
                 \brief Returns type of series.
                 \sa QChartSeries, QChartSeriesType
             */
             /*!
                \fn QPen QLineChartSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn bool  QLineChartSeries::isPointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QLineChartSeries::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.
             */
-            QLineChartSeries::QLineChartSeries(QObject* parent):QChartSeries(parent),
+            QLineSeries::QLineSeries(QObject* parent):QChartSeries(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.
             */
-            QLineChartSeries::~QLineChartSeries()
+            QLineSeries::~QLineSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
-            void QLineChartSeries::add(qreal x,qreal y)
+            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 QLineChartSeries::add(const QPointF& point)
+            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 QLineChartSeries::replace(qreal x,qreal y)
+            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 QLineChartSeries::replace(const QPointF& point)
+            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 QLineChartSeries::remove(qreal x)
+            void QLineSeries::remove(qreal x)
             {
             }
             /*!
               Removes current \a point x value. Note \point y value is ignored.
             */
-            void QLineChartSeries::remove(const QPointF& point)
+            void QLineSeries::remove(const QPointF& point)
             {
             }
             /*!
               Clears all the data.
             */
-            void QLineChartSeries::clear()
+            void QLineSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
-            qreal QLineChartSeries::x(int pos) const
+            qreal QLineSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
-            qreal QLineChartSeries::y(int pos) const
+            qreal QLineSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
-            int QLineChartSeries::count() const
+            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 QLineChartSeries::setPen(const QPen& pen)
+            void QLineSeries::setPen(const QPen& pen)
             {
                 m_pen=pen;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
-            void QLineChartSeries::setPointsVisible(bool visible)
+            void QLineSeries::setPointsVisible(bool visible)
             {
                 m_pointsVisible=visible;
             }
-            QDebug operator<< (QDebug debug, const QLineChartSeries series)
+            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_qlinechartseries.cpp"
+            #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h ~~src/linechart/qlinechartseries.h~~ renamed +4 -4

             #ifndef QLINECHARTSERIES_H_
             #define QLINECHARTSERIES_H_
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QLineChartSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QLineSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
-                QLineChartSeries(QObject* parent=0);
+                QLineSeries(QObject* parent=0);
-                virtual ~QLineChartSeries();
+                virtual ~QLineSeries();
             public: // from QChartSeries
                 virtual QChartSeriesType type() const { return QChartSeries::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 QLineChartSeries series);
+                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

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

             #include <QtTest/QtTest>
             #include <qchartaxis.h>
             #include <qchartseries.h>
-            #include <qlinechartseries.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(QLineChartSeries*)
+            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*>();
             }
             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);
-            	QLineChartSeries series;
+            	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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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;
-            		QLineChartSeries* series = new QLineChartSeries();
+            		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.");
-            	QLineChartSeries* series1 = new QLineChartSeries();
+            	QLineSeries* series1 = new QLineSeries();
             	dataSet.addSeries(series1);
-            	QLineChartSeries* series2 = new QLineChartSeries();
+            	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);
-            	QLineChartSeries* series = new QLineChartSeries();
+            	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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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;
-            	QLineChartSeries* series1 = new QLineChartSeries();
+            	QLineSeries* series1 = new QLineSeries();
             	series1->add(domain1.m_minX, domain1.m_minY);
             	series1->add(domain1.m_maxX, domain1.m_maxY);
-            	QLineChartSeries* series2 = new QLineChartSeries();
+            	QLineSeries* series2 = new QLineSeries();
             	series2->add(domain2.m_minX, domain2.m_minY);
             	series2->add(domain2.m_maxX, domain2.m_maxY);
-            	QLineChartSeries* series3 = new QLineChartSeries();
+            	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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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);
-            	QLineChartSeries* series = new QLineChartSeries();
+            	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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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;
             	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;
-            		QLineChartSeries* series = new QLineChartSeries();
+            		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 spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	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;
-                    QLineChartSeries* series = new QLineChartSeries();
+                    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 spy4(&dataSet, SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
                 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
                 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 +2 -2

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
-            #include <qlinechartseries.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);
-                        QLineChartSeries *series = new QLineChartSeries();
+                        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->enableToolTip();
                     series->enableSeparators(false);
                     m_chartWidget->addSeries(series);
                     setCurrentSeries(series);
                 }
                 // TODO: spline and area
             }
             void MainWidget::setCurrentSeries(QChartSeries *series)
             {
                 if (series) {
                     m_currentSeries = series;
                     switch (m_currentSeries->type()) {
                     case QChartSeries::SeriesTypeLine:
                         break;
                     case QChartSeries::SeriesTypeScatter:
                         break;
                     case QChartSeries::SeriesTypePie:
                         break;
                     case QChartSeries::SeriesTypeBar:
                         qDebug() << "setCurrentSeries (bar)";
                         break;
                     case QChartSeries::SeriesTypeStackedBar:
                         qDebug() << "setCurrentSeries (Stackedbar)";
                         break;
                     case QChartSeries::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);
             }

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