HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r392:938f3d3eaf7c

Adds updated handling for line series

Michal Klocek -

r392:938f3d3eaf7c

parent child

Context file:

r392:938f3d3eaf7c

Collapse all files

src/chartpresenter.cpp +2 0

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(0)
             {
             	createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*)),this,SLOT(handleSeriesAdded(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         LineChartItem* item;
                         if(m_options.testFlag(QChart::SeriesAnimations)){
                             item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         }else{
                             item = new LineChartItem(this,lineSeries,m_chart);
                         }
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(lineSeries,SIGNAL(pointReplaced(int)),item,SLOT(handlePointReplaced(int)));
                         QObject::connect(lineSeries,SIGNAL(pointAdded(int)),item,SLOT(handlePointAdded(int)));
                         QObject::connect(lineSeries,SIGNAL(pointRemoved(int)),item,SLOT(handlePointRemoved(int)));
+                        QObject::connect(lineSeries,SIGNAL(updated()),item,SLOT(handleUpdated()));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
+                        item->handleUpdated();
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         BarPresenter* item = new BarPresenter(barSeries,m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(scatterPresenter, SIGNAL(clicked()), scatterSeries, SIGNAL(clicked()));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         if(m_rect.isValid()) scatterPresenter->handleGeometryChanged(m_rect);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         // Hide all from background when there is only piechart
                         // TODO: refactor this ugly code... should be one setting for this
                         if (m_chartItems.count() == 0) {
                             m_chart->axisX()->setAxisVisible(false);
                             m_chart->axisY()->setAxisVisible(false);
                             m_chart->axisX()->setGridVisible(false);
                             m_chart->axisY()->setGridVisible(false);
                             m_chart->axisX()->setLabelsVisible(false);
                             m_chart->axisY()->setLabelsVisible(false);
                             m_chart->axisX()->setShadesVisible(false);
                             m_chart->axisY()->setShadesVisible(false);
                             m_chart->setChartBackgroundBrush(Qt::transparent);
                         }
                         m_chartItems.insert(series, pie);
                         pie->handleGeometryChanged(m_rect);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesDomainChanged(QSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem.cpp +1 -3

             #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(ChartPresenter* presenter, QLineSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_items(this)
             {
             	//m_items.setZValue(ChartPresenter::LineChartZValue);
                 setZValue(ChartPresenter::LineChartZValue);
             }
             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_domain.spanX();
                 const qreal deltaY = m_size.height()/m_domain.spanY();
                 qreal x = (m_series->x(index) - m_domain.m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_domain.m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> LineChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/m_domain.spanX();
                 const qreal deltaY = m_size.height()/m_domain.spanY();
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_domain.m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_domain.m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
             void LineChartItem::updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
             {
             	applyGeometry(newPoints);
             	oldPoints = newPoints;
             }
             void LineChartItem::updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint)
             {
             	oldPoints.replace(index,newPoint);
             	applyGeometry(oldPoints);
             }
             void LineChartItem::applyGeometry(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);
                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);
                    path.lineTo(point);
                }
                prepareGeometryChange();
                m_path = path;
                m_rect = path.boundingRect();
             }
             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);
                 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);
                 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);
                 update();
             }
             void LineChartItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 if(m_domain.isEmpty()) return;
                 if(!m_clipRect.isValid()) return;
                 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_domain.isEmpty()) return;
             	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::handleSeriesUpdated()
+            void LineChartItem::handleUpdated()
             {
-                if(m_points.count()==0) return;
                 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();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +2 -2

             #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(ChartPresenter* presenter, 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 handleSeriesUpdated();
+                void handleUpdated();
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             public:
                 virtual void updateItem(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints);
                 virtual void updateItem(QVector<QPointF>& oldPoints,int index,QPointF& newPoint);
                 void applyGeometry(QVector<QPointF>& points);
                 void createPoints(int count);
                 void clearPoints(int count);
                 QPointF calculateGeometryPoint(int index) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 ChartPresenter* m_presenter;
                 QPainterPath m_path;
+                QLineSeries* m_series;
                 QSizeF m_size;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 Domain m_domain;
                 QGraphicsItemGroup m_items;
                 QVector<QPointF> m_points;
-                QLineSeries* m_series;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/linechart/qlineseries.cpp +11 0

             #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(int index)
+                \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),
             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);
                 m_x.remove(index);
                 m_y.remove(index);
                 emit pointRemoved(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());
                 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 +1 0

             #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 pointsVisible() const {return m_pointsVisible;}
                 int count() const;
                 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 pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
+                void updated();
             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