HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r401:e71d8c300b9c

Spline working somewhat

Marek Rosa -

r401:e71d8c300b9c

parent child

Context file:

r401:e71d8c300b9c

Collapse all files

example/splinechart/main.cpp created 644 +11 0

@@ -0,0 +1,11
	1	#include <QtGui/QApplication>
	2	#include "splinewidget.h"
	3
	4	int main(int argc, char *argv[])
	5	{
	6	QApplication a(argc, argv);
	7	SplineWidget w;
	8	w.show();
	9
	10	return a.exec();
	11	}

example/splinechart/splinechart.pro created 644 +20 0

@@ -0,0 +1,20
	1	#-------------------------------------------------
	2	#
	3	# Project created by QtCreator 2012-02-29T12:37:46
	4	#
	5	#-------------------------------------------------
	6
	7	!include( ../example.pri ) {
	8	error( "Couldn't find the example.pri file!" )
	9	}
	10
	11	QT += core gui
	12
	13	TARGET = splinechart
	14	TEMPLATE = app
	15
	16
	17	SOURCES += main.cpp\
	18	splinewidget.cpp
	19
	20	HEADERS += splinewidget.h

example/splinechart/splinewidget.cpp created 644 +53 0

@@ -0,0 +1,53
	1	#include "splinewidget.h"
	2	#include "qchartview.h"
	3	#include "qsplineseries.h"
	4	#include "qlinechartseries.h"
	5	#include <QGridLayout>
	6
	7	QTCOMMERCIALCHART_USE_NAMESPACE
	8
	9	SplineWidget::SplineWidget(QWidget *parent)
	10	: QWidget(parent)
	11	{
	12	//create QSplineSeries
	13	QSplineSeries* series = new QSplineSeries(this);
	14	series->addData(QPointF(150, 100));
	15	series->addData(QPointF(200, 180));
	16	series->addData(QPointF(240, 130));
	17	series->addData(QPointF(270, 120));
	18	series->addData(QPointF(310, 120));
	19	series->addData(QPointF(420, 160));
	20	series->addData(QPointF(535, 250));
	21
	22	series->calculateControlPoints();
	23
	24	QLineChartSeries* lineSeries = new QLineChartSeries;
	25	for (int i = 0; i < series->count() - 1; i++)
	26	{
	27	lineSeries->add(series->at(i).x(), series->at(i).y());
	28	lineSeries->add(series->controlPoint(2i).x(), series->controlPoint(2i).y());
	29	lineSeries->add(series->controlPoint(2i + 1).x(), series->controlPoint(2i + 1).y());
	30	}
	31
	32	// QLineChartSeries* lineSeries2 = new QLineChartSeries;
	33	// lineSeries2->add(10, 50);
	34	// lineSeries2->add(30, 15);
	35	// lineSeries2->add(60, 40);
	36	// lineSeries2->add(90, 70);
	37	// lineSeries2->add(100, 20);
	38
	39	//create chart view
	40	QChartView* chart = new QChartView;
	41	chart->setMinimumSize(800,600);
	42	// chart->setGeometry(50, 50, 400, 300);
	43	chart->addSeries(series);
	44
	45	QGridLayout* mainLayout = new QGridLayout;
	46	mainLayout->addWidget(chart);
	47	setLayout(mainLayout);
	48	}
	49
	50	SplineWidget::~SplineWidget()
	51	{
	52
	53	}

example/splinechart/splinewidget.h created 644 +15 0

@@ -0,0 +1,15
	1	#ifndef SPLINEWIDGET_H
	2	#define SPLINEWIDGET_H
	3
	4	#include <QtGui/QWidget>
	5
	6	class SplineWidget : public QWidget
	7	{
	8	Q_OBJECT
	9
	10	public:
	11	SplineWidget(QWidget *parent = 0);
	12	~SplineWidget();
	13	};
	14
	15	#endif // SPLINEWIDGET_H

example/example.pro +2 -1

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
-                       presenterchart
+                       presenterchart \
+                splinechart

src/chartdataset.cpp +16 0

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlinechartseries.h"
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.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(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);
                     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";
                     QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(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";
                     QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(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";
                     QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(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;
                 }
+                case QChartSeries::SeriesTypeSpline: {
+                    QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
+                    for (int i = 0; i < splineSeries->count(); i++)
+                    {
+                        qreal x = splineSeries->at(i).x();
+                        qreal y = splineSeries->at(i).y();
+                        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(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 +5 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_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"
             #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()))
             {
                 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);
+                //    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(axis==m_dataset->axisX()){
                     item = new AxisItem(AxisItem::X_AXIS,m_chart);
                 }else{
                     item = new AxisItem(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);
                     LineChartItem* item = new LineChartAnimationItem(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: {
                     QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(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: {
                     QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(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: {
                     QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(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(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&)));
                     m_chartItems.insert(series, pie);
                     break;
                 }
                 case QChartSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
-                    SplinePresenter* splinePresenter = new SplinePresenter
+                    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;
                 }
                 }
                 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();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),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();
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +19 0

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "qbarset.h"
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
+            #include "qsplineseries.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"
+            #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));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     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);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarChartSeries* b = static_cast<QBarChartSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarChartSeries* s = static_cast<QStackedBarChartSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarChartSeries* s = static_cast<QPercentBarChartSeries*>(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)
             {
                 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, QBarChartSeries* 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, QStackedBarChartSeries* 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, QPercentBarChartSeries* 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();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     s->setPen(QPen(Qt::black)); // TODO: get from theme
                     s->setBrush(colors.takeFirst());
                 }
             }
             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/charttheme_p.h +3 0

             #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 BarPresenter;
             class QBarChartSeries;
             class StackedBarPresenter;
             class QStackedBarChartSeries;
             class QPercentBarChartSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
+            class SplinePresenter;
+            class QSplineSeries;
             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, QBarChartSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarChartSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarChartSeries* series,int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis* axis,AxisItem* item);
+                void decorate(SplinePresenter* presenter, QSplineSeries* series, int count);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/splinechart/qsplineseries.cpp +64 -54

@@ -1,100 +1,110
1	#include "qsplineseries.h"	1	#include "qsplineseries.h"
2		2
		3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
		4
3	QSplineSeries::QSplineSeries(QObject *parent) :	5	QSplineSeries::QSplineSeries(QObject *parent) :
4	Q~~Object~~(parent)	6	QChartSeries(parent)
5	{	7	{
6	}	8	}
7		9
8	QSplineSeries& QSplineSeries::operator << (const QPointF &value)	10	QSplineSeries& QSplineSeries::operator << (const QPointF &value)
9	{	11	{
10	d->m_data.append(value);	12	// d->m_data.append(value);
11	emit changed();	13	m_data.append(value);
		14	// emit changed();
12	return *this;	15	return *this;
13	}	16	}
14		17
15	void QSplineSeries::~~GetCurveControlPoints~~()	18	void QSplineSeries::addData(QPointF value)
16	{	19	{
		20	m_data.append(value);
		21	}
		22
		23	void QSplineSeries::calculateControlPoints()
		24	{
		25
		26	// Based on http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit
		27	// CPOL Licence
		28
17	int n = m_data.size() - 1;	29	int n = m_data.size() - 1;
18	if (n < 1)
19	throw new ArgumentException
20	("At least two knot points required", "knots");
21	if (n == 1)	30	if (n == 1)
22	{ // Special case: Bezier curve should be a straight line.	31	{ // Special case: Bezier curve should be a straight line.
23	firstControlPoints = new Point[1];	32	// firstControlPoints = new Point[1];
24	// 3P1 = 2P0 + P3	33	// 3P1 = 2P0 + P3
25	firstControlPoints[0].X = (2 * knots[0].X + knots[1].X) / 3;	34	m_controlPoints.append(QPointF((2 * m_data[0].x() + m_data[1].x()) / 3, (2 * m_data[0].y() + m_data[1].y()) / 3));
26	firstControlPoints[0].Y = (2 * knots[0].Y + knots[1].Y) / 3;
27		35
28	secondControlPoints = new Point[1];
29	// P2 = 2P1 P0	36	// P2 = 2P1 P0
30	secondControlPoints[0].X = 2 *	37	m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - m_data[0].x(), 2 * m_controlPoints[0].y() - m_data[0].y()));
31	firstControlPoints[0].X - knots[0].X;
32	secondControlPoints[0].Y = 2 *
33	firstControlPoints[0].Y - knots[0].Y;
34	return;	38	return;
35	}	39	}
36		40
37	// Calculate first Bezier control points	41	// Calculate first Bezier control points
38	// Right hand side vector	42	// Right hand side vector
39	double[] rhs = new double[n];	43	// Set of equations for P0 to Pn points.
		44	//
		45	// \| 2 1 0 0 ... 0 0 0 ... 0 0 0 \| \| P1_1 \| \| P0 + 2 * P1 \|
		46	// \| 1 4 1 0 ... 0 0 0 ... 0 0 0 \| \| P1_2 \| \| 4 * P1 + 2 * P2 \|
		47	// \| 0 1 4 1 ... 0 0 0 ... 0 0 0 \| \| P1_3 \| \| 4 * P2 + 2 * P3 \|
		48	// \| . . . . . . . . . . . . \| \| ... \| \| ... \|
		49	// \| 0 0 0 0 ... 1 4 1 ... 0 0 0 \| * \| P1_i \| = \| 4 * P(i-1) + 2 * Pi \|
		50	// \| . . . . . . . . . . . . \| \| ... \| \| ... \|
		51	// \| 0 0 0 0 0 0 0 0 ... 1 4 1 \| \| P1_(n-1)\| \| 4 * P(n-2) + 2 * P(n-1) \|
		52	// \| 0 0 0 0 0 0 0 0 ... 0 2 7 \| \| P1_n \| \| 8 * P(n-1) + Pn \|
		53	//
		54	QList<qreal> rhs;
		55	rhs.append(m_data[0].x() + 2 * m_data[1].x());
40		56
41	// Set right hand side X values	57	// Set right hand side X values
42	for (int i = 1; i < n - 1; ++i)	58	for (int i = 1; i < m_data.size() - 1; ++i)
43	rhs[i] = 4 * ~~knots~~[i].X + 2 * ~~knots~~[i + 1].X;	59	rhs.append(4 * m_data[i].x() + 2 * m_data[i + 1].x());
44	rhs[0] = knots[0].X + 2 * knots[1].X;	60
45	rhs[n - 1] = (8 * ~~knots~~[n - 1].X + ~~knots~~[n].X) / 2.0;	61	rhs.append((8 * m_data[n - 1].x() + m_data[n].x()) / 2.0);
46	// Get first control points X-values	62	// Get first control points X-values
47	~~double~~[] x = GetFirstControlPoints(rhs);	63	QList<qreal> x = getFirstControlPoints(rhs);
		64	rhs[0] = m_data[0].y() + 2 * m_data[1].y();
48		65
49	// Set right hand side Y values	66	// Set right hand side Y values
50	for (int i = 1; i < n - 1; ++i)	67	for (int i = 1; i < m_data.size() - 1; ++i)
51	rhs[i] = 4 * ~~knots~~[i].Y + 2 * ~~knots~~[i + 1].Y;	68	rhs[i] = 4 * m_data[i].y() + 2 * m_data[i + 1].y();
52	rhs[0] = knots[0].Y + 2 * knots[1].Y;	69
53	rhs[n - 1] = (8 * ~~knots~~[n - 1].Y + ~~knots~~[n].Y) / 2.0;	70	rhs[n - 1] = (8 * m_data[n - 1].y() + m_data[n].y()) / 2.0;
54	// Get first control points Y-values	71	// Get first control points Y-values
55	~~double~~[] y = GetFirstControlPoints(rhs);	72	QList<qreal> y = getFirstControlPoints(rhs);
56		73
57	// Fill output arrays.	74	// Fill output arrays.
58	firstControlPoints = new Point[n];	75	// firstControlPoints = new Point[n];
59	secondControlPoints = new Point[n];	76	// secondControlPoints = new Point[n];
60	for (int i = 0; i < n; ++i)	77	for (int i = 0; i < m_data.size(); ++i)
61	{	78	{
62	// First control point	79	// First control point
63	~~firstC~~ontrolPoints[i] = ~~new~~ ~~Point~~(x[i], y[i]);	80	m_controlPoints.append(QPointF(x[i], y[i]));
64	// Second control point	81	// Second control point
65	if (i < n - 1)	82	if (i < n - 1)
66	secondControlPoints[i] = new Point(2 * knots	83	m_controlPoints.append(QPointF(2 * m_data[i + 1].x() - x[i + 1], 2 * m_data[i + 1].y() - y[i + 1]));
67	[i + 1].X - x[i + 1], 2 *
68	knots[i + 1].Y - y[i + 1]);
69	else	84	else
70	secondControlPoints[i] = new Point((knots	85	m_controlPoints.append(QPointF((m_data[n].x() + x[n - 1]) / 2, (m_data[n].y() + y[n - 1]) / 2));
71	[n].X + x[n - 1]) / 2,
72	(knots[n].Y + y[n - 1]) / 2);
73	}	86	}
74	}	87	}
75		88
76	/// <summary>	89	QList<qreal> QSplineSeries::getFirstControlPoints(QList<qreal> rhs)
77	/// Solves a tridiagonal system for one of coordinates (x or y)
78	/// of first Bezier control points.
79	/// </summary>
80	/// <param name="rhs">Right hand side vector.</param>
81	/// <returns>Solution vector.</returns>
82	void GetFirstControlPoints(qreal[] rhs)
83	{	90	{
84	int n = rhs.Length;	91	QList<qreal> x; // Solution vector.
85	double[] x = new double[n]; // Solution vector.	92	QList<qreal> tmp; // Temp workspace.
86	double[] tmp = new double[n]; // Temp workspace.
87		93
88	~~double~~ b = 2.0;	94	qreal b = 2.0;
89	x[0] = rhs[0] / b;	95	x.append(rhs[0] / b);
90	for (int i = 1; i < n; i++) // Decomposition and forward substitution.	96	tmp.append(0);
		97	for (int i = 1; i < rhs.size(); i++) // Decomposition and forward substitution.
91	{	98	{
92	tmp[i] = 1 / b;	99	tmp.append(1 / b);
93	b = (i < n - 1 ? 4.0 : 3.5) - tmp[i];	100	b = (i < rhs.size() - 1 ? 4.0 : 3.5) - tmp[i];
94	x[i] = (rhs[i] - x[i - 1]) / b;	101	x.append((rhs[i] - x[i - 1]) / b);
95	}	102	}
96	for (int i = 1; i < n; i++)	103	for (int i = 1; i < rhs.size(); i++)
97	x[n - i - 1] -= tmp[n - i] * x[n - i]; // Backsubstitution.	104	x[rhs.size() - i - 1] -= tmp[rhs.size() - i] * x[rhs.size() - i]; // Backsubstitution.
98		105
99	return x;	106	return x;
100	}	107	}
		108	#include "moc_qsplineseries.cpp"
		109
		110	QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +10 0

             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
+            #include "qchartglobal.h"
+            #include <QtGlobal>
             #include "qchartseries.h"
+            #include <QList>
+            #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeries : public QChartSeries
             {
                 Q_OBJECT
                 public:
                 QSplineSeries(QObject *parent = 0);
                 QChartSeriesType type() const { return QChartSeries::SeriesTypeSpline; }
                 void addData(QPointF value);
                 QSplineSeries& operator << (const QPointF &value);
                 void calculateControlPoints();
+                QList<qreal> getFirstControlPoints(QList<qreal> rhs);
+                int count() const { return m_data.size(); }
+                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_controlPoints;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/splinechart/splinechart.pri +3 -6

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qsplineseries.cpp \
-                splinechart/splinepresenter.cpp
+                $$PWD/splinepresenter.cpp
-            PRIVATE_HEADERS +=
+            PRIVATE_HEADERS += \
+                $$PWD/splinepresenter_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qsplineseries.h
-            HEADERS += \
-                splinechart/qsplineseries.h \
-                splinechart/splinepresenter_p.h

src/splinechart/splinepresenter.cpp +41 -3

@@ -1,16 +1,54
1	#include "splinepresenter_p.h"	1	#include "splinepresenter_p.h"
		2	#include <QPainter>
2		3
3	SplinePresenter::SplinePresenter(QObject *parent) :	4	QTCOMMERCIALCHART_BEGIN_NAMESPACE
4	QObject(parent)	5
		6	SplinePresenter::SplinePresenter(QSplineSeries* series, QGraphicsObject *parent) :
		7	ChartItem(parent),m_series(series),m_boundingRect()
5	{	8	{
		9	if (parent)
		10	m_boundingRect = parent->boundingRect();
		11	else
		12	m_boundingRect = QRectF(10,50, 250, 250);
6	}	13	}
7		14
8	void SplinePresenter::handleGeometryChanged(const QRectF&)	15	void SplinePresenter::handleGeometryChanged(const QRectF&)
9	{	16	{
10	//	17	update();
11	}	18	}
12		19
13	void SplinePresenter::handleDomainChanged(const Domain& domain)	20	void SplinePresenter::handleDomainChanged(const Domain& domain)
14	{	21	{
15	//	22	//
16	}	23	}
		24
		25	void SplinePresenter::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
		26	{
		27	Q_UNUSED(widget);
		28	Q_UNUSED(option);
		29	painter->save();
		30
		31	painter->setPen(Qt::SolidLine);
		32
		33	QPainterPath splinePath;
		34	splinePath.moveTo(m_series->at(0));
		35	for (int i = 0; i < m_series->count() - 1; i++)
		36	{
		37	painter->setPen(Qt::red);
		38	splinePath.cubicTo(m_series->controlPoint(2 * i), m_series->controlPoint(2 * i + 1), m_series->at(i + 1));
		39	painter->drawEllipse(m_series->at(i), 4, 4);
		40
		41	painter->setPen(Qt::blue);
		42	painter->drawLine(m_series->at(i), m_series->controlPoint(2 * i));
		43	painter->drawLine(m_series->at(i + 1), m_series->controlPoint(2 * i + 1));
		44	painter->drawEllipse(m_series->controlPoint(2 * i), 4, 4);
		45	painter->drawEllipse(m_series->controlPoint(2 * i + 1), 4, 4);
		46	}
		47	painter->setPen(Qt::red);
		48	painter->drawPath(splinePath);
		49	painter->restore();
		50	}
		51
		52	#include "moc_splinepresenter_p.cpp"
		53
		54	QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinepresenter_p.h +10 -3

             #ifndef SPLINEPRESENTER_P_H
             #define SPLINEPRESENTER_P_H
             #include "chartitem_p.h"
             #include <QObject>
+            #include "qsplineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplinePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
-                SplinePresenter(QObject *parent = 0);
+                SplinePresenter(QSplineSeries* series, QGraphicsObject *parent = 0);
-                void handleGeometryChanged(const QRectF&);
+                QRectF boundingRect() const { return m_boundingRect; }
-                void handleDomainChanged(const Domain& domain);
+                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;
+                QRectF m_boundingRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINEPRESENTER_P_H

test/chartwidgettest/dataseriedialog.cpp +1 -1

             #include "dataseriedialog.h"
             #include <QDialogButtonBox>
             #include <QGridLayout>
-            #include <QCheckbox>
+            #include <QCheckBox>
             #include <QPushButton>
             #include <QGroupBox>
             #include <QRadioButton>
             #include <QLabel>
             #include <QDebug>
             DataSerieDialog::DataSerieDialog(QString defaultType, QWidget *parent) :
                 QDialog(parent)
             {
                 QDialogButtonBox *addSeriesBox = new QDialogButtonBox(Qt::Horizontal);
                 QPushButton *b = addSeriesBox->addButton(QDialogButtonBox::Ok);
                 connect(b, SIGNAL(clicked()), this, SLOT(accept()));
                 b = addSeriesBox->addButton(QDialogButtonBox::Cancel);
                 connect(b, SIGNAL(clicked()), this, SLOT(reject()));
                 QGridLayout *grid = new QGridLayout();
                 m_seriesTypeSelector = seriesTypeSelector();
                 m_columnCountSelector = columnCountSelector();
                 m_rowCountSelector = rowCountSelector();
                 m_dataCharacteristicsSelector = dataCharacteristicsSelector();
                 grid->addWidget(m_seriesTypeSelector, 0, 0);
                 grid->addWidget(m_columnCountSelector, 0, 1);
                 grid->addWidget(m_rowCountSelector, 1, 1);
                 grid->addWidget(m_dataCharacteristicsSelector, 1, 0);
                 m_labelsSelector = new QCheckBox("Labels defined");
                 m_labelsSelector->setChecked(true);
                 grid->addWidget(m_labelsSelector, 2, 0);
                 grid->addWidget(addSeriesBox, 3, 1);
                 setLayout(grid);
             }
             QGroupBox *DataSerieDialog::seriesTypeSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *line = new QRadioButton("Line");
                 line->setChecked(true);
                 layout->addWidget(line);
                 layout->addWidget(new QRadioButton("Area"));
                 layout->addWidget(new QRadioButton("Pie"));
                 layout->addWidget(new QRadioButton("Bar"));
                 layout->addWidget(new QRadioButton("Stacked bar"));
                 layout->addWidget(new QRadioButton("Percent bar"));
                 layout->addWidget(new QRadioButton("Scatter"));
                 layout->addWidget(new QRadioButton("Spline"));
                 QGroupBox *groupBox = new QGroupBox("Series type");
                 groupBox->setLayout(layout);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::columnCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *radio = new QRadioButton("1");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("2"));
                 layout->addWidget(new QRadioButton("3"));
                 layout->addWidget(new QRadioButton("5"));
                 layout->addWidget(new QRadioButton("10"));
                 layout->addWidget(new QRadioButton("100"));
                 QGroupBox *groupBox = new QGroupBox("Column count");
                 groupBox->setLayout(layout);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::rowCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("1"));
                 QRadioButton *radio = new QRadioButton("10");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("50"));
                 layout->addWidget(new QRadioButton("100"));
                 layout->addWidget(new QRadioButton("10000"));
                 layout->addWidget(new QRadioButton("1000000"));
                 QGroupBox *groupBox = new QGroupBox("Row count");
                 groupBox->setLayout(layout);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::dataCharacteristicsSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *radio1 = new QRadioButton("Linear");
                 radio1->setChecked(true);
                 layout->addWidget(radio1);
                 layout->addWidget(new QRadioButton("Constant"));
                 layout->addWidget(new QRadioButton("Random"));
                 layout->addWidget(new QRadioButton("Sin"));
                 layout->addWidget(new QRadioButton("Sin + random"));
                 QGroupBox *groupBox = new QGroupBox("Data Characteristics");
                 groupBox->setLayout(layout);
                 return groupBox;
             }
             void DataSerieDialog::accept()
             {
                 accepted(radioSelection(m_seriesTypeSelector),
                          radioSelection(m_columnCountSelector).toInt(),
                          radioSelection(m_rowCountSelector).toInt(),
                          radioSelection(m_dataCharacteristicsSelector),
                          m_labelsSelector->isChecked());
                 QDialog::accept();
             }
             QString DataSerieDialog::radioSelection(QGroupBox *groupBox)
             {
                 QString selection;
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 for (int i(0); i < layout->count(); i++) {
                     QLayoutItem *item = layout->itemAt(i);
                     Q_ASSERT(item);
                     QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                     Q_ASSERT(radio);
                     if (radio->isChecked()) {
                         selection = radio->text();
                         break;
                     }
                 }
                 qDebug() << "radioSelection: " << selection;
                 return selection;
             }

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