HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r185:71bb456d2e5e

Add pointsVisible setting for line series

Michal Klocek -

r185:71bb456d2e5e

parent child

Context file:

r185:71bb456d2e5e

Collapse all files

src/linechart/linechartitem.cpp +3 -2

             #include "linechartitem_p.h"
             #include "qlinechartseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimazie : remove points which are not visible
             LineChartItem::LineChartItem(ChartPresenter* presenter, QLineChartSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_dirtyData(false),
             m_dirtyGeometry(false),
             m_dirtyDomain(false)
             {
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::addPoints(const QVector<QPointF>& points)
             {
                 m_data = points;
                 for(int i=0; i<m_data.size();i++){
                 const QPointF& point =m_data[i];
                 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
                 item->setPos(point.x()-1,point.y()-1);;
-                if(!m_clipRect.contains(point)) item->setVisible(false);
+                if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
                 m_points << item;
                 }
             }
             void LineChartItem::addPoint(const QPointF& point)
             {
             	m_data << point;
             	QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
             	m_clipRect.contains(point);
             	item->setPos(point.x()-1,point.y()-1);
-            	if(!m_clipRect.contains(point)) item->setVisible(false);
+            	if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
             	m_points << item;
             }
             void LineChartItem::removePoint(const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(point,0);
                 m_data.remove(index);
                 delete(m_points.takeAt(index));
             }
             void LineChartItem::setPoint(const QPointF& oldPoint,const QPointF& newPoint)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(oldPoint,0);
                 if(index > -1){
                 m_data.replace(index,newPoint);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(newPoint.x()-1,newPoint.y()-1);
                 }
             }
             void LineChartItem::setPoint(int index,const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 Q_ASSERT(index>=0);
                 m_data.replace(index,point);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(point.x()-1,point.y()-1);
             }
             void LineChartItem::clear()
             {
             	 qDeleteAll(m_points);
             	 m_points.clear();
             	 m_hash.clear();
             	 m_path = QPainterPath();
             	 m_rect = QRect();
             	 m_data.clear();
             }
             void LineChartItem::clearView()
             {
                  qDeleteAll(m_points);
                  m_points.clear();
                  m_path = QPainterPath();
                  m_rect = QRect();
                  m_data.clear();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             	Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
             	painter->drawPath(m_path);
             }
             void LineChartItem::calculatePoint(QPointF& point, int index, const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 qreal x = (series->x(index) - domain.m_minX)* deltaX;
                 qreal y = (series->y(index) - domain.m_minY)*-deltaY + size.height();
                 point.setX(x);
                 point.setY(y);
             }
             void LineChartItem::calculatePoints(QVector<QPointF>& points, QHash<int,int>& hash,const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 for (int i = 0; i < series->count(); ++i) {
                   qreal x = (series->x(i) - domain.m_minX)* deltaX;
                   qreal y = (series->y(i) - domain.m_minY)*-deltaY + size.height();
                   hash[i] = points.size();
                   points << QPointF(x,y);
                 }
             }
             void LineChartItem::updateDomain()
             {
                 clear();
                 prepareGeometryChange();
             	calculatePoints(m_data,m_hash,m_series,m_size, m_domain);
             	addPoints(m_data);
             }
             void LineChartItem::updateData()
             {
                 //for now the same
                 updateDomain();
             }
             void LineChartItem::updateGeometry()
             {
                if(m_data.size()==0) return;
                prepareGeometryChange();
                QPainterPath path;
                const QPointF& point = m_data.at(0);
                path.moveTo(point);
                foreach( const QPointF& point , m_data) {
                    path.lineTo(point);
                }
                m_path = path;
                m_rect = path.boundingRect();
             }
             void LineChartItem::setPen(const QPen& pen)
             {
                 m_pen = pen;
             }
             //handlers
             void LineChartItem::handleModelChanged(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 if(m_hash.contains(index)){
                     int i = m_hash.value(index);
                     QPointF point;
                     calculatePoint(point,index,m_series,m_size,m_domain);
                     setPoint(i,point);
                 }
                 update();
             }
             void LineChartItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 updateDomain();
                 update();
             }
             void LineChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 updateDomain();
                 updateGeometry();
                 setPos(rect.topLeft());
                 update();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +1 0

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QLineChartSeries;
             class LineChartAnimationItem;
             class LineChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                 LineChartItem(ChartPresenter* presenter, QLineChartSeries* 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);
                 const Domain& domain() const { return m_domain;}
                 virtual void addPoint(const QPointF& );
                 virtual void addPoints(const QVector<QPointF>& points);
                 virtual void removePoint(const QPointF& point);
                 virtual void setPoint(const QPointF& oldPoint, const QPointF& newPoint);
                 virtual void setPoint(int index,const QPointF& point);
+                void setPointsVisible(bool visible);
                 void clear();
                 void clearView();
                 int count() const { return m_data.size();}
                 const QVector<QPointF>& points(){ return m_data;}
             protected:
                 virtual void updateGeometry();
                 virtual void updateData();
                 virtual void updateDomain();
                 //refactor
                 void calculatePoint(QPointF& point, int index, const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const;
                 void calculatePoints(QVector<QPointF>& points,QHash<int,int>& hash,const QLineChartSeries* series, const QSizeF& size, const Domain& domain) const;
             protected slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 ChartPresenter* m_presenter;
                 QPainterPath m_path;
                 QSizeF m_size;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 Domain m_domain;
                 QList<QGraphicsItem*> m_points;
                 QVector<QPointF> m_data;
                 QHash<int,int> m_hash;
                 QLineChartSeries* m_series;
                 QPen m_pen;
                 bool m_dirtyData;
                 bool m_dirtyGeometry;
                 bool m_dirtyDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlinechartseries.cpp +2 -1

             #include "qlinechartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QLineChartSeries::QLineChartSeries(QObject* parent):QChartSeries(parent)
+            QLineChartSeries::QLineChartSeries(QObject* parent):QChartSeries(parent),
+            m_pointsVisible(false)
             {
             }
             QLineChartSeries::~QLineChartSeries()
             {
             }
             int QLineChartSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
                 return m_x.size()-1;
             }
             void QLineChartSeries::set(int index,qreal x,qreal y)
             {
                 m_x[index]=x;
                 m_y[index]=y;
                 emit changed(index);
             }
             void QLineChartSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             qreal QLineChartSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             qreal QLineChartSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             int QLineChartSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             void QLineChartSeries::setPen(const QPen& pen)
             {
                 m_pen=pen;
             }
             QDebug operator<< (QDebug debug, const QLineChartSeries 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_qlinechartseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlinechartseries.h +4 -2

             #ifndef QLINECHARTSERIES_H_
             #define QLINECHARTSERIES_H_
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 QLineChartSeries(QObject* parent=0);
                 virtual ~QLineChartSeries();
             public: // from QChartSeries
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeLine;}
-            public:
                 int add(qreal x, qreal y);
                 void set(int index,qreal x,qreal y);
                 void clear();
                 void setPen(const QPen& pen);
                 const QPen& pen() const { return m_pen;}
+                void pointsVisible(bool visible);
+                bool isPointsVisible() const {return m_pointsVisible;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QLineChartSeries series);
             signals:
                 void changed(int index);
             private:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
+                bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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