HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r367:7568f64ee3e2

Fixes pointsVisible naming convention in qlineseries

Michal Klocek -

r367:7568f64ee3e2

parent child

Context file:

r367:7568f64ee3e2

Collapse all files

src/linechart/linechartitem.cpp +2 -2

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimazie : remove points which are not visible
             LineChartItem::LineChartItem(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_dirtyData(false),
             m_dirtyGeometry(false),
             m_dirtyDomain(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
             }
             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) || !m_series->isPointsVisible()) item->setVisible(false);
+                if(!m_clipRect.contains(point) || !m_series->pointsVisible()) 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) || !m_series->isPointsVisible()) item->setVisible(false);
+            	if(!m_clipRect.contains(point) || !m_series->pointsVisible()) 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->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
             void LineChartItem::calculatePoint(QPointF& point, int index, const QLineSeries* 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 QLineSeries* 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/qlineseries.cpp +1 -1

             #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
                 To create line charts, users need to first QLineSeries object.
                 \snippet ../example/linechart/main.cpp 1
                 Populate with the data
                 \snippet ../example/linechart/main.cpp 2
                 Add created series objects to QChartView or QChart instance.
                 \snippet ../example/linechart/main.cpp 3
             */
             /*!
                 \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::isPointsVisible() const
+               \fn bool  QLineSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QLineSeries::changed(int index)
                 \brief \internal \a index
             */
             /*!
                 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),
             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)
             {
                 m_x<<x;
                 m_y<<y;
             }
             /*!
                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)
             {
                 m_x<<point.x();
                 m_y<<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 changed(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)
             {
                 int index = m_x.indexOf(point.x());
                 m_x[index]=point.x();
                 m_y[index]=point.y();
                 emit changed(index);
             }
             /*!
               Removes current \a x and y value.
             */
             void QLineSeries::remove(qreal x)
             {
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QLineSeries::remove(const QPointF& point)
             {
             }
             /*!
               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)
             {
                 m_pen=pen;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QLineSeries::setPointsVisible(bool visible)
             {
                 m_pointsVisible=visible;
             }
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
             	Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             #include "moc_qlineseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.h +1 -1

             #ifndef QLINESERIES_H_
             #define QLINESERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QSeries
             {
                 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 isPointsVisible() const {return m_pointsVisible;}
+                bool pointsVisible() const {return m_pointsVisible;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QLineSeries 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