HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r470:5c708e3e7c7c

Refactor scatter chart to fit the other classes...

Michal Klocek -

r470:5c708e3e7c7c

parent child

Context file:

r470:5c708e3e7c7c

Expand all files

src/scatterseries/scatterchartitem.cpp created 644 +178 0

@@ -0,0 +1,178
	1	#include "scatterchartitem_p.h"
	2	#include "qscatterseries.h"
	3	#include "chartpresenter_p.h"
	4	#include <QPainter>
	5	#include <QGraphicsScene>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	ScatterChartItem::ScatterChartItem(QScatterSeries series, QGraphicsObject parent) :
	10	XYChartItem(series,parent),
	11	m_series(series),
	12	m_items(this),
	13	m_shape(QScatterSeries::MarkerShapeRectangle),
	14	m_size(10)
	15
	16	{
	17	Q_ASSERT(parent);
	18	Q_ASSERT(series);
	19
	20	connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
	21
	22	setZValue(ChartPresenter::ScatterSeriesZValue);
	23	setFlags(QGraphicsItem::ItemHasNoContents);
	24	setFlags(QGraphicsItem::ItemClipsChildrenToShape);
	25
	26	handleUpdated();
	27
	28	// TODO: how to draw a drop shadow?
	29	// QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
	30	// dropShadow->setOffset(2.0);
	31	// dropShadow->setBlurRadius(2.0);
	32	// setGraphicsEffect(dropShadow);
	33	}
	34
	35
	36	QRectF ScatterChartItem::boundingRect() const
	37	{
	38	return m_rect;
	39	}
	40
	41	void ScatterChartItem::createPoints(int count)
	42	{
	43	for (int i = 0; i < count; ++i) {
	44
	45	QGraphicsItem *item;
	46
	47	switch (m_shape) {
	48	case QScatterSeries::MarkerShapeDefault:
	49	// Fallthrough, defaults to circle
	50	case QScatterSeries::MarkerShapeCircle:
	51	item = new QGraphicsEllipseItem(0,0,m_size,m_size);
	52	break;
	53	case QScatterSeries::MarkerShapeRectangle:
	54	item = new QGraphicsRectItem(0,0,m_size,m_size);
	55	break;
	56	case QScatterSeries::MarkerShapeRoundedRectangle:
	57	//m_path.addRoundedRect(x, y, size, size, size / 4.0, size / 4.0);
	58	break;
	59	case QScatterSeries::MarkerShapeTiltedRectangle:
	60	// TODO: tilt the rectangle
	61	//m_path.addRect(x, y, size, size);
	62	//break;
	63	case QScatterSeries::MarkerShapeTriangle:
	64	//QPolygonF polygon;
	65	//polygon << QPointF(0.0, -size) << QPointF(size / 2.0, 0.0) << QPointF(-size / 2, 0.0);
	66	// TODO: the position is not exactly right...
	67	//m_path.addPolygon(polygon.translated(x + size / 2.0, y + size));
	68	break;
	69	}
	70	m_items.addToGroup(item);
	71	}
	72	}
	73
	74	void ScatterChartItem::deletePoints(int count)
	75	{
	76	QList<QGraphicsItem *> items = m_items.childItems();
	77
	78	for (int i = 0; i < count; ++i) {
	79	delete(items.takeLast());
	80	}
	81	}
	82
	83	/*
	84
	85	void ScatterChartItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
	86	{
	87
	88	QPointF clickedPoint(
	89	m_minX + (event->lastPos().x() / m_clippingRect.width()) * (m_maxX-m_minX),
	90	m_maxY - (event->lastPos().y() / m_clippingRect.height()) * (m_maxY-m_minY));
	91	emit clicked(clickedPoint);
	92
	93	}
	94	*/
	95
	96	void ScatterChartItem::setGeometry(QVector<QPointF>& points)
	97	{
	98	if(points.size()==0) return;
	99
	100	int diff = XYChartItem::points().size() - points.size();
	101
	102	if(diff>0) {
	103	deletePoints(diff);
	104	}
	105	else if(diff<0) {
	106	createPoints(-diff);
	107	}
	108
	109	if(diff!=0) handleUpdated();
	110
	111	QList<QGraphicsItem*> items = m_items.childItems();
	112
	113	for(int i=0; i< points.size();i++) {
	114	QGraphicsItem* item = items.at(i);
	115	const QPointF& point = points.at(i);
	116	item->setPos(point.x()-1,point.y()-1);
	117	if(!clipRect().contains(point)) {
	118	item->setVisible(false);
	119	}
	120	else {
	121	item->setVisible(true);
	122	}
	123	}
	124
	125	prepareGeometryChange();
	126	m_rect = clipRect();
	127	XYChartItem::setGeometry(points);
	128	}
	129
	130
	131	void ScatterChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
	132	{
	133	Q_UNUSED(painter);
	134	Q_UNUSED(option);
	135	Q_UNUSED(widget);
	136	}
	137
	138	void ScatterChartItem::setPen(const QPen& pen)
	139	{
	140	foreach(QGraphicsItem* item , m_items.childItems()) {
	141	static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
	142	}
	143	}
	144
	145	void ScatterChartItem::setBrush(const QBrush& brush)
	146	{
	147	foreach(QGraphicsItem* item , m_items.childItems()) {
	148	static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
	149	}
	150	}
	151
	152	void ScatterChartItem::handleUpdated()
	153	{
	154
	155	int count = m_items.childItems().count();
	156
	157	if(count==0) return;
	158
	159	bool recreate = m_size != m_series->size() \|\| m_shape != m_series->shape();
	160
	161	//TODO: only rewrite on size change
	162
	163	m_size = m_series->size();
	164	m_shape = m_series->shape();
	165
	166	if(recreate){
	167	deletePoints(count);
	168	createPoints(count);
	169	}
	170
	171	setPen(m_series->pen());
	172	setBrush(m_series->brush());
	173
	174	}
	175
	176	#include "moc_scatterchartitem_p.cpp"
	177
	178	QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h created 644 +50 0

@@ -0,0 +1,50
	1	#ifndef SCATTERPRESENTER_H
	2	#define SCATTERPRESENTER_H
	3
	4	#include "qchartglobal.h"
	5	#include "xychartitem_p.h"
	6	#include <QObject>
	7	#include <QPen>
	8
	9	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	10
	11	class QScatterSeries;
	12
	13	class ScatterChartItem : public XYChartItem
	14	{
	15	Q_OBJECT
	16	public:
	17	explicit ScatterChartItem(QScatterSeries series, QGraphicsObject parent = 0);
	18
	19	public:
	20	//from QGraphicsItem
	21	QRectF boundingRect() const;
	22	void paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget);
	23
	24	void setPen(const QPen& pen);
	25	void setBrush(const QBrush& brush);
	26
	27	signals:
	28	void clicked(QPointF coordinates);
	29
	30	public slots:
	31	void handleUpdated();
	32
	33	private:
	34	void createPoints(int count);
	35	void deletePoints(int count);
	36
	37	protected:
	38	virtual void setGeometry(QVector<QPointF>& points);
	39
	40	private:
	41	QScatterSeries *m_series;
	42	QGraphicsItemGroup m_items;
	43	int m_shape;
	44	int m_size;
	45	QRectF m_rect;
	46	};
	47
	48	QTCOMMERCIALCHART_END_NAMESPACE
	49
	50	#endif // SCATTERPRESENTER_H

example/scatter/main.cpp +6 -5

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qscatterseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 //! [1]
                 // Create chart view
                 QChartView *chartView = new QChartView();
                 chartView->setRenderHint(QPainter::Antialiasing);
                 // Add scatter series with linear test data with random "noise"
                 QScatterSeries *scatter = new QScatterSeries();
                 for (qreal i(0.0); i < 20; i += 0.5) {
                     qreal x = i + (qreal)(rand() % 100) / 100.0;
                     qreal y = i + (qreal)(rand() % 100) / 100.0;
                     (*scatter) << QPointF(x, y);
                 }
                 // Chart takes ownership
                 chartView->addSeries(scatter);
                 //! [1]
                 // And more
                 //! [2]
-                *scatter << QPointF(2.0, 5.5) << QPointF(2.2, 5.4);
+               // *scatter << QPointF(2.0, 5.5) << QPointF(2.2, 5.4);
                 //! [2]
                 //! [3]
-                QBrush brush(QColor(255, 0, 0, 80), Qt::SolidPattern);
+                QBrush brush(Qt::red);
                 scatter->setBrush(brush);
-                QPen pen(QColor(0, 255, 0, 60), 3);
+                QPen pen(Qt::black);
+                pen.setWidth(3);
                 scatter->setPen(pen);
-                scatter->setShape(QScatterSeries::MarkerShapeRectangle);
+                scatter->setShape(QScatterSeries::MarkerShapeCircle);
                 scatter->setSize(25.0);
                 //! [3]
                 // Use the chart widget as the central widget
                 QMainWindow w;
                 w.resize(400, 300);
                 w.setCentralWidget(chartView);
-                w.setWindowFlags(Qt::FramelessWindowHint);
+               // w.setWindowFlags(Qt::FramelessWindowHint);
                 w.show();
                 return a.exec();
             }

example/scatterinteractions/mainwindow.cpp +3 0

             #include "mainwindow.h"
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWindow::MainWindow(QWidget *parent)
                 : QMainWindow(parent)
             {
                 resize(400, 300);
                 setWindowFlags(Qt::FramelessWindowHint);
                 QChartView *chartView = new QChartView(this);
                 chartView->setChartTitle("Click to play with points");
                 chartView->setRenderHint(QPainter::Antialiasing);
                 setCentralWidget(chartView);
                 m_scatter = new QScatterSeries();
                 for(qreal x(0.5); x <= 5.0; x += 0.5) {
                     for(qreal y(0.5); y <= 5.0; y += 0.5) {
                         *m_scatter << QPointF(x, y);
                     }
                 }
                 chartView->addSeries(m_scatter);
                 // Add two more series
                 m_scatter2 = new QScatterSeries();
                 chartView->addSeries(m_scatter2);
                 m_scatter3 = new QScatterSeries();
                 chartView->addSeries(m_scatter3);
                 connect(m_scatter, SIGNAL(clicked(QPointF)), this, SLOT(clickPoint(QPointF)));
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::clickPoint(QPointF coordinate)
             {
                 // Remove the clicked point from the series and add points to the two other series we have
+                //TODO: fix me
+                /*
                 int index = m_scatter->closestPoint(coordinate);
                 QPointF point = m_scatter->data().at(index);
                 Q_ASSERT(m_scatter->removeAt(index));
                 point.rx() += 0.25;
                 point.ry() += 0.25;
                 *m_scatter2 << point;
                 point.ry() -= 0.25;
                 *m_scatter3 << point;
+                */
             }

src/chartdataset.cpp +17 -39

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qareaseries.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()
             {
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 if(!series->parent()){
                    series->setParent(this); // take ownership
                 };
                 if(!axisY->parent()){
                    axisY->setParent(this); // take ownership
                 }
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain();
                     QObject::connect(axisY,SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeYChanged(qreal,qreal)));
                     QObject::connect(axisX(),SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeXChanged(qreal,qreal)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 calculateDomain(series,domain);
                 m_seriesAxisMap.insert(series,axisY);
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 if(series->parent()==this){
                     delete series;
                     series=0;
                 }
                 QList<QChartAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=axisY()){
                         if(axis->parent()==this){
                             delete axis;
                             axis=0;
                         }
                     }
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QSeries*> series =  m_seriesAxisMap.keys();
                 foreach(QSeries* s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
             }
             //to be removed with PIMPL
             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const
             {
                 switch(series->type())
                 {
-                    case QSeries::SeriesTypeLine: {
+                    case QSeries::SeriesTypeLine:
+                    case QSeries::SeriesTypeSpline:
+                    case QSeries::SeriesTypeScatter:
+                    {
-                        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
+                        QXYSeries* xySeries = static_cast<QXYSeries*>(series);
-                        for (int i = 0; i < lineSeries->count(); i++)
+                        qreal minX(domain->minX());
+                        qreal minY(domain->minY());
+                        qreal maxX(domain->maxX());
+                        qreal maxY(domain->maxY());
+                        for (int i = 0; i < xySeries->count(); i++)
                         {
-                            qreal x = lineSeries->x(i);
+                            qreal x = xySeries->x(i);
-                            qreal y = lineSeries->y(i);
+                            qreal y = xySeries->y(i);
+                            minX = qMin(minX, x);
+                            minY = qMin(minY, y);
+                            maxX = qMax(maxX, x);
+                            maxY = qMax(maxY, y);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         QLineSeries* upperSeries = areaSeries->upperSeries();
                         QLineSeries* lowerSeries = areaSeries->lowerSeries();
                         for (int i = 0; i < upperSeries->count(); i++)
                         {
                             qreal x = upperSeries->x(i);
                             qreal y = upperSeries->y(i);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         if(lowerSeries) {
                             for (int i = 0; i < lowerSeries->count(); i++)
                             {
                                 qreal x = lowerSeries->x(i);
                                 qreal y = lowerSeries->y(i);
                                 domain->setMinX(qMin(domain->minX(),x));
                                 domain->setMinY(qMin(domain->minY(),y));
                                 domain->setMaxX(qMax(domain->maxX(),x));
                                 domain->setMaxY(qMax(domain->maxY(),y));
                             }}
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(0);
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(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);
-                        qreal minX(domain->minX());
-                        qreal minY(domain->minY());
-                        qreal maxX(domain->maxX());
-                        qreal maxY(domain->maxY());
-                        foreach (QPointF point, scatterSeries->data()) {
-                            minX = qMin(minX, point.x());
-                            minY = qMin(minY, point.y());
-                            maxX = qMax(maxX, point.x());
-                            maxY = qMax(maxY, point.y());
-                        domain->setMinX(minX);
-                        domain->setMinY(minY);
-                        domain->setMaxX(maxX);
-                        domain->setMaxY(maxY);
-                        break;
-                    case QSeries::SeriesTypeSpline: {
-                        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
-                        for (int i = 0; i < splineSeries->count(); i++)
-                            qreal x = splineSeries->x(i);
-                            qreal y = splineSeries->y(i);
-                            domain->setMinX(qMin(domain->minX(),x));
-                            domain->setMinY(qMin(domain->minY(),y));
-                            domain->setMaxX(qMax(domain->maxX(),x));
-                            domain->setMaxY(qMax(domain->maxY(),y));
-                        break;
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QSeries* series) const
             {
             	QChartAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QChartAxis* axis) const
             {
                 if(axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             QChartAxis* ChartDataSet::axis(QSeries* series) const
             {
             	return m_seriesAxisMap.value(series);
             }
             #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 "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "areachartitem_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 "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_marginSize(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation)
             {
                 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*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 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,Domain* domain)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 if(axis==m_dataset->axisX()){
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX());
                     item->handleTicksCountChanged(4);
                 }
                 else{
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY());
                     item->handleTicksCountChanged(4);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 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,Domain* domain)
             {
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)){
                         item = new LineChartAnimationItem(lineSeries,m_chart);
                     }else{
                         item = new LineChartItem(lineSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     //decorate
                     m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     else {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                      item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                      if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                      //decorate
                     m_chartTheme->decorate(item,areaSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     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);
+                    ScatterChartItem *scatterPresenter = new ScatterChartItem(scatterSeries, m_chart);
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                      scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),
                                      scatterPresenter, SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                     m_chartItems.insert(scatterSeries, scatterPresenter);
                     if (m_rect.isValid())
                         scatterPresenter->handleGeometryChanged(m_rect);
                     scatterPresenter->handleDomainChanged(domain->minX(), domain->maxX(), domain->minY(), domain->maxY());
                     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 QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
                     SplineChartItem* splinePresenter = new SplineChartItem(splineSeries, m_chart);
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), splinePresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),splinePresenter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     splinePresenter->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     m_chartTheme->decorate(splinePresenter, splineSeries, m_chartItems.count());
                     m_chartItems.insert(splineSeries, splinePresenter);
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 delete item;
             }
             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,m_dataset->domain(axis));
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series,m_dataset->domain(series));
                     }
                 }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_marginSize, -m_marginSize);
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +6 -6

             #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 "qareaseries.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 "areachartitem_p.h"
-            #include "scatterpresenter_p.h"
+            #include "scatterchartitem_p.h"
             #include "piepresenter_p.h"
             #include "splinechartitem_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 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, 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::SeriesTypeArea: {
                                QAreaSeries* s = static_cast<QAreaSeries*>(series);
                                AreaChartItem* i = static_cast<AreaChartItem*>(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);
+                        ScatterChartItem* i = static_cast<ScatterChartItem*>(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(AreaChartItem* item, QAreaSeries* series,int count)
             {
                 QPen pen;
                 QBrush brush;
                 if(pen != series->pen()){
                    item->setPen(series->pen());
                 }else{
                     pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                     pen.setWidthF(2);
                     item->setPen(pen);
                 }
                 if(brush != series->brush()){
                    item->setBrush(series->brush());
                 }else{
                    QBrush brush(m_seriesColor.at(count%m_seriesColor.size()));
                    item->setBrush(brush);
                 }
             }
             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)
+            void ChartTheme::decorate(ScatterChartItem* item, QScatterSeries* series, int count)
             {
-                Q_ASSERT(presenter);
+                Q_ASSERT(item);
                 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;
+                item->setBrush(Qt::blue);
                 QPen pen(brush, 3);
                 pen.setColor(color);
-                presenter->m_markerPen = pen;
+                item->setPen(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->setSlicePen(c);
                     s->setSliceBrush(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(SplineChartItem* item, QSplineSeries* series, int count)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(series->pen().widthF());
                 item->setPen(pen);
             //    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 +2 -2

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
-            class ScatterPresenter;
+            class ScatterChartItem;
             class PiePresenter;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             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, QSeries* series,int count);
                 void decorate(BarPresenter* item, QBarSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count);
                 void decorate(LineChartItem* item, QLineSeries* series,int count);
                 void decorate(AreaChartItem* item, QAreaSeries* series,int count);
-                void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
+                void decorate(ScatterChartItem* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis* axis,AxisItem* item);
                 void decorate(SplineChartItem* 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/linechart/linechartitem_p.h +5 -4

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QLineSeries;
             class LineChartItem :  public XYChartItem
             {
                  Q_OBJECT
             public:
-                LineChartItem(QLineSeries* series,QGraphicsItem *parent = 0);
+                 explicit LineChartItem(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);
-                void createPoints(int count);
-                void deletePoints(int count);
             public slots:
                 void handleUpdated();
             protected:
                 virtual void setGeometry(QVector<QPointF>& points);
             private:
+                void createPoints(int count);
+                void deletePoints(int count);
+            private:
                 QLineSeries* m_series;
                 QGraphicsItemGroup m_items;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_pen;
                 friend class LineChartAnimatator;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp +29 -25

             #include "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QLineSeries* series = new QLineSeries();
             	series->add(0, 6);
             	series->add(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
-               \fn QPen QLineSeries::pen() const
+               \fn bool QLineSeries::pointsVisible() const
-               \brief  Returns the pen used to draw line for this series.
-                \sa setPen()
-            */
-            /*!
-               \fn bool  QLineSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
-            /*!
-                \fn void QLineSeries::pointReplaced(int index)
-                \brief \internal \a index
-            */
             /*!
-                \fn void QLineSeries::pointAdded(int index)
+               \fn QPen QLineSeries::linePen() const
-                \brief \internal \a index
+               \brief  Returns the pen used to draw line connecting points.
+                \sa setPen()
             */
             /*!
-                \fn void QLineSeries::pointRemoved(int index)
+                Constructs empty series object which is a child of \a parent.
-                \brief \internal \a index
+                When series object is added to QChartView or QChart instance ownerships is transfered.
             */
+            QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent),
+            m_pointsVisible(false)
+            {
+            }
             /*!
-                \fn void QLineSeries::updated()
+                Destroys the object. Series added to QChartView or QChart instances are owned by those,
-                \brief \internal
+                and are deleted when mentioned object are destroyed.
             */
+            QLineSeries::~QLineSeries()
+            {
+            }
             /*!
-                Constructs empty series object which is a child of \a parent.
+                Sets \a pen used for drawing line connecting points.
-                When series object is added to QChartView or QChart instance ownerships is transfered.
             */
-            QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent)
+            void QLineSeries::setLinePen(const QPen& pen)
             {
+                if(pen!=m_pen){
+                m_pen=pen;
+                emit updated();
+                }
             }
             /*!
-                Destroys the object. Series added to QChartView or QChart instances are owned by those,
+                Sets if data points are \a visible and should be drawn on line.
-                and are deleted when mentioned object are destroyed.
             */
-            QLineSeries::~QLineSeries()
+            void QLineSeries::setPointsVisible(bool visible)
             {
+                if(m_pointsVisible!=visible){
+                m_pointsVisible=visible;
+                emit updated();
+                }
             }
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +9 0

             #ifndef QLINESERIES_H_
             #define QLINESERIES_H_
             #include "qchartglobal.h"
             #include "qxyseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
             	Q_OBJECT
             public:
             	QLineSeries(QObject* parent=0);
             	virtual ~QLineSeries();
+            	void setLinePen(const QPen& pen);
+            	QPen linePen() const {return m_pen;}
+            	void setPointsVisible(bool visible);
+            	bool pointsVisible() const {return m_pointsVisible;}
             public: // from QChartSeries
             	virtual QSeriesType type() const {return QSeries::SeriesTypeLine;}
                 friend QDebug operator<< (QDebug d, const QLineSeries series);
+            private:
+                QPen m_pen;
+                bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterseries/qscatterseries.cpp +22 -121

             #include "qscatterseries.h"
-            #include "scatterseries_p.h"
             #include "qchart.h"
             /*!
                 \class QScatterSeries
                 \brief QtCommercial Chart series API for showing scatter series.
                 \mainclass
                 Example on how to create a chart with scatter series:
                 \snippet ../example/scatter/main.cpp 1
                 The example code would result the following:
                 \image scatter_example1.jpg
                 To customize the graphical representation of the series, you can modify pen, brush, shape and
                 size of the marker items. For example:
                 \snippet ../example/scatter/main.cpp 3
                 Would present your scatter markers as big rectangles with opaque, uglyish green outlines and
                 opaque red filling instead of the beatiful markers defined by the chart's theme:
                 \image scatter_example_custom.jpg
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeDefault
                 \value MarkerShapeX
                 \value MarkerShapeRectangle
                 \value MarkerShapeRoundedRectangle
                 \value MarkerShapeTiltedRectangle
                 \value MarkerShapeTriangle
                 \value MarkerShapeCircle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
             */
             /*!
                 \fn void QScatterSeries::clicked(QPointF coordinate)
                 User clicked the scatter series. Note that the \a coordinate is the chart coordinate that the
                 click occurred on; not necessarily a data point coordinate. To find the corresponding (closest)
                 data point you can use closestPoint().
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QScatterSeriesPrivate::QScatterSeriesPrivate(QObject *parent) :
-                QObject(parent),
-                m_data(QList<QPointF>()),
-                m_markerPen(QPen(QColor::Invalid)),
-                m_markerBrush(QBrush(QColor::Invalid)),
-                m_markerShape(QScatterSeries::MarkerShapeDefault),
-                m_markerSize(9.0)
-            void QScatterSeriesPrivate::emitChanged()
-                emit changed();
-            #include "moc_scatterseries_p.cpp"
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
-                QSeries(parent),
+                QXYSeries(parent),
-                d(new QScatterSeriesPrivate(this))
+                m_shape(QScatterSeries::MarkerShapeDefault),
+                m_size(9.0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
-                delete d;
             }
-            /*!
-                Add single data point with \a x and \a y coordinates to the series.
-            */
-            void QScatterSeries::add(qreal x, qreal y)
-                d->m_data.append(QPointF(x, y));
-                d->emitChanged();
-            /*!
-                Add single data point with \a value to the series.
-            */
-            void QScatterSeries::add(QPointF value)
-                d->m_data.append(value);
-                d->emitChanged();
-            /*!
-                Add list of \a points to the series.
-            */
-            void QScatterSeries::add(QList<QPointF> points)
-                d->m_data.append(points);
-                d->emitChanged();
             /*!
                 Stream operator for adding a data point with \a value to the series.
                 \sa add()
                 For example:
                 \snippet ../example/scatter/main.cpp 2
             */
-            QScatterSeries& QScatterSeries::operator << (const QPointF &value)
-                d->m_data.append(value);
-                d->emitChanged();
-                return *this;
             /*!
                 Stream operator for adding a list of points to the series.
                 \sa add()
             */
-            QScatterSeries& QScatterSeries::operator << (QList<QPointF> value)
-                d->m_data.append(value);
-                d->emitChanged();
-                return *this;
             /*!
                 Replaces the data of the series with the given list of data \a points.
             */
-            void QScatterSeries::setData(QList<QPointF> points)
-                d->m_data = points;
-                d->emitChanged();
             /*!
                 Returns the current list of data points of the series.
             */
-            QList<QPointF> QScatterSeries::data()
-                return d->m_data;
             /*!
                 Replaces the point at \a index with \a newPoint. Returns true if \a index is a valid position
                 in the series data, false otherwise.
             */
-            bool QScatterSeries::replace(int index, QPointF newPoint)
-                if (index >= 0 && index < d->m_data.count()) {
-                    d->m_data.replace(index, newPoint);
-                    d->emitChanged();
-                    return true;
-                return false;
             /*!
                 Remove the data point at \a index. Returns true if a point was removed, false if the point
                 at \a index does not exist on the series.
             */
-            bool QScatterSeries::removeAt(int index)
-                if (index >=0 && index < d->m_data.count()) {
-                    d->m_data.removeAt(index);
-                    d->emitChanged();
-                    return true;
-                return false;
             /*!
                 Remove all occurrences of \a point from the series and returns the number of points removed.
             */
-            int QScatterSeries::removeAll(QPointF point)
-                int count = d->m_data.removeAll(point);
-                d->emitChanged();
-                return count;
             /*!
                 Remove all data points from the series.
             */
-            void QScatterSeries::clear()
-                d->m_data.clear();
-                d->emitChanged();
             /*!
                 Returns the index of the data point that is closest to \a coordinate. If several data points
                 are at the same distance from the \a coordinate, returns the last one. If no points exist,
                 returns -1.
-            */
             int QScatterSeries::closestPoint(QPointF coordinate)
             {
                 qreal distance(-1);
                 int pointIndex(-1);
                 for (int i(0); i < d->m_data.count(); i++) {
                     QPointF dataPoint = d->m_data.at(i);
                     QPointF difference = dataPoint - coordinate;
                     if (i == 0 || difference.manhattanLength() <= distance) {
                         distance = difference.manhattanLength();
                         pointIndex = i;
                     }
                 }
                 return pointIndex;
             }
+            */
             /*!
                 Returns the pen used for drawing markers.
             */
-            QPen QScatterSeries::pen() const
-                return d->m_markerPen;
             /*!
                 Overrides the default pen used for drawing a marker item with a user defined \a pen. The
                 default pen is defined by chart theme setting.
                 \sa setBrush()
                 \sa QChart::setChartTheme()
             */
-            void QScatterSeries::setPen(const QPen &pen)
-                d->m_markerPen = pen;
-                d->emitChanged();
             /*!
                 Returns the brush used for drawing markers.
             */
-            QBrush QScatterSeries::brush() const
-                return d->m_markerBrush;
             /*!
                 Overrides the default brush of the marker items with a user defined \a brush. The default brush
                 is defined by chart theme setting.
                 \sa setPen()
                 \sa QChart::setChartTheme()
             */
-            void QScatterSeries::setBrush(const QBrush &brush)
-                d->m_markerBrush = brush;
-                d->emitChanged();
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
-                return (QScatterSeries::MarkerShape) d->m_markerShape;
+                return (QScatterSeries::MarkerShape) m_shape;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
-                d->m_markerShape = shape;
+                m_shape = shape;
-                d->emitChanged();
+                emit updated();
             }
             /*!
                 Returns the size of the marker items.
             */
             qreal QScatterSeries::size() const
             {
-                return d->m_markerSize;
+                return m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 9.0.
             */
             void QScatterSeries::setSize(qreal size)
             {
-                d->m_markerSize = size;
+                m_size = size;
-                d->emitChanged();
+                emit updated();
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +7 -24

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
-            #include "qseries.h"
+            #include "qchartglobal.h"
+            #include "qxyseries.h"
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QSeries
+            class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
                 Q_OBJECT
             public:
                 enum MarkerShape {
                     // TODO: to be defined by the graphics design
                     // TODO: marker shapes: "x", star, rectangle, tilted rect, triangle, circle, dot
                     MarkerShapeDefault = 0,
                     MarkerShapeX,
                     MarkerShapeRectangle,
                     MarkerShapeRoundedRectangle,
                     MarkerShapeTiltedRectangle,
                     MarkerShapeTriangle,
                     MarkerShapeCircle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
-                void add(qreal x, qreal y);
+                //int closestPoint(QPointF coordinate);
-                void add(QPointF value);
-                void add(QList<QPointF> points);
-                void setData(QList<QPointF> points);
-                QScatterSeries& operator << (const QPointF &value);
-                QScatterSeries& operator << (QList<QPointF> points);
-                QList<QPointF> data();
-                bool replace(int index, QPointF newPoint);
-                bool removeAt(int index);
-                int removeAll(QPointF point);
-                void clear();
-                int closestPoint(QPointF coordinate);
-                //TODO: insert, replace...?
-                QPen pen() const;
-                void setPen(const QPen &pen);
-                QBrush brush() const;
-                void setBrush(const QBrush &brush);
                 MarkerShape shape() const;
                 void setShape(MarkerShape shape);
                 qreal size() const;
                 void setSize(qreal size);
-            Q_SIGNALS:
+            signals:
                 void clicked(QPointF coordinate);
             private:
-                Q_DECLARE_PRIVATE(QScatterSeries)
+                MarkerShape m_shape;
-                Q_DISABLE_COPY(QScatterSeries)
+                qreal m_size;
-                friend class ScatterPresenter;
-                QScatterSeriesPrivate *d;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/scatterseries/scatter.pri +2 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qscatterseries.cpp \
-                $$PWD/scatterpresenter.cpp
+                $$PWD/scatterchartitem.cpp
             PRIVATE_HEADERS += \
-                $$PWD/scatterpresenter_p.h \
+                $$PWD/scatterchartitem_p.h
-                $$PWD/scatterseries_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qscatterseries.h

src/splinechart/qsplineseries.cpp +1 -1

             #include "qsplineseries.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
             */
             /*!
               \fn QSeriesType QSplineSeries::type() const
               Returns the type of the series
               */
             /*!
               \fn QSeriesType QSplineSeries::controlPoint(int index) const
               Returns the control point specified by \a index
               */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transfered.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
-                QXYSeries(parent)
+                QLineSeries(parent)
             {
                 connect(this,SIGNAL(pointAdded(int)), this, SLOT(updateControlPoints()));
                 connect(this,SIGNAL(pointRemoved(int)), this, SLOT(updateControlPoints()));
                 connect(this,SIGNAL(pointReplaced(int)), this, SLOT(updateControlPoints()));
             }
             /*!
               \internal
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeries::calculateControlPoints()
             {
                 // Based on http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit
                 // CPOL License
                 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_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_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_x[0] + 2 * m_x[1]);
                 // Set right hand side X values
                 for (int i = 1; i < n - 1; ++i)
                     rhs.append(4 * m_x[i] + 2 * m_x[i + 1]);
                 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_y[0] + 2 * m_y[1];
                 // Set right hand side Y values
                 for (int i = 1; i < n - 1; ++i)
                     rhs[i] = 4 * m_y[i] + 2 * m_y[i + 1];
                 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.
                 for (int i = 0; i < n; ++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_x[i + 1] - x[i + 1], 2 * m_y[i + 1] - y[i + 1]));
                     else
                         m_controlPoints.append(QPointF((m_x[n] + x[n - 1]) / 2, (m_y[n] + y[n - 1]) / 2));
                 }
             }
             /*!
               \internal
               */
             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;
             }
             /*!
               \internal
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeries::updateControlPoints()
             {
                 if(m_x.size() > 1)
                 {
                     m_controlPoints.clear();
                     calculateControlPoints();
                 }
             }
             #include "moc_qsplineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +2 -2

             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include "qchartglobal.h"
             #include <QtGlobal>
-            #include "qxyseries.h"
+            #include "qlineseries.h"
             #include <QList>
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QXYSeries
+            class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
             public:
                 QSplineSeries(QObject *parent = 0);
                 QSeriesType type() const {return QSeries::SeriesTypeSpline;}
             //    int count() const { return m_x.size(); }
                 QPointF controlPoint(int index) const {return m_controlPoints[index];}
                 // TODO: allow the user to set custom control points
             //    void setCustomControlPoints(QList<QPointsF> controlPoints);
             //    bool calculateControlPointsAutomatically();
             //    void setCalculateControlPointsAutomatically();
             private:
                 void calculateControlPoints();
                 QList<qreal> getFirstControlPoints(QList<qreal> rhs);
             private slots:
                 void updateControlPoints();
             private:
                 QList<QPointF> m_controlPoints;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/xychart/qxyseries.cpp +12 -35

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
-                \brief The QXYSeries class is used for making line charts.
+                \brief The QXYSeries class is a base class for line, spline and scatter series.
-                \mainclass
-            	A line chart is used to show information as a series of data points
-            	connected by straight lines.
-            	\image linechart.png
-            	Creating basic line chart is simple:
-            	\code
-            	QXYSeries* series = new QXYSeries();
-            	series->add(0, 6);
-            	series->add(2, 4);
-            	...
-            	chartView->addSeries(series);
-                \endcode
             */
             /*!
                 \fn virtual QSeriesType QXYSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn QPen QXYSeries::pen() const
-               \brief  Returns the pen used to draw line for this series.
+               \brief  Returns the pen used to draw points for this series.
                 \sa setPen()
             */
             /*!
-               \fn bool  QXYSeries::pointsVisible() const
-               \brief  Returns if the points are drawn for this series.
-                \sa setPointsVisible()
-            */
-            /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
-            QXYSeries::QXYSeries(QObject* parent):QSeries(parent),
+            QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
-            m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QPointF& point)
             {
                 add(point.x(),point.y());
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF& point)
             {
                replace(point.x(),point.y());
             }
             /*!
               Removes current \a x and y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 int index = m_x.indexOf(x);
                 emit pointRemoved(index);
                 m_x.remove(index);
                 m_y.remove(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
                 remove(point.x());
             }
             /*!
               Clears all the data.
             */
             void QXYSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             /*!
-                Sets \a pen used for drawing given series..
+                Sets \a pen used for points on the chart.
             */
             void QXYSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
-                m_pen=pen;
+                    m_pen=pen;
-                emit updated();
+                    emit updated();
                 }
             }
             /*!
-                Sets if data points are \a visible and should be drawn on line.
+                Sets \a brush used for points on the chart.
             */
-            void QXYSeries::setPointsVisible(bool visible)
+            void QXYSeries::setBrush(const QBrush& brush)
             {
-                if(m_pointsVisible!=visible){
+                if(brush!=m_brush){
-                m_pointsVisible=visible;
+                    m_brush=brush;
-                emit updated();
+                    emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 add(point);
                 return *this;
             }
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +11 -5

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
             	Q_OBJECT
-            public:
+            protected:
             	QXYSeries(QObject* parent=0);
             	virtual ~QXYSeries();
             public:
             	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();
             	int count() const;
             	qreal x(int pos) const;
             	qreal y(int pos) const;
             	QXYSeries& operator << (const QPointF &point);
+            	/*
+            	void add(QList<QPointF> points);
+                void setData(QList<QPointF> points);
+                QScatterSeries& operator << (const QPointF &value);
+                QScatterSeries& operator << (QList<QPointF> points);
+               int removeAll(QPointF point);
+            	*/
             	void setPen(const QPen& pen);
             	QPen pen() const {return m_pen;}
+                void setBrush(const QBrush& pen);
-            	void setPointsVisible(bool visible);
+                QBrush brush() const {return m_brush;}
-            	bool pointsVisible() const {return m_pointsVisible;}
             signals:
             	void updated();
             	void pointReplaced(int index);
             	void pointRemoved(int index);
             	void pointAdded(int index);
             protected:
             	QVector<qreal> m_x;
             	QVector<qreal> m_y;
             	QPen m_pen;
-            	bool m_pointsVisible;
+            	QBrush m_brush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychartitem_p.h +1 -1

             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
-                XYChartItem(QXYSeries* series,QGraphicsItem *parent = 0);
+                 explicit XYChartItem(QXYSeries* series,QGraphicsItem *parent = 0);
                 ~ XYChartItem(){};
                 QVector<QPointF> points() const {return m_points;}
                 QRectF clipRect() const { return m_clipRect;}
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 virtual void updatePoints(QVector<QPointF>& points);
                 virtual void updatePoint(int index,QPointF& newPoint);
                 virtual void setGeometry(QVector<QPointF>& points);
                 QPointF calculateGeometryPoint(const QPointF& point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterseries/scatterpresenter.cpp removed 0 -166

NO CONTENT: file was removed

src/scatterseries/scatterpresenter_p.h removed 0 -51

NO CONTENT: file was removed

src/scatterseries/scatterseries_p.h removed 0 -37

NO CONTENT: file was removed

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