HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r465:7f683774d508

Refactor line spline to common xyline...

Michal Klocek -

r465:7f683774d508

parent child

Context file:

r465:7f683774d508

Collapse all files

example/example.pro +1 -1

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
                        piechartcustomization \
                        piechartdrilldown \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
                        chartview \
                        scatterinteractions \
-                       #splinechart \
+                       splinechart \
                        areachart \
                        stackedbarchartdrilldown

src/linechart/linechartanimationitem.cpp +2 -3

             #include "linechartanimationitem_p.h"
             #include "linechartitem_p.h"
             #include <QPropertyAnimation>
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 500;
             LineChartAnimationItem::LineChartAnimationItem(QLineSeries* series,QGraphicsItem *parent):
             LineChartItem(series,parent),
             m_animation(new LineChartAnimatator(this,this)),
             m_dirty(false)
             {
             }
             LineChartAnimationItem::~LineChartAnimationItem()
             {
             }
-            void LineChartAnimationItem::updateAllPoints()
+            void LineChartAnimationItem::updatePoints(QVector<QPointF>& newPoints)
             {
                 QVector<QPointF> oldPoints = points();
-                LineChartItem::updateAllPoints();
+                LineChartItem::updatePoints(newPoints);
-                QVector<QPointF> newPoints = points();
                 if(newPoints.count()==0) return;
                 oldPoints.resize(newPoints.size());
                 if(m_animation->state()!=QAbstractAnimation::Stopped){
                    m_animation->stop();
                 }
                 m_animation->setDuration(duration);
                 m_animation->setEasingCurve(QEasingCurve::InOutBack);
                 m_animation->setKeyValueAt(0.0, qVariantFromValue(oldPoints));
                 m_animation->setKeyValueAt(1.0, qVariantFromValue(newPoints));
                 QTimer::singleShot(0,m_animation,SLOT(start()));
                 m_points = newPoints;
                 m_dirty=false;
             }
             void LineChartAnimationItem::updatePoint(int index,QPointF& newPoint)
             {
                 if(m_animation->state()!=QAbstractAnimation::Stopped){
                    m_animation->stop();
                    m_dirty=true;
                 }
                 if(m_dirty){
                 	m_points=points();
                 	m_dirty=false;
                 }
                 LineChartItem::updatePoint(index,newPoint);
                 m_animation->setDuration(duration);
                 m_animation->setEasingCurve(QEasingCurve::InOutBack);
                 m_animation->setKeyValueAt(0.0, qVariantFromValue(m_points));
                 m_animation->setKeyValueAt(1.0, qVariantFromValue( points()));
                 QTimer::singleShot(0,this,SLOT(startAnimation()));
             }
             void LineChartAnimationItem::startAnimation()
             {
             	 m_dirty=true;
             	 m_animation->start();
             }
             LineChartAnimatator::LineChartAnimatator(LineChartAnimationItem *item , QObject *parent):QVariantAnimation(parent),
                 m_item(item)
             {
             }
             LineChartAnimatator::~LineChartAnimatator()
             {
             }
             QVariant LineChartAnimatator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
             {
             	QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
             	QVector<QPointF> endVecotr = qVariantValue<QVector<QPointF> >(end);
             	QVector<QPointF> result;
                 Q_ASSERT(startVector.count() == endVecotr.count());
                 for(int i =0 ;i< startVector.count();i++){
                        qreal x = startVector[i].x() + ((endVecotr[i].x()- startVector[i].x()) * progress);//qBound(0.0, progress, 1.0));
                        qreal y = startVector[i].y() + ((endVecotr[i].y()- startVector[i].y()) * progress);//qBound(0.0, progress, 1.0));
                        result << QPointF(x,y);
                 }
                 return qVariantFromValue(result);
             }
             void LineChartAnimatator::updateCurrentValue (const QVariant & value )
             {
             	QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
             	if(state()!=QAbstractAnimation::Stopped){ //workaround
                 m_item->setGeometry(vector);
             	}
             }
             #include "moc_linechartanimationitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartanimationitem_p.h +1 -1

             #ifndef LINECHARTANIMATIONITEM_P_H_
             #define LINECHARTANIMATIONITEM_P_H_
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include "domain_p.h"
             #include <QVariantAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class LineChartAnimatator;
             class LineChartAnimationItem : public LineChartItem {
             	Q_OBJECT
             public:
             	LineChartAnimationItem(QLineSeries *series, QGraphicsItem *parent = 0);
             	virtual ~LineChartAnimationItem();
             protected:
-            	 virtual void updateAllPoints();
+            	 virtual void updatePoints(QVector<QPointF>& newPoints);
             	 virtual void updatePoint(int index,QPointF& newPoint);
             private slots:
             	void startAnimation();
             private:
                 LineChartAnimatator *m_animation;
                 QVector<QPointF> m_points;
                 bool m_dirty;
             };
             class LineChartAnimatator: public QVariantAnimation
             {
             public:
                 LineChartAnimatator(LineChartAnimationItem *item, QObject *parent = 0 );
                 ~LineChartAnimatator();
             protected:
                 QVariant interpolated(const QVariant &start, const QVariant & end, qreal progress ) const;
                 void updateCurrentValue (const QVariant & value );
             private:
                 LineChartAnimationItem* m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/linechartitem.cpp +35 -156

@@ -1,245 +1,124
1	#include "linechartitem_p.h"	1	#include "linechartitem_p.h"
2	#include "qlineseries.h"	2	#include "qlineseries.h"
3	#include "chartpresenter_p.h"	3	#include "chartpresenter_p.h"
4	#include <QPainter>	4	#include <QPainter>
5		5
6		6
7	QTCOMMERCIALCHART_BEGIN_NAMESPACE	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
8		8
9	//TODO: optimize : remove points which are not visible	9	//TODO: optimize : remove points which are not visible
10		10
11	LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),	11	LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):XYChartItem(series,parent),
12	m_minX(0),
13	m_maxX(0),
14	m_minY(0),
15	m_maxY(0),
16	m_series(series),	12	m_series(series),
17	m_items(this)	13	m_items(this)
18	{	14	{
19	//m_items.setZValue(ChartPresenter::LineChartZValue);	15	//m_items.setZValue(ChartPresenter::LineChartZValue);
20	setZValue(ChartPresenter::LineChartZValue);	16	setZValue(ChartPresenter::LineChartZValue);
21
22	QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
23	QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
24	QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
25	QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));	17	QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
26		18
27	handleUpdated();	19	handleUpdated();
28	}	20	}
29		21
30	QRectF LineChartItem::boundingRect() const	22	QRectF LineChartItem::boundingRect() const
31	{	23	{
32	return m_rect;	24	return m_rect;
33	}	25	}
34		26
35	QPainterPath LineChartItem::shape() const	27	QPainterPath LineChartItem::shape() const
36	{	28	{
37	return m_path;	29	return m_path;
38	}	30	}
39		31
40	void LineChartItem::createPoints(int count)	32	void LineChartItem::createPoints(int count)
41	{	33	{
42	for (int i = 0; i < count; ++i) {	34	for (int i = 0; i < count; ++i) {
43	QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3);	35	QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3);
44	m_items.addToGroup(item);	36	m_items.addToGroup(item);
45	}	37	}
46	}	38	}
47		39
48	void LineChartItem::~~clear~~Points(int count)	40	void LineChartItem::deletePoints(int count)
49	{	41	{
50	QList<QGraphicsItem *> items = m_items.childItems();	42	QList<QGraphicsItem *> items = m_items.childItems();
51		43
52	for (int i = 0; i < count; ++i) {	44	for (int i = 0; i < count; ++i) {
53	delete(items.takeLast());	45	delete(items.takeLast());
54	}	46	}
55	}	47	}
56		48
57	~~QPointF~~ LineChartItem::~~calculate~~Geometry~~Point~~(int ~~index~~) ~~const~~	49	void LineChartItem::setGeometry(QVector<QPointF>& points)
58	{
59	const qreal deltaX = m_size.width()/(m_maxX-m_minX);
60	const qreal deltaY = m_size.height()/(m_maxY-m_minY);
61	qreal x = (m_series->x(index) - m_minX)* deltaX;
62	qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
63	return QPointF(x,y);
64	}
65
66	QVector<QPointF> LineChartItem::calculateGeometryPoints() const
67	{
68	const qreal deltaX = m_size.width()/(m_maxX-m_minX);
69	const qreal deltaY = m_size.height()/(m_maxY-m_minY);
70
71	QVector<QPointF> points;
72	points.reserve(m_series->count());
73	for (int i = 0; i < m_series->count(); ++i) {
74	qreal x = (m_series->x(i) - m_minX)* deltaX;
75	qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
76	points << QPointF(x,y);
77	}
78	return points;
79	}
80
81	void LineChartItem::updateAllPoints()
82	{	50	{
83	QVector<QPointF> points = calculateGeometryPoints();	51	if(points.size()==0) return;
84		52
85	int diff = m_points.size() - points.size();	53	int diff = XYChartItem::points().size() - points.size();
86		54
87	if(diff>0) {	55	if(diff>0) {
88	~~clear~~Points(diff);	56	deletePoints(diff);
89	}	57	}
90	else if(diff<0) {	58	else if(diff<0) {
91	createPoints(-diff);	59	createPoints(-diff);
92	}	60	}
93		61
94	setGeometry(points);	62	QList<QGraphicsItem*> items = m_items.childItems();
95	}
96
97	void LineChartItem::updatePoints(QVector<QPointF>& points)
98	{
99	int diff = m_points.size() - points.size();
100		63
101	if(diff>0) {	64	QPainterPath path;
102	clearPoints(diff);	65	const QPointF& point = points.at(0);
103	}	66	path.moveTo(point);
104	else if(diff<0) {	67	QGraphicsItem* item = items.at(0);
105	createPoints(-diff);	68	item->setPos(point.x()-1,point.y()-1);
106	}	69	if(!clipRect().contains(point)) {
		70	item->setVisible(false);
		71	}
		72	else {
		73	item->setVisible(true);
		74	}
107		75
108	setGeometry(points);	76	for(int i=1; i< points.size();i++) {
109	}	77	QGraphicsItem* item = items.at(i);
		78	const QPointF& point = points.at(i);
		79	item->setPos(point.x()-1,point.y()-1);
		80	if(!clipRect().contains(point)) {
		81	item->setVisible(false);
		82	}
		83	else {
		84	item->setVisible(true);
		85	}
		86	path.lineTo(point);
		87	}
110		88
111	void LineChartItem::updatePoint(int index,QPointF& newPoint)	89	prepareGeometryChange();
112	{	90	m_path = path;
113	m_points.replace(index,newPoint);	91	m_rect = path.boundingRect();
114	setGeometry(m_points);
115	}
116		92
117	~~void~~ ~~Line~~ChartItem::setGeometry(~~QVector~~<~~QPointF~~>& points)	93	XYChartItem::setGeometry(points);
118	{
119	if(points.size()==0) return;
120
121	QList<QGraphicsItem*> items = m_items.childItems();
122
123	QPainterPath path;
124	const QPointF& point = points.at(0);
125	path.moveTo(point);
126	QGraphicsItem* item = items.at(0);
127	item->setPos(point.x()-1,point.y()-1);
128	if(!m_clipRect.contains(point)) {
129	item->setVisible(false);
130	}else{
131	item->setVisible(true);
132	}
133
134	for(int i=1 ; i< points.size();i++) {
135	QGraphicsItem* item = items.at(i);
136	const QPointF& point = points.at(i);
137	item->setPos(point.x()-1,point.y()-1);
138	if(!m_clipRect.contains(point)) {
139	item->setVisible(false);
140	}else{
141	item->setVisible(true);
142	}
143	path.lineTo(point);
144	}
145
146	prepareGeometryChange();
147	m_path = path;
148	m_rect = path.boundingRect();
149	m_points = points;
150	}	94	}
151		95
152	void LineChartItem::setPen(const QPen& pen)	96	void LineChartItem::setPen(const QPen& pen)
153	{	97	{
154	m_pen = pen;	98	m_pen = pen;
155	}	99	}
156		100
157	//handlers
158
159	void LineChartItem::handlePointAdded(int index)
160	{
161	Q_ASSERT(index<m_series->count());
162	Q_ASSERT(index>=0);
163
164	QPointF point = calculateGeometryPoint(index);
165	createPoints(1);
166	QVector<QPointF> points = m_points;
167	points.insert(index,point);
168
169	updatePoints(points);
170	update();
171	}
172	void LineChartItem::handlePointRemoved(int index)
173	{
174	Q_ASSERT(index<m_series->count());
175	Q_ASSERT(index>=0);
176
177	QPointF point = calculateGeometryPoint(index);
178	clearPoints(1);
179	QVector<QPointF> points = m_points;
180	points.remove(index);
181	updatePoints(points);
182	update();
183	}
184
185	void LineChartItem::handlePointReplaced(int index)
186	{
187	Q_ASSERT(index<m_series->count());
188	Q_ASSERT(index>=0);
189	QPointF point = calculateGeometryPoint(index);
190	updatePoint(index,point);
191	update();
192	}
193
194	void LineChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
195	{
196	m_minX=minX;
197	m_maxX=maxX;
198	m_minY=minY;
199	m_maxY=maxY;
200
201	if(isEmpty()) return;
202	updateAllPoints();
203	update();
204	}
205
206	void LineChartItem::handleGeometryChanged(const QRectF& rect)
207	{
208	Q_ASSERT(rect.isValid());
209	m_size=rect.size();
210	m_clipRect=rect.translated(-rect.topLeft());
211	setPos(rect.topLeft());
212
213	if(isEmpty()) return;
214	updateAllPoints();
215	update();
216	}
217		101
218	void LineChartItem::handleUpdated()	102	void LineChartItem::handleUpdated()
219	{	103	{
220	m_items.setVisible(m_series->pointsVisible());	104	m_items.setVisible(m_series->pointsVisible());
221	setPen(m_series->pen());	105	setPen(m_series->pen());
222	update();	106	update();
223	}	107	}
224		108
225	//painter	109	//painter
226		110
227	void LineChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)	111	void LineChartItem::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
228	{	112	{
229	Q_UNUSED(widget);	113	Q_UNUSED(widget);
230	Q_UNUSED(option);	114	Q_UNUSED(option);
231	painter->save();	115	painter->save();
232	painter->setPen(m_pen);	116	painter->setPen(m_pen);
233	painter->setClipRect(m_clipRect);	117	painter->setClipRect(clipRect());
234	painter->drawPath(m_path);	118	painter->drawPath(m_path);
235	painter->restore();	119	painter->restore();
236	}	120	}
237		121
238	bool LineChartItem::isEmpty()
239	{
240	return !m_clipRect.isValid() \|\| m_maxX - m_minX == 0 \|\| m_maxY - m_minY ==0 ;
241	}
242
243	#include "moc_linechartitem_p.cpp"	122	#include "moc_linechartitem_p.cpp"
244		123
245	QTCOMMERCIALCHART_END_NAMESPACE	124	QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +8 -27

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
-            #include "chartitem_p.h"
+            #include "xychartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QLineSeries;
-            class LineChartItem :  public QObject , public ChartItem
+            class LineChartItem :  public XYChartItem
             {
                  Q_OBJECT
             public:
                 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 handlePointAdded(int index);
-                void handlePointRemoved(int index);
-                void handlePointReplaced(int index);
                 void handleUpdated();
-                void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                void handleGeometryChanged(const QRectF& size);
             protected:
-                virtual void updateAllPoints();
-                virtual void updatePoints(QVector<QPointF>& points);
-                virtual void updatePoint(int index,QPointF& newPoint);
                 virtual void setGeometry(QVector<QPointF>& points);
-                QVector<QPointF> points() {return m_points;}
+            private:
-                void createPoints(int count);
-                void clearPoints(int count);
-                QPointF calculateGeometryPoint(int index) const;
-                QVector<QPointF> calculateGeometryPoints() const;
-                inline bool isEmpty();
-            protected:
-                qreal m_minX;
-                qreal m_maxX;
-                qreal m_minY;
-                qreal m_maxY;
-                QPainterPath m_path;
-                QRectF m_rect;
                 QLineSeries* m_series;
-                QSizeF m_size;
-                QRectF m_clipRect;
                 QGraphicsItemGroup m_items;
-                QVector<QPointF> m_points;
+                QPainterPath m_path;
+                QRectF m_rect;
                 QPen m_pen;
                 friend class LineChartAnimatator;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp +2 -109

             #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
                \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)
                 \brief \internal \a index
             */
             /*!
                 \fn void QLineSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QLineSeries::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.
             */
-            QLineSeries::QLineSeries(QObject* parent):QSeries(parent),
+            QLineSeries::QLineSeries(QObject* parent):QXYSeries(parent),
             m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
             }
             /*!
-                Adds data point \a x \a y to the series. Points are connected with lines on the chart.
-             */
-            void QLineSeries::add(qreal x,qreal y)
-                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 QLineSeries::add(const QPointF& point)
-                add(point.x(),point.y());
-            /*!
-              Modifies \a y value for given \a x a value.
-            */
-            void QLineSeries::replace(qreal x,qreal y)
-                int index = m_x.indexOf(x);
-                m_x[index]=x;
-                m_y[index]=y;
-                emit pointReplaced(index);
-            /*!
-              This is an overloaded function.
-              Replaces current y value of for given \a point x value with \a point y value.
-            */
-            void QLineSeries::replace(const QPointF& point)
-               replace(point.x(),point.y());
-            /*!
-              Removes current \a x and y value.
-            */
-            void QLineSeries::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 QLineSeries::remove(const QPointF& point)
-                remove(point.x());
-            /*!
-              Clears all the data.
-            */
-            void QLineSeries::clear()
-                m_x.clear();
-                m_y.clear();
-            /*!
-                \internal \a pos
-            */
-            qreal QLineSeries::x(int pos) const
-               return m_x.at(pos);
-            /*!
-                \internal \a pos
-            */
-            qreal QLineSeries::y(int pos) const
-               return m_y.at(pos);
-            /*!
-                Returns number of data points within series.
-            */
-            int QLineSeries::count() const
-            	Q_ASSERT(m_x.size() == m_y.size());
-            	return m_x.size();
-            /*!
                 Sets \a pen used for drawing given series..
             */
             void QLineSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
                 m_pen=pen;
                 emit updated();
                 }
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             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());
+                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();
             }
-            /*!
-                Stream operator for adding a data \a point to the series.
-                \sa add()
-            */
-            QLineSeries& QLineSeries::operator<< (const QPointF &point)
-                add(point);
-                return *this;
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +3 -28

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

src/splinechart/splinechartitem.cpp +25 -16

             #include "splinechartitem_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsObject *parent) :
-                LineChartItem(series, parent)//,m_boundingRect()
+            XYChartItem(series, parent),
+            m_series(series)
             {
-                //
             }
+            QRectF SplineChartItem::boundingRect() const
+            {
+                return m_rect;
+            }
+            QPainterPath SplineChartItem::shape() const
+            {
+                return m_path;
+            }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
-                QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
+                return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
-                const qreal deltaX = m_size.width()/(m_maxX-m_minX);
-                const qreal deltaY = m_size.height()/(m_maxY-m_minY);
-                qreal x = (splineSeries->controlPoint(index).x() - m_minX)* deltaX;
-                qreal y = (splineSeries->controlPoint(index).y() - m_minY)*-deltaY + m_size.height();
-                return QPointF(x,y);
             }
             void SplineChartItem::setGeometry(QVector<QPointF>& points)
             {
                 if(points.size()==0) return;
                 QPainterPath splinePath;
                 const QPointF& point = points.at(0);
                 splinePath.moveTo(point);
-            //    QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 for (int i = 0; i < points.size() - 1; i++)
                 {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(calculateGeometryControlPoint(2 * i), calculateGeometryControlPoint(2 * i + 1), point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
+                XYChartItem::setGeometry(points);
+            }
+            void SplineChartItem::setPen(const QPen& pen)
+            {
+                m_pen = pen;
             }
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
-                painter->setPen(m_pen);
+                painter->setClipRect(clipRect());
-                painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
-                QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
+                const QVector<QPointF> points =  XYChartItem::points();
-                for (int i = 0; i < m_points.size() - 1; i++)
+                for (int i = 0; i < points.size() - 1; i++)
                 {
                     painter->setPen(Qt::red);
-                    painter->drawEllipse(m_points[i], 2, 2);
+                    painter->drawEllipse(points[i], 2, 2);
                     painter->setPen(Qt::blue);
                     //        painter->drawLine(m_series->at(i), m_series->controlPoint(2 * i));
                     //        painter->drawLine(m_series->at(i + 1), m_series->controlPoint(2 * i + 1));
                     //        painter->drawEllipse(calculateGeometryControlPoint(2 * i), 4, 4);
                     //        painter->drawEllipse(calculateGeometryControlPoint(2 * i + 1), 4, 4);
                 }
-                if (m_points.count() > 0)
+                if (points.count() > 0)
                 {
                     painter->setPen(Qt::red);
-                    painter->drawEllipse(m_points[m_points.count() - 1], 2, 2);
+                    painter->drawEllipse(points[points.count() - 1], 2, 2);
                 }
                 painter->restore();
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h +16 -4

             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "chartitem_p.h"
             #include <QObject>
             #include "qsplineseries.h"
-            #include "linechartitem_p.h"
+            #include "xychartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class SplineChartItem : public LineChartItem
+            class SplineChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 SplineChartItem(QSplineSeries* series, QGraphicsObject *parent = 0);
-                void updateGeometry();
+                //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);
+            protected:
                 void setGeometry(QVector<QPointF>& points);
+            private:
                 QPointF calculateGeometryControlPoint(int index) const;
-                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+            private:
+                QSplineSeries* m_series;
+                QPainterPath m_path;
+                QRectF m_rect;
+                QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

src/src.pro +1 0

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

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