HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r419:1666cfa56d96

Spline with problems

Marek Rosa -

r419:1666cfa56d96

parent child

Context file:

r419:1666cfa56d96

Collapse all files

example/splinechart/splinewidget.cpp +15 -15

             #include "splinewidget.h"
             #include "qchartview.h"
             #include "qsplineseries.h"
-            #include "qlinechartseries.h"
+            #include "qlineseries.h"
             #include <QGridLayout>
             QTCOMMERCIALCHART_USE_NAMESPACE
             SplineWidget::SplineWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 //create QSplineSeries
                 QSplineSeries* series = new QSplineSeries(this);
-                series->addData(QPointF(150, 100));
+                series->add(QPointF(150, 100));
-                series->addData(QPointF(200, 180));
+                series->add(QPointF(200, 180));
-                series->addData(QPointF(240, 130));
+                series->add(QPointF(240, 130));
-                series->addData(QPointF(270, 120));
+                series->add(QPointF(270, 120));
-                series->addData(QPointF(310, 120));
+                series->add(QPointF(310, 120));
-                series->addData(QPointF(420, 160));
+                series->add(QPointF(420, 160));
-                series->addData(QPointF(535, 250));
+                series->add(QPointF(535, 250));
                 series->calculateControlPoints();
-                QLineChartSeries* lineSeries = new QLineChartSeries;
+            //    QLineSeries* lineSeries = new QLineSeries;
-                for (int i = 0; i < series->count() - 1; i++)
+            //    for (int i = 0; i < series->count() - 1; i++)
+            //    {
-                    lineSeries->add(series->at(i).x(), series->at(i).y());
+            //        lineSeries->add(series->at(i).x(), series->at(i).y());
-                    lineSeries->add(series->controlPoint(2*i).x(), series->controlPoint(2*i).y());
+            //        lineSeries->add(series->controlPoint(2*i).x(), series->controlPoint(2*i).y());
-                    lineSeries->add(series->controlPoint(2*i + 1).x(), series->controlPoint(2*i + 1).y());
+            //        lineSeries->add(series->controlPoint(2*i + 1).x(), series->controlPoint(2*i + 1).y());
+            //    }
             //    QLineChartSeries* lineSeries2 = new QLineChartSeries;
             //    lineSeries2->add(10, 50);
             //    lineSeries2->add(30, 15);
             //    lineSeries2->add(60, 40);
             //    lineSeries2->add(90, 70);
             //    lineSeries2->add(100, 20);
                 //create chart view
                 QChartView* chart = new QChartView;
                 chart->setMinimumSize(800,600);
             //    chart->setGeometry(50, 50, 400, 300);
                 chart->addSeries(series);
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chart);
                 setLayout(mainLayout);
             }
             SplineWidget::~SplineWidget()
             {
             }

src/chartdataset.cpp +3 -3

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.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(QSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this); // take ownership
                 clearDomains();
                 if(axisY==0) axisY = m_axisY;
                 axisY->setParent(this); // take ownership
                 QList<QSeries*>  seriesList = m_seriesMap.values(axisY);
                 QList<Domain> domainList = m_domainMap.values(axisY);
                 Q_ASSERT(domainList.size()<=1);
                 Domain domain;
                 if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* xyseries = static_cast<QLineSeries*>(series);
                     for (int i = 0; i < xyseries->count(); i++)
                     {
                         qreal x = xyseries->x(i);
                         qreal y = xyseries->y(i);
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     qDebug() << "QChartSeries::SeriesTypeBar";
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     qreal x = barSeries->categoryCount();
                     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 QSeries::SeriesTypeStackedBar: {
                     qDebug() << "QChartSeries::SeriesTypeStackedBar";
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     qreal x = stackedBarSeries->categoryCount();
                     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 QSeries::SeriesTypePercentBar: {
                     qDebug() << "QChartSeries::SeriesTypePercentBar";
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     qreal x = percentBarSeries->categoryCount();
                     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 QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     // TODO: domain stuff
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     Q_ASSERT(scatterSeries);
                     foreach (QPointF point, scatterSeries->data()) {
                         domain.m_minX = qMin(domain.m_minX, point.x());
                         domain.m_maxX = qMax(domain.m_maxX, point.x());
                         domain.m_minY = qMin(domain.m_minY, point.y());
                         domain.m_maxY = qMax(domain.m_maxY, point.y());
                     }
                     break;
                 }
-                case QChartSeries::SeriesTypeSpline: {
+                case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     for (int i = 0; i < splineSeries->count(); i++)
                     {
-                        qreal x = splineSeries->at(i).x();
+                        qreal x = splineSeries->x(i);
-                        qreal y = splineSeries->at(i).y();
+                        qreal y = splineSeries->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;
                 }
                 default: {
                     qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                     return;
                     break;
                 }
                 }
                 if(!m_domainMap.contains(axisY))
                 {
                     emit axisAdded(axisY);
                     QObject::connect(axisY,SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                 }
                 if(!m_axisXInitialized)
                 {
                     emit axisAdded(axisX());
                     QObject::connect(axisX(),SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
                     QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                     m_axisXInitialized=true;
                 }
                 m_domainMap.replace(axisY,domain);
                 m_seriesMap.insert(axisY,series);
                 emit seriesAdded(series);
                 setDomain(m_domainIndex,axisY);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         emit seriesRemoved(series);
                         m_seriesMap.remove(axis,series);
                         //remove axis if no longer there
                         if(!m_seriesMap.contains(axis)){
                             emit axisRemoved(axis);
                             m_domainMap.remove(axis);
                             if(axis != m_axisY)
                                 delete axis;
                         }
                         series->setParent(0);
                         break;
                     }
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     for(int i =0 ; i < seriesList.size();i++ )
                     {
                         emit seriesRemoved(seriesList.at(i));
                         delete(seriesList.at(i));
                     }
                     m_seriesMap.remove(axis);
                     m_domainMap.remove(axis);
                     emit axisRemoved(axis);
                     if(axis != m_axisY) delete axis;
                 }
                 m_domainIndex=0;
             }
             bool ChartDataSet::nextDomain()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 if(domainList.count()==0) return;
                 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<QSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     axis->updateRange(domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 axisX()->updateRange(domain.m_minX,domain.m_maxY);
                 emit axisRangeChanged(axisX(),labels);
             }
             void ChartDataSet::setDomain(int index,QChartAxis* axis)
             {
                 int i = m_domainMap.count(axis) - index -1;
                 Q_ASSERT(i>=0);
                 Domain domain = m_domainMap.values(axis).at(i);
                 {
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     axis->updateRange(domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(axis,labels);
                 }
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 axisX()->updateRange(domain.m_minX,domain.m_maxY);
                 emit axisRangeChanged(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());
                     m_domainMap.insert(axis,domain);
                 }
                 setDomain(++m_domainIndex);
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         return axis;
                     }
                 }
                 return 0;
             }
             QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
             {
                 Q_ASSERT(max>=min);
                 QStringList labels;
                 int ticks = axis->ticksCount()-1;
                 for(int i=0; i<= ticks; i++){
                     qreal value = min + (i * (max - min)/ ticks);
                     QString label = axis->axisTickLabel(value);
                     if(label.isEmpty()){
                         labels << QString::number(value);
                     }else{
                         labels << label;
                     }
                 }
                 return labels;
             }
             void ChartDataSet::handleRangeChanged(QChartAxis* axis)
             {
                 qreal min = axis->min();
                 qreal max = axis->max();
                 if(axis==axisX()) {
                     m_domainIndex=0;
                     clearDomains(m_domainIndex);
                     QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                     foreach (QChartAxis* axis , domainList) {
                         Q_ASSERT(m_domainMap.values(axis).size()==1);
                         Domain domain = m_domainMap.value(axis);
                         domain.m_minX=min;
                         domain.m_maxX=max;
                         m_domainMap.replace(axis,domain);
                     }
                     setDomain(m_domainIndex);
                 }
                 else {
                     QList<Domain> domains = m_domainMap.values(axis);
                     m_domainMap.remove(axis);
                     for(int i=0;i<domains.size();i++)
                     {
                         domains[i].m_minY=min;
                         domains[i].m_maxY=max;
                     }
                     for(int j=domains.size()-1; j>=0;j--)
                         m_domainMap.insert(axis,domains.at(j));
                     setDomain(m_domainIndex,axis);
                 }
             }
             void ChartDataSet::handleTickChanged(QChartAxis* axis)
             {
                 if(axis==axisX()){
                     Domain domain = m_domainMap.value(axisY());
                     QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
                     emit axisRangeChanged(axis,labels);
                 }else{
                     Domain domain = m_domainMap.value(axis);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     emit axisRangeChanged(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 "qlineseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             #include "splinepresenter_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(QSeries*)),this,SLOT(handleSeriesAdded(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisRangeChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisRangeChanged(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);
+                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(QSeries* series)
             {
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)){
                         item = new LineChartAnimationItem(this,lineSeries,m_chart);
                     }else{
                         item = new LineChartItem(this,lineSeries,m_chart);
                     }
                     m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
                     QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
                     QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
                     QObject::connect(lineSeries,SIGNAL(updated()),item,SLOT(handleUpdated()));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     item->handleUpdated();
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* item = new BarPresenter(barSeries,m_chart);
                     m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     // m_axisXItem->setVisible(false);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                     m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                     m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                     QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
                                      scatterSeries, SIGNAL(clicked(QPointF)));
                     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);
                     if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *s = qobject_cast<QPieSeries *>(series);
                     PiePresenter* pie = new PiePresenter(m_chart, s);
                     m_chartTheme->decorate(pie, s, m_chartItems.count());
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->setAxisVisible(false);
                         m_chart->axisY()->setAxisVisible(false);
                         m_chart->axisX()->setGridVisible(false);
                         m_chart->axisY()->setGridVisible(false);
                         m_chart->axisX()->setLabelsVisible(false);
                         m_chart->axisY()->setLabelsVisible(false);
                         m_chart->axisX()->setShadesVisible(false);
                         m_chart->axisY()->setShadesVisible(false);
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     m_chartItems.insert(series, pie);
                     pie->handleGeometryChanged(m_rect);
                     break;
                 }
-                case QChartSeries::SeriesTypeSpline: {
+                case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
                     SplinePresenter* splinePresenter = new SplinePresenter(splineSeries, m_chart);
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), splinePresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     m_chartTheme->decorate(splinePresenter, splineSeries, m_chartItems.count());
                     m_chartItems.insert(splineSeries, splinePresenter);
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 delete item;
             }
             void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisRangeChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleRangeChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                     j.next();
                     m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "scatterpresenter_p.h"
-            #include "piepresenter.h"
+            #include "piepresenter_p.h"
             #include "splinepresenter_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             void ChartTheme::decorate(SplinePresenter* presenter, QSplineSeries* 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;
             }
             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 QLineSeries;
             class LineChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                 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);
                 void setPointsVisible(bool visible);
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleUpdated();
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             public:
                 virtual void updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
                 virtual void updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint);
-                void applyGeometry(QVector<QPointF>& points);
+                virtual void applyGeometry(QVector<QPointF>& points);
                 void createPoints(int count);
                 void clearPoints(int count);
                 QPointF calculateGeometryPoint(int index) const;
                 QVector<QPointF> calculateGeometryPoints() const;
-            private:
+            protected:
-                ChartPresenter* m_presenter;
                 QPainterPath m_path;
-                QLineSeries* m_series;
-                QSizeF m_size;
                 QRectF m_rect;
+                QLineSeries* m_series;
+                ChartPresenter* m_presenter;
+                QSizeF m_size;
                 QRectF m_clipRect;
                 Domain m_domain;
                 QGraphicsItemGroup m_items;
                 QVector<QPointF> m_points;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.h +6 -4

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

src/splinechart/qsplineseries.cpp +26 -26

             #include "qsplineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QSplineSeries::QSplineSeries(QObject *parent) :
-                QChartSeries(parent)
+                QLineSeries(parent)
             {
             }
-            QSplineSeries& QSplineSeries::operator << (const QPointF &value)
+            //QSplineSeries& QSplineSeries::operator << (const QPointF &value)
+            //{
-            //    d->m_data.append(value);
+            ////    d->m_data.append(value);
-                m_data.append(value);
+            //    m_data.append(value);
-            //    emit changed();
+            ////    emit changed();
-                return *this;
+            //    return *this;
+            //}
-            void QSplineSeries::addData(QPointF value)
+            //void QSplineSeries::addData(QPointF value)
+            //{
-                m_data.append(value);
+            //    m_data.append(value);
+            //}
             void QSplineSeries::calculateControlPoints()
             {
                 // Based on http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit
                 // CPOL Licence
-                int n = m_data.size() - 1;
+                int n = m_x.size() - 1;
                 if (n == 1)
                 { // Special case: Bezier curve should be a straight line.
                     //            firstControlPoints = new Point[1];
                     // 3P1 = 2P0 + P3
-                    m_controlPoints.append(QPointF((2 * m_data[0].x() + m_data[1].x()) / 3, (2 * m_data[0].y() + m_data[1].y()) / 3));
+                    m_controlPoints.append(QPointF((2 * m_x[0] + m_x[1]) / 3, (2 * m_y[0] + m_y[1]) / 3));
                     // P2 = 2P1  P0
-                    m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - m_data[0].x(), 2 * m_controlPoints[0].y() - m_data[0].y()));
+                    m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - m_x[0], 2 * m_controlPoints[0].y() - m_y[0]));
                     return;
                 }
                 // Calculate first Bezier control points
                 // Right hand side vector
                 //  Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QList<qreal> rhs;
-                rhs.append(m_data[0].x() + 2 * m_data[1].x());
+                rhs.append(m_x[0] + 2 * m_x[1]);
                 // Set right hand side X values
-                for (int i = 1; i < m_data.size() - 1; ++i)
+                for (int i = 1; i < m_x.size() - 1; ++i)
-                    rhs.append(4 * m_data[i].x() + 2 * m_data[i + 1].x());
+                    rhs.append(4 * m_x[i] + 2 * m_x[i + 1]);
-                rhs.append((8 * m_data[n - 1].x() + m_data[n].x()) / 2.0);
+                rhs.append((8 * m_x[n - 1] + m_x[n]) / 2.0);
                 // Get first control points X-values
                 QList<qreal> x = getFirstControlPoints(rhs);
-                rhs[0] = m_data[0].y() + 2 * m_data[1].y();
+                rhs[0] = m_y[0] + 2 * m_y[1];
                 // Set right hand side Y values
-                for (int i = 1; i < m_data.size() - 1; ++i)
+                for (int i = 1; i < m_y.size() - 1; ++i)
-                    rhs[i] = 4 * m_data[i].y() + 2 * m_data[i + 1].y();
+                    rhs[i] = 4 * m_y[i] + 2 * m_y[i + 1];
-                rhs[n - 1] = (8 * m_data[n - 1].y() + m_data[n].y()) / 2.0;
+                rhs[n - 1] = (8 * m_y[n - 1] + m_y[n]) / 2.0;
                 // Get first control points Y-values
                 QList<qreal> y = getFirstControlPoints(rhs);
                 // Fill output arrays.
                 //        firstControlPoints = new Point[n];
                 //        secondControlPoints = new Point[n];
-                for (int i = 0; i < m_data.size(); ++i)
+                for (int i = 0; i < m_x.size(); ++i)
                 {
                     // First control point
                     m_controlPoints.append(QPointF(x[i], y[i]));
                     // Second control point
                     if (i < n - 1)
-                        m_controlPoints.append(QPointF(2 * m_data[i + 1].x() - x[i + 1], 2 * m_data[i + 1].y() - y[i + 1]));
+                        m_controlPoints.append(QPointF(2 * m_x[i + 1] - x[i + 1], 2 * m_y[i + 1] - y[i + 1]));
                     else
-                        m_controlPoints.append(QPointF((m_data[n].x() + x[n - 1]) / 2, (m_data[n].y() + y[n - 1]) / 2));
+                        m_controlPoints.append(QPointF((m_x[n] + x[n - 1]) / 2, (m_y[n] + y[n - 1]) / 2));
                 }
             }
             QList<qreal> QSplineSeries::getFirstControlPoints(QList<qreal> rhs)
             {
                 QList<qreal> x; // Solution vector.
                 QList<qreal> tmp; // Temp workspace.
                 qreal b = 2.0;
                 x.append(rhs[0] / b);
                 tmp.append(0);
                 for (int i = 1; i < rhs.size(); i++) // Decomposition and forward substitution.
                 {
                     tmp.append(1 / b);
                     b = (i < rhs.size() - 1 ? 4.0 : 3.5) - tmp[i];
                     x.append((rhs[i] - x[i - 1]) / b);
                 }
                 for (int i = 1; i < rhs.size(); i++)
                     x[rhs.size() - i - 1] -= tmp[rhs.size() - i] * x[rhs.size() - i]; // Backsubstitution.
                 return x;
             }
             #include "moc_qsplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +8 -8

             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include "qchartglobal.h"
             #include <QtGlobal>
-            #include "qchartseries.h"
+            #include "qlineseries.h"
             #include <QList>
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QSplineSeries : public QChartSeries
+            class QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
                 public:
                 QSplineSeries(QObject *parent = 0);
-                QChartSeriesType type() const { return QChartSeries::SeriesTypeSpline; }
+                QSeriesType type() const { return QSeries::SeriesTypeSpline; }
-                void addData(QPointF value);
+            //    void addData(QPointF value);
-                QSplineSeries& operator << (const QPointF &value);
+            //    QSplineSeries& operator << (const QPointF &value);
                 void calculateControlPoints();
                 QList<qreal> getFirstControlPoints(QList<qreal> rhs);
-                int count() const { return m_data.size(); }
+                int count() const { return m_x.size(); }
-                QPointF at(int index) const { return m_data[index]; }
+            //    QPointF at(int index) const { return m_data[index]; }
                 QPointF controlPoint(int index) const { return m_controlPoints[index]; }
                 signals:
                 public slots:
                 private:
-                QList<QPointF> m_data;
+            //    QList<QPointF> m_data;
                 QList<QPointF> m_controlPoints;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/splinechart/splinepresenter.cpp +46 -12

             #include "splinepresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplinePresenter::SplinePresenter(QSplineSeries* series, QGraphicsObject *parent) :
-                LineChartItem(this, parent),m_series(series)//,m_boundingRect()
+                LineChartItem(0, series, parent)//,m_boundingRect()
             {
             //    if (parent)
             //        m_boundingRect = parent->boundingRect();
             //    else
             //        m_boundingRect = QRectF(10,50, 250, 250);
             }
             //void SplinePresenter::handleGeometryChanged(const QRectF&)
             //{
             //    update();
             //}
             //void SplinePresenter::handleDomainChanged(const Domain& domain)
             //{
             //    //
             //}
-            void SplinePresenter::updateGeometry()
+            QPointF SplinePresenter::calculateGeometryControlPoint(int index) const
             {
+                QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
+                const qreal deltaX = m_size.width()/m_domain.spanX();
+                const qreal deltaY = m_size.height()/m_domain.spanY();
+                qreal x = (splineSeries->controlPoint(index).x() - m_domain.m_minX)* deltaX;
+                qreal y = (splineSeries->controlPoint(index).y() - m_domain.m_minY)*-deltaY + m_size.height();
+                return QPointF(x,y);
+            }
+            void SplinePresenter::applyGeometry(QVector<QPointF>& points)
+            {
+               if(points.size()==0) return;
-               if(m_data.size()==0) return;
+            //   QList<QGraphicsItem*> items = m_items.childItems();
-               prepareGeometryChange();
+               QPainterPath splinePath;
-               QPainterPath path;
+               const QPointF& point = points.at(0);
-               const QPointF& point = m_data.at(0);
+               splinePath.moveTo(point);
-               path.moveTo(point);
+            //   QGraphicsItem* item = items.at(0);
+            //   item->setPos(point.x()-1,point.y()-1);
+            //   if(!m_clipRect.contains(point)) item->setVisible(false);
-               foreach( const QPointF& point , m_data) {
+               QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
-                   path.lineTo(point);
+               for (int i = 0; i < splineSeries->count() - 1; i++)
+                   {
+                   const QPointF& point = points.at(i + 1);
+            //           painter->setPen(Qt::red);
+            //           splinePath.cubicTo(qobject_cast<QSplineSeries*>(m_series)->controlPoint(2 * i), qobject_cast<QSplineSeries*>(m_series)->controlPoint(2 * i + 1), QPointF(m_series->x(i + 1), m_series->y(i + 1)));
+                   splinePath.cubicTo(calculateGeometryControlPoint(2 * i), calculateGeometryControlPoint(2 * i + 1), point);
+            //           painter->drawEllipse(m_series->at(i), 4, 4);
-               m_path = path;
+            //           painter->setPen(Qt::blue);
-               m_rect = path.boundingRect();
+            //           painter->drawLine(m_series->at(i), m_series->controlPoint(2 * i));
+            //           painter->drawLine(m_series->at(i + 1), m_series->controlPoint(2 * i + 1));
+            //           painter->drawEllipse(m_series->controlPoint(2 * i), 4, 4);
+            //           painter->drawEllipse(m_series->controlPoint(2 * i + 1), 4, 4);
+                   }
+            //   for(int i=1 ; i< points.size();i++) {
+            //       QGraphicsItem* item = items.at(i);
+            //       const QPointF& point = points.at(i);
+            //       item->setPos(point.x()-1,point.y()-1);
+            //       if(!m_clipRect.contains(point)) item->setVisible(false);
+            //       path.lineTo(point);
+            //   }
+               prepareGeometryChange();
+               m_path = splinePath;
+               m_rect = splinePath.boundingRect();
             }
             //void SplinePresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             //{
             //    Q_UNUSED(widget);
             //    Q_UNUSED(option);
             //    painter->save();
             //    painter->setPen(Qt::SolidLine);
             //    QPainterPath splinePath;
             //    splinePath.moveTo(m_series->at(0));
             //    for (int i = 0; i < m_series->count() - 1; i++)
             //    {
             //        painter->setPen(Qt::red);
             //        splinePath.cubicTo(m_series->controlPoint(2 * i), m_series->controlPoint(2 * i + 1), m_series->at(i + 1));
             //        painter->drawEllipse(m_series->at(i), 4, 4);
             //        painter->setPen(Qt::blue);
             //        painter->drawLine(m_series->at(i), m_series->controlPoint(2 * i));
             //        painter->drawLine(m_series->at(i + 1), m_series->controlPoint(2 * i + 1));
             //        painter->drawEllipse(m_series->controlPoint(2 * i), 4, 4);
             //        painter->drawEllipse(m_series->controlPoint(2 * i + 1), 4, 4);
             //    }
             //    painter->setPen(Qt::red);
             //    painter->drawPath(splinePath);
             //    painter->restore();
             //}
             #include "moc_splinepresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinepresenter_p.h +5 -1

             #ifndef SPLINEPRESENTER_P_H
             #define SPLINEPRESENTER_P_H
             #include "chartitem_p.h"
             #include <QObject>
             #include "qsplineseries.h"
             #include "linechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplinePresenter : public LineChartItem
             {
                 Q_OBJECT
             public:
                 SplinePresenter(QSplineSeries* series, QGraphicsObject *parent = 0);
                 void updateGeometry();
+                void applyGeometry(QVector<QPointF>& points);
+                QPointF calculateGeometryControlPoint(int index) const;
             //    QRectF boundingRect() const { return m_boundingRect; }
             //    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             signals:
             public slots:
             //    void handleDomainChanged(const Domain& domain);
             //    void handleGeometryChanged(const QRectF& rect);
                 private:
-                QSplineSeries* m_series;
+            //    QSplineSeries* m_series;
             //    QRectF m_boundingRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINEPRESENTER_P_H

src/src.pro 0 -5

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += axisitem.cpp \
                 axisanimationitem.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartaxis.cpp \
                 qchartview.cpp \
                 qseries.cpp
             PRIVATE_HEADERS += axisitem_p.h \
                 axisanimationitem_p.h \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h
             PUBLIC_HEADERS += qchart.h \
                 qchartaxis.h \
                 qchartglobal.h \
                 qseries.h \
                 qchartview.h
             include(linechart/linechart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
-            <<<<<<< HEAD
                 $$CHART_BUILD_LIB_DIR
-            =======
-                $$CHART_BUILD_LIB_DIR
-            >>>>>>> spline

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