HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r150:19743dc8af25

Adds cliping and proper zoom handling for line chart

Michal Klocek -

r150:19743dc8af25

parent child

Context file:

r150:19743dc8af25

Collapse all files

src/linechart/linechartitem.cpp +9 -4

             #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);
+                item->setPos(point.x()-1,point.y()-1);;
+                if(!m_clipRect.contains(point)) 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);
             	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;
-                  if(x<0 || x > size.width()) continue;
                   qreal y = (series->y(i) - domain.m_minY)*-deltaY + size.height();
-                  if(y<0 || y > size.height()) continue;
                   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 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/qchart.cpp +1 -1

             #include "qchart.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series)
             {
                 m_dataset->addSeries(series);
             }
             //TODO on review, is it really needed ??
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
                 QChartSeries *series(0);
                 switch (type) {
                     case QChartSeries::SeriesTypeLine: {
                         series = QLineChartSeries::create();
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         series = new BarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         series = new StackedBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         series = new PercentBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         series = new QScatterSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         series = new QPieSeries(this);
                         break;
                     }
                     default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setTitle(const QString& title,const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
                 m_presenter->setTheme(theme);
             }
             QChart::ChartThemeId QChart::theme()
             {
-                return (QChart::ChartThemeId) m_presenter->theme();
+                return m_presenter->theme();
             }
             void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 m_presenter->zoomInToRect(rectangle);
             }
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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