HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r464:407de0c5cf5b

Refactors linechart update calls

Michal Klocek -

r464:407de0c5cf5b

parent child

Context file:

r464:407de0c5cf5b

Collapse all files

src/areachart/areachartitem_p.h +2 -2

             #ifndef AREACHARTITEM_H
             #define AREACHARTITEM_H
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAreaSeries;
             class AreaChartItem;
             class AreaChartItem :  public QObject ,public ChartItem
             {
                 Q_OBJECT
             public:
                 AreaChartItem(QAreaSeries* areaSeries, QGraphicsItem *parent = 0);
                 ~ AreaChartItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setPen(const QPen& pen);
                 void setBrush(const QBrush& brush);
                 void setPointsVisible(bool visible);
                 void updatePath();
             public slots:
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 QAreaSeries* m_series;
                 LineChartItem* m_upper;
                 LineChartItem* m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 QPen m_pen;
                 QBrush m_brush;
             };
             class AreaBoundItem : public LineChartItem
             {
             public:
                 AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries):LineChartItem(lineSeries),
                 m_item(item){};
                 ~AreaBoundItem(){};
-                void applyGeometry(QVector<QPointF>& points){
+                void setGeometry(QVector<QPointF>& points){
-                    LineChartItem::applyGeometry(points);
+                    LineChartItem::setGeometry(points);
                     m_item->updatePath();
                 }
             private:
                 AreaChartItem* m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/linechartanimationitem.cpp +17 -7

             #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::updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
+            void LineChartAnimationItem::updateAllPoints()
             {
+                QVector<QPointF> oldPoints = points();
+                LineChartItem::updateAllPoints();
+                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()));
-                oldPoints = newPoints;
                 m_points = newPoints;
                 m_dirty=false;
             }
-            void LineChartAnimationItem::updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint)
+            void LineChartAnimationItem::updatePoint(int index,QPointF& newPoint)
             {
                 if(m_animation->state()!=QAbstractAnimation::Stopped){
                    m_animation->stop();
                    m_dirty=true;
                 }
                 if(m_dirty){
-                	m_points=oldPoints;
+                	m_points=points();
                 	m_dirty=false;
                 }
-                oldPoints.replace(index,newPoint);
+                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(oldPoints));
+                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);
-                m_item->applyGeometry(vector);
+            	if(state()!=QAbstractAnimation::Stopped){ //workaround
+                m_item->setGeometry(vector);
+            	}
             }
             #include "moc_linechartanimationitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartanimationitem_p.h +2 -2

             #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 updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
+            	 virtual void updateAllPoints();
-                virtual void updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint);
+            	 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 +45 -39

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series),
             m_items(this)
             {
             	//m_items.setZValue(ChartPresenter::LineChartZValue);
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3);
                     m_items.addToGroup(item);
                 }
             }
             void LineChartItem::clearPoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             QPointF LineChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (m_series->x(index) - m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> LineChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
-            void LineChartItem::updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
+            void LineChartItem::updateAllPoints()
             {
-            	applyGeometry(newPoints);
+                QVector<QPointF> points = calculateGeometryPoints();
-            	oldPoints = newPoints;
+                int diff = m_points.size() - points.size();
+                if(diff>0) {
+                    clearPoints(diff);
+                }
+                else if(diff<0) {
+                    createPoints(-diff);
+                }
+            	setGeometry(points);
             }
-            void LineChartItem::updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint)
+            void LineChartItem::updatePoints(QVector<QPointF>& points)
             {
-            	oldPoints.replace(index,newPoint);
+                int diff = m_points.size() - points.size();
-            	applyGeometry(oldPoints);
+                 if(diff>0) {
+                     clearPoints(diff);
+                 }
+                 else if(diff<0) {
+                     createPoints(-diff);
+                 }
+                 setGeometry(points);
+            }
+            void LineChartItem::updatePoint(int index,QPointF& newPoint)
+            {
+            	m_points.replace(index,newPoint);
+            	setGeometry(m_points);
             }
-            void LineChartItem::applyGeometry(QVector<QPointF>& points)
+            void LineChartItem::setGeometry(QVector<QPointF>& points)
             {
                if(points.size()==0) return;
                QList<QGraphicsItem*> items = m_items.childItems();
                QPainterPath path;
                const QPointF& point = points.at(0);
                path.moveTo(point);
                QGraphicsItem* item = items.at(0);
                item->setPos(point.x()-1,point.y()-1);
                if(!m_clipRect.contains(point)) {
             	   item->setVisible(false);
                }else{
             	   item->setVisible(true);
                }
                for(int i=1 ; i< points.size();i++) {
                    QGraphicsItem* item = items.at(i);
                    const QPointF& point = points.at(i);
                    item->setPos(point.x()-1,point.y()-1);
                    if(!m_clipRect.contains(point)) {
                 	   item->setVisible(false);
                    }else{
                 	   item->setVisible(true);
                    }
                    path.lineTo(point);
                }
                prepareGeometryChange();
                m_path = path;
                m_rect = path.boundingRect();
+               m_points = points;
             }
             void LineChartItem::setPen(const QPen& pen)
             {
                 m_pen = pen;
             }
             //handlers
             void LineChartItem::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 createPoints(1);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
-                updateItem(m_points,points);
+                updatePoints(points);
                 update();
             }
             void LineChartItem::handlePointRemoved(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 clearPoints(1);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
-                updateItem(m_points,points);
+                updatePoints(points);
                 update();
             }
             void LineChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
-                updateItem(m_points,index,point);
+                updatePoint(index,point);
                 update();
             }
             void LineChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
-                if( (m_maxX - m_minX) == 0|| (m_maxY - m_minY) == 0) return;
+                if(isEmpty()) return;
-                if(!m_clipRect.isValid()) return;
+                updateAllPoints();
-                QVector<QPointF> points = calculateGeometryPoints();
-                int diff = m_points.size() - points.size();
-                if(diff>0) {
-                      clearPoints(diff);
-                else if(diff<0) {
-                      createPoints(-diff);
-                updateItem(m_points,points);
                 update();
             }
             void LineChartItem::handleGeometryChanged(const QRectF& rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
-            	if( (m_maxX - m_minX) == 0|| (m_maxY - m_minY) == 0) return;
+            	if(isEmpty()) return;
+            	updateAllPoints();
-            	QVector<QPointF> points = calculateGeometryPoints();
-            	int diff = m_points.size() - points.size();
-            	if(diff>0) {
-            		clearPoints(diff);
-            	else if(diff<0) {
-            		createPoints(-diff);
-            	updateItem(m_points,points);
             	update();
             }
             void LineChartItem::handleUpdated()
             {
                 m_items.setVisible(m_series->pointsVisible());
                 setPen(m_series->pen());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
+            bool LineChartItem::isEmpty()
+            {
+               return !m_clipRect.isValid() ||  m_maxX - m_minX == 0 || m_maxY - m_minY ==0 ;
+            }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +10 -4

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QLineSeries;
             class LineChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                 LineChartItem(QLineSeries* series,QGraphicsItem *parent = 0);
                 ~ LineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setPen(const QPen& pen);
                 void setPointsVisible(bool visible);
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
-            public:
+            protected:
-                virtual void updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
+                virtual void updateAllPoints();
-                virtual void updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint);
+                virtual void updatePoints(QVector<QPointF>& points);
-                virtual void applyGeometry(QVector<QPointF>& points);
+                virtual void updatePoint(int index,QPointF& newPoint);
+                virtual void setGeometry(QVector<QPointF>& points);
+                QVector<QPointF> points() {return m_points;}
                 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;
                 QPen m_pen;
+                friend class LineChartAnimatator;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/splinechart/splinechartitem.cpp +1 -1

             #include "splinechartitem_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsObject *parent) :
                 LineChartItem(series, parent)//,m_boundingRect()
             {
                 //
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 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::applyGeometry(QVector<QPointF>& points)
+            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();
             }
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 for (int i = 0; i < m_points.size() - 1; i++)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(m_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)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(m_points[m_points.count() - 1], 2, 2);
                 }
                 painter->restore();
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h +1 -1

             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "chartitem_p.h"
             #include <QObject>
             #include "qsplineseries.h"
             #include "linechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplineChartItem : public LineChartItem
             {
                 Q_OBJECT
             public:
                 SplineChartItem(QSplineSeries* series, QGraphicsObject *parent = 0);
                 void updateGeometry();
-                void applyGeometry(QVector<QPointF>& points);
+                void setGeometry(QVector<QPointF>& points);
                 QPointF calculateGeometryControlPoint(int index) const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

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