HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r743:e20e9148b1b0

minor code review issues. indent, spaces, brackets etc.

sauimone -

r743:e20e9148b1b0

parent child

Context file:

r743:e20e9148b1b0

Collapse all files

src/areachart/areachartitem.cpp +21 -21

             //TODO: optimize : remove points which are not visible
-            AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,ChartPresenter *presenter):ChartItem(presenter),
+            AreaChartItem::AreaChartItem(QAreaSeries *areaSeries,ChartPresenter *presenter) : ChartItem(presenter),
-            m_series(areaSeries),
+                m_series(areaSeries),
-            m_upper(0),
+                m_upper(0),
-            m_lower(0),
+                m_lower(0),
-            m_pointsVisible(false)
+                m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries());
-                if(m_series->lowerSeries()){
+                if (m_series->lowerSeries()) {
-                m_lower = new AreaBoundItem(this,m_series->lowerSeries());
+                    m_lower = new AreaBoundItem(this,m_series->lowerSeries());
                 }
-                QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
+                connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
-                QObject::connect(this,SIGNAL(clicked(const QPointF&)),areaSeries,SIGNAL(clicked(const QPointF&)));
+                connect(this,SIGNAL(clicked(const QPointF&)),areaSeries,SIGNAL(clicked(const QPointF&)));
                 handleUpdated();
             }
                 path = m_upper->shape();
-                if(m_lower){
+                if (m_lower) {
-                path.connectPath(m_lower->shape().toReversed());
+                    path.connectPath(m_lower->shape().toReversed());
+                } else {
-                else{
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
             void AreaChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_upper->handleDomainChanged(minX,maxX,minY,maxY);
-                if(m_lower)
+                if (m_lower)
-                m_lower->handleDomainChanged(minX,maxX,minY,maxY);
+                    m_lower->handleDomainChanged(minX,maxX,minY,maxY);
             }
-            void AreaChartItem::handleGeometryChanged(const QRectF& rect)
+            void AreaChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
-                if(m_lower)
+                if (m_lower)
-                m_lower->handleGeometryChanged(rect);
+                    m_lower->handleGeometryChanged(rect);
             }
             //painter
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
-                if(m_pointsVisible){
+                if (m_pointsVisible) {
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->points());
-                       if(m_lower)  painter->drawPoints(m_lower->points());
+                       if (m_lower)
+                           painter->drawPoints(m_lower->points());
                 }
                 painter->restore();
             }
-            void AreaChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
+            void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->calculateDomainPoint(event->pos()));
             }

src/areachart/areachartitem_p.h +6 -6

             {
                 Q_OBJECT
             public:
-                AreaChartItem(QAreaSeries* areaSeries, ChartPresenter *presenter);
+                AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter);
                 ~ AreaChartItem();
                 //from QGraphicsItem
                 void updatePath();
             protected:
-                void mousePressEvent( QGraphicsSceneMouseEvent * event );
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
             signals:
-                void clicked(const QPointF& point);
+                void clicked(const QPointF &point);
             public slots:
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                void handleGeometryChanged(const QRectF& size);
+                void handleGeometryChanged(const QRectF &size);
             private:
                 QAreaSeries* m_series;
             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries):LineChartItem(lineSeries,0),
+                AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries):LineChartItem(lineSeries,0),
                 m_item(item){
                 };
                 ~AreaBoundItem(){};
-                void setLayout(QVector<QPointF>& points){
+                void setLayout(QVector<QPointF> &points){
                     LineChartItem::setLayout(points);
                     m_item->updatePath();
                 }

src/areachart/qareaseries.cpp +7 -7

             */
             void QAreaSeries::setPen(const QPen& pen)
             {
-                if(m_pen!=pen){
+                if (m_pen != pen) {
-                    m_pen=pen;
+                    m_pen = pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for filling the area.
             */
-            void QAreaSeries::setBrush(const QBrush& brush)
+            void QAreaSeries::setBrush(const QBrush &brush)
             {
-                if(m_brush!=brush){
+                if (m_brush != brush) {
-                    m_brush=brush;
+                    m_brush = brush;
                     emit updated();
                 }
             }
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
-                if(m_pointsVisible!=visible){
+                if (m_pointsVisible != visible) {
-                    m_pointsVisible=visible;
+                    m_pointsVisible = visible;
                     emit updated();
                 }
             }

src/areachart/qareaseries.h +4 -5

             #include <qchartglobal.h>
             #include <qseries.h>
-            #include <QDebug>
             #include <QPen>
             #include <QBrush>
             {
                 Q_OBJECT
             public:
-                QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries=0);
+                QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries=0);
                 virtual ~QAreaSeries();
             public: // from QChartSeries
                 QLineSeries* upperSeries() const { return m_upperSeries;}
                 QLineSeries* lowerSeries() const { return m_lowerSeries;}
-                void setPen(const QPen& pen);
+                void setPen(const QPen &pen);
                 QPen pen() const { return m_pen;}
-                void setBrush(const QBrush& brush);
+                void setBrush(const QBrush &brush);
                 QBrush brush() const { return m_brush;}
                 void setPointsVisible(bool visible);
             signals:
                 void updated();
-                void clicked(const QPointF& point);
+                void clicked(const QPointF &point);
             private:
                 QBrush m_brush;

src/linechart/linechartitem_p.h +2 -2

             {
                  Q_OBJECT
             public:
-                 explicit LineChartItem(QLineSeries* series,ChartPresenter *presenter);
+                 explicit LineChartItem(QLineSeries *series,ChartPresenter *presenter);
-                ~ LineChartItem(){};
+                ~LineChartItem() {};
                 //from QGraphicsItem
                 QRectF boundingRect() const;

src/linechart/qlineseries.cpp +11 -11

                 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):QXYSeries(parent),
+            QLineSeries::QLineSeries(QObject *parent) : QXYSeries(parent),
-            m_pointsVisible(false)
+                m_pointsVisible(false)
             {
             }
             /*!
                 Sets \a pen used for drawing line connecting points.
             */
-            void QLineSeries::setLinePen(const QPen& pen)
+            void QLineSeries::setLinePen(const QPen &pen)
             {
-                if(pen!=m_pen){
+                if (pen != m_pen){
-                m_pen=pen;
+                    m_pen = pen;
-                emit QXYSeries::updated();
+                    emit QXYSeries::updated();
                 }
             }
             */
             void QLineSeries::setPointsVisible(bool visible)
             {
-                if(m_pointsVisible!=visible){
+                if (m_pointsVisible != visible){
-                m_pointsVisible=visible;
+                    m_pointsVisible = visible;
-                emit QXYSeries::updated();
+                    emit QXYSeries::updated();
                 }
             }
                 int size = series.m_x.size();
-                for (int i=0;i<size;i++) {
+                for (int i=0; i<size; i++) {
-                debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
+                    debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }

src/linechart/qlineseries.h +3 -5

             #include <qchartglobal.h>
             #include <qxyseries.h>
-            #include <QDebug>
             #include <QPen>
-            #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
             public:
-            	QLineSeries(QObject* parent=0);
+                QLineSeries(QObject *parent=0);
             	virtual ~QLineSeries();
-            	void setLinePen(const QPen& pen);
+                void setLinePen(const QPen &pen);
-            	QPen linePen() const {return m_pen;}
+                QPen linePen() const {return m_pen;}
             	void setPointsVisible(bool visible);
             	bool pointsVisible() const {return m_pointsVisible;}

src/scatterseries/qscatterseries.cpp +4 -4

             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
-                if(m_shape!= shape){
+                if (m_shape != shape) {
-                    m_shape=shape;
+                    m_shape = shape;
                     emit QXYSeries::updated();
                 }
             }
             */
             void QScatterSeries::setSize(qreal size)
             {
-                if(m_size != size){
+                if (m_size != size) {
-                    m_size=size;
+                    m_size = size;
                     emit updated();
                 }
             }

src/scatterseries/scatterchartitem.cpp +1 -1

                 }
             }
-            void ScatterChartItem::markerSelected(Marker* marker)
+            void ScatterChartItem::markerSelected(Marker *marker)
             {
                 emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }

src/scatterseries/scatterchartitem_p.h +7 -7

                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-                void setPen(const QPen& pen);
+                void setPen(const QPen &pen);
-                void setBrush(const QBrush& brush);
+                void setBrush(const QBrush &brush);
-                void markerSelected(Marker* item);
+                void markerSelected(Marker *item);
             public slots:
                 void handleUpdated();
                 void deletePoints(int count);
             protected:
-                void setLayout(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF> &points);
             private:
                 QScatterSeries *m_series;
             public:
-               Marker(QAbstractGraphicsShapeItem* item , ScatterChartItem* parent):QAbstractGraphicsShapeItem(0),m_item(item),m_parent(parent)
+               Marker(QAbstractGraphicsShapeItem *item , ScatterChartItem *parent) : QAbstractGraphicsShapeItem(0) ,m_item(item), m_parent(parent)
                {
                };
                    return m_item->contains(point);
                }
-               void setPen(const QPen& pen)
+               void setPen(const QPen &pen)
                {
                    m_item->setPen(pen);
                }
-               void setBrush(const QBrush& brush)
+               void setBrush(const QBrush &brush)
                {
                    m_item->setBrush(brush);
                }

src/splinechart/qsplineseries.cpp +4 -6

                 QList<qreal> yControl = getFirstControlPoints(rhs);
                 // Fill output arrays.
-                for (int i = 0; i < n; ++i)
+                for (int i = 0; i < n; ++i) {
                     // First control point
                     m_controlPoints.append(QPointF(xControl[i], yControl[i]));
                     // Second control point
                 qreal b = 2.0;
                 x.append(rhs[0] / b);
                 tmp.append(0);
-                for (int i = 1; i < rhs.size(); i++) // Decomposition and forward substitution.
+                for (int i = 1; i < rhs.size(); i++) {
+                    // Decomposition and forward substitution.
                     tmp.append(1 / b);
                     b = (i < rhs.size() - 1 ? 4.0 : 3.5) - tmp[i];
                     x.append((rhs[i] - x[i - 1]) / b);
               */
             void QSplineSeries::updateControlPoints()
             {
-                if(count() > 1)
+                if (count() > 1) {
                     m_controlPoints.clear();
                     calculateControlPoints();
                 }

src/splinechart/qsplineseries.h +2 -2

             #define QSPLINESERIES_H
             #include <qchartglobal.h>
-            #include <QtGlobal>
             #include <qlineseries.h>
             #include <QList>
             #include <QPointF>
+            #include <QtGlobal>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //    int count() const { return m_x.size(); }
                 QPointF controlPoint(int index) const {return m_controlPoints[index];}
-                bool setModel(QAbstractItemModel* model);
+                bool setModel(QAbstractItemModel *model);
                 void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingShift(int first, int count);

src/splinechart/splinechartitem.cpp +15 -18

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplineChartItem::SplineChartItem(QSplineSeries* series, ChartPresenter *presenter) :
+            SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
-            XYChartItem(series, presenter),
+                XYChartItem(series, presenter),
-            m_series(series),
+                m_series(series),
-            m_pointsVisible(false)
+                m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 return m_path;
             }
-            void SplineChartItem::updateLayout(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index)
+            void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 QVector<QPointF> controlPoints;
                 controlPoints.resize(newPoints.count()*2-2);
-                for (int i = 0; i < newPoints.size() - 1; i++)
+                for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
-                if(controlPoints.count()<2) {
+                if (controlPoints.count()<2) {
                     setLayout(newPoints,controlPoints);
                     return;
                 }
-                if(animator()){
+                if (animator()) {
                    animator()->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
-                }else{
+                } else {
                    setLayout(newPoints,controlPoints);
                 }
             }
                 return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
             }
-            void SplineChartItem::setLayout(QVector<QPointF>& points,QVector<QPointF>& controlPoints)
+            void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &controlPoints)
             {
-                if(points.size()<2 || controlPoints.size()<2)
+                if ((points.size()<2) || (controlPoints.size()<2)) {
                     XYChartItem::setLayout(points);
                     m_controlPoints=controlPoints;
                     return;
                 QPainterPath splinePath(points.at(0));
-                for (int i = 0; i < points.size() - 1; i++)
+                for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
-                if(m_pointsVisible){
+                if (m_pointsVisible) {
-                       painter->setPen(m_pointPen);
+                    painter->setPen(m_pointPen);
-                       painter->drawPoints(points());
+                    painter->drawPoints(points());
                 }
                 painter->restore();
             }

src/splinechart/splinechartitem_p.h +3 -5

             #include "qsplineseries.h"
             #include "xychartitem_p.h"
-            #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             {
                 Q_OBJECT
             public:
-                SplineChartItem(QSplineSeries* series, ChartPresenter *presenter);
+                SplineChartItem(QSplineSeries *series, ChartPresenter *presenter);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void handleUpdated();
             protected:
-                void setLayout(QVector<QPointF>& points,QVector<QPointF>& controlPoints);
+                void setLayout(QVector<QPointF> &points,QVector<QPointF> &controlPoints);
-                void updateLayout(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index);
+                void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;

src/xychart/qxyseries.cpp +58 -87

                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
-            QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
+            QXYSeries::QXYSeries(QObject *parent):QSeries(parent)
             {
                 m_mapX = -1;
                 m_mapY = -1;
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
-            void QXYSeries::add(const QPointF& point)
+            void QXYSeries::add(const QPointF &point)
             {
                 add(point.x(),point.y());
             }
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
-                m_x[index]=x;
+                m_x[index] = x;
-                m_y[index]=y;
+                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 QXYSeries::replace(const QPointF& point)
+            void QXYSeries::replace(const QPointF &point)
             {
                 replace(point.x(),point.y());
             }
             {
                 int index = m_x.indexOf(x);
-                if(index==-1) return;
+                if (index == -1) return;
                 m_x.remove(index);
                 m_y.remove(index);
             void QXYSeries::remove(qreal x,qreal y)
             {
                 int index =-1;
-                do{
+                do {
                     index = m_x.indexOf(x,index+1);
-                }while(index !=-1 && m_y.at(index)!=y);
+                } while (index !=-1 && m_y.at(index)!=y);
-                if(index==-1) return;
+                if (index==-1) return;
                 m_x.remove(index);
                 m_y.remove(index);
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
-            void QXYSeries::remove(const QPointF& point)
+            void QXYSeries::remove(const QPointF &point)
             {
                 remove(point.x(),point.y());
             }
             */
             qreal QXYSeries::x(int pos) const
             {
-                if (m_model)
+                if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos + m_mapFirst, m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapX, pos + m_mapFirst), Qt::DisplayRole).toDouble();
-                else
+                } else {
                     // model is not specified, return the data from series' internal data store
                     return m_x.at(pos);
+                }
             }
             /*!
             */
             qreal QXYSeries::y(int pos) const
             {
-                if (m_model)
+                if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos + m_mapFirst, m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapY, pos + m_mapFirst), Qt::DisplayRole).toDouble();
-                else
+                } else {
                     // model is not specified, return the data from series' internal data store
                     return m_y.at(pos);
+                }
             }
             /*!
                 Q_ASSERT(m_x.size() == m_y.size());
                 if (m_model) {
-                    if (m_mapOrientation == Qt::Vertical)
+                    if (m_mapOrientation == Qt::Vertical) {
                         // data is in a column. Return the number of mapped items if the model's column have enough items
                         // or the number of items that can be mapped
                         if (m_mapLimited)
                             return qMin(m_mapCount, qMax(m_model->rowCount() - m_mapFirst, 0));
                         else
                             return qMax(m_model->rowCount() - m_mapFirst, 0);
+                    } else {
-                    else
                         // data is in a row. Return the number of mapped items if the model's row have enough items
                         // or the number of items that can be mapped
                         if (m_mapLimited)
                 pen from chart theme is used.
                 \sa QChart::setChartTheme()
             */
-            void QXYSeries::setPen(const QPen& pen)
+            void QXYSeries::setPen(const QPen &pen)
             {
-                if(pen!=m_pen){
+                if (pen != m_pen) {
-                    m_pen=pen;
+                    m_pen = pen;
                     emit updated();
                 }
             }
                 \sa QChart::setChartTheme()
             */
-            void QXYSeries::setBrush(const QBrush& brush)
+            void QXYSeries::setBrush(const QBrush &brush)
             {
-                if(brush!=m_brush){
+                if (brush != m_brush) {
-                    m_brush=brush;
+                    m_brush = brush;
                     emit updated();
                 }
             }
             {
                 Q_UNUSED(bottomRight)
-                if (m_mapOrientation == Qt::Vertical)
+                if (m_mapOrientation == Qt::Vertical) {
                     if (topLeft.row() >= m_mapFirst && (!m_mapLimited || topLeft.row() < m_mapFirst + m_mapCount))
                         emit pointReplaced(topLeft.row() - m_mapFirst);
+                } else {
-                else
                     if (topLeft.column() >= m_mapFirst && (!m_mapLimited || topLeft.column() < m_mapFirst + m_mapCount))
                         emit pointReplaced(topLeft.column() - m_mapFirst);
                 }
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
-                if (m_mapLimited)
+                if (m_mapLimited) {
+                    if (start >= m_mapFirst + m_mapCount) {
-                    if (start >= m_mapFirst + m_mapCount)
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
-                    else
+                    } else {
                         // the added data is in the mapped area or before it and update is needed
                         // check how many mapped items there is currently (before new items are added)
                         // internal storage before new ones can be added
                         int itemsToRemove = qMin(count() - (start - m_mapFirst), end - start + 1);
-                        if (m_mapCount == count())
+                        if (m_mapCount == count()) {
                             for (int i = 0; i < itemsToRemove; i++)
                                 emit pointRemoved(count() - 1 - i);
+                        }
                     }
+                } else {
-                else
                     // map is not limited (it includes all the items starting from m_mapFirst till the end of model)
                     // nothing to do
                     //        emit pointAdded(qMax(start - m_mapFirst, 0));
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
-                if (m_mapLimited)
+                if (m_mapLimited) {
+                    if (start >= m_mapFirst + m_mapCount) {
-                    if (start >= m_mapFirst + m_mapCount)
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
-                    else
+                    } else {
                         // the added data is in the mapped area or before it
                         // update needed
-                        if (count() > 0)
+                        if (count() > 0) {
                             for (int i = 0; i < qMin(m_mapCount - (start - m_mapFirst), end - start + 1); i++)
                                 emit pointAdded(qMax(start + i - m_mapFirst, 0));
+                        }
                     }
+                } else {
-                else
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit pointAdded(qMax(start + i - m_mapFirst, 0));
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
-                if (m_mapLimited)
+                if (m_mapLimited) {
+                    if (start >= m_mapFirst + m_mapCount) {
-                    if (start >= m_mapFirst + m_mapCount)
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
-                    else
+                    } else {
                         // the removed data is in the mapped area or before it
                         // update needed
                         for (int i = 0; i < itemsToRemove; i++)
                             emit pointRemoved(qMax(start - m_mapFirst, 0));
                     }
+                } else {
-                else
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit pointRemoved(qMax(start - m_mapFirst, 0));
                 // how many items there were before data was removed
                 //    int oldCount = count() - 1;
-                if (m_mapLimited)
+                if (m_mapLimited) {
+                    if (start >= m_mapFirst + m_mapCount) {
-                    if (start >= m_mapFirst + m_mapCount)
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
-                    else
+                    } else {
                         // if the current items count in the whole model is bigger than the index of the last item
                         // that was removed than it means there are some extra items available
                         int extraItemsAvailable = 0;
-                        if (m_mapOrientation == Qt::Vertical)
+                        if (m_mapOrientation == Qt::Vertical) {
                             extraItemsAvailable = qMax(m_model->rowCount() - end, 0);
+                        } else {
-                        else
                             extraItemsAvailable = qMax(m_model->columnCount() - end, 0);
                         }
                         for (int k = 0; k < toBeAdded; k++)
                             emit pointAdded(qMax(start - m_mapFirst, m_mapFirst) + k);
                     }
+                } else {
-                else
                     // data was removed from XYSeries interal storage. Nothing more to do
                 }
             }
-            bool QXYSeries::setModel(QAbstractItemModel* model) {
+            bool QXYSeries::setModel(QAbstractItemModel *model) {
                 // disconnect signals from old model
-                if(m_model)
+                if (m_model) {
                     disconnect(m_model, 0, this, 0);
                     m_mapX = -1;
                     m_mapY = -1;
                 }
                 // set new model
-                if(model)
+                if (model) {
                     m_model = model;
                     return true;
+                } else {
-                else
+                    m_model = 0;
-                    m_model = NULL;
                     return false;
                 }
             }
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
-                if (m_model == NULL)
+                if (m_model == 0)
                     return;
                 m_mapX = modelX;
                 m_mapY = modelY;
                 m_mapFirst = 0;
                 m_mapOrientation = orientation;
-                if (m_mapOrientation == Qt::Vertical)
+                if (m_mapOrientation == Qt::Vertical) {
                     //        m_mapCount = m_model->rowCount();
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                } else {
-                else
                     //        m_mapCount = m_model->columnCount();
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
             void QXYSeries::setModelMappingShift(int first, int count)
             {
                 m_mapFirst = first;
-                if (count == 0)
+                if (count == 0) {
                     m_mapLimited = false;
-                else
+                } else {
                     m_mapCount = count;
                     m_mapLimited = true;
                 }

src/xychart/qxyseries.h +8 -9

             #include <qchartglobal.h>
             #include <qseries.h>
-            #include <QDebug>
             #include <QPen>
             #include <QBrush>
             {
                 Q_OBJECT
             protected:
-                QXYSeries(QObject* parent=0);
+                QXYSeries(QObject *parent=0);
                 virtual ~QXYSeries();
             public:
                 void add(qreal x, qreal y);
-                void add(const QPointF& point);
+                void add(const QPointF &point);
                 void add(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
-                void replace(const QPointF& point);
+                void replace(const QPointF &point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
-                void remove(const QPointF& point);
+                void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
-                void setPen(const QPen& pen);
+                void setPen(const QPen &pen);
                 QPen pen() const {return m_pen;}
-                void setBrush(const QBrush& pen);
+                void setBrush(const QBrush &pen);
                 QBrush brush() const {return m_brush;}
-                bool setModel(QAbstractItemModel* model);
+                bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel* model() {return m_model;}
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                     void modelDataRemoved(QModelIndex parent, int start, int end);
             signals:
-                void clicked(const QPointF& point);
+                void clicked(const QPointF &point);
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);

src/xychart/xychartitem.cpp +24 -24

             //TODO: optimize : remove points which are not visible
-            XYChartItem::XYChartItem(QXYSeries* series, ChartPresenter *presenter):ChartItem(presenter),
+            XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
-            m_minX(0),
+                m_minX(0),
-            m_maxX(0),
+                m_maxX(0),
-            m_minY(0),
+                m_minY(0),
-            m_maxY(0),
+                m_maxY(0),
-            m_series(series)
+                m_series(series)
             {
-                QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
+                connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
-                QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
+                connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
-                QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+                connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
-                QObject::connect(this,SIGNAL(clicked(const QPointF&)),series,SIGNAL(clicked(const QPointF&)));
+                connect(this,SIGNAL(clicked(const QPointF&)),series,SIGNAL(clicked(const QPointF&)));
             }
-            QPointF XYChartItem::calculateGeometryPoint(const QPointF& point) const
+            QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) 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 x = (m_series->x(i) - m_minX)* deltaX;
-                  qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
+                    qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
-                  points << QPointF(x,y);
+                    points << QPointF(x,y);
                 }
                 return points;
             }
-            QPointF XYChartItem::calculateDomainPoint(const QPointF& point) const
+            QPointF XYChartItem::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 return QPointF(x,y);
             }
-            void XYChartItem::updateLayout(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index)
+            void XYChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
-                if(animator()){
+                if (animator()) {
-                   animator()->updateLayout(this,oldPoints,newPoints,index);
+                    animator()->updateLayout(this,oldPoints,newPoints,index);
-                }else{
+                } else {
                     setLayout(newPoints);
                 }
             }
-            void XYChartItem::setLayout(QVector<QPointF>& points)
+            void XYChartItem::setLayout(QVector<QPointF> &points)
             {
                 m_points = points;
                 update();
                 m_minY=minY;
                 m_maxY=maxY;
-                if(isEmpty()) return;
+                if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateLayout(m_points,points);
                 update();
             }
-            void XYChartItem::handleGeometryChanged(const QRectF& rect)
+            void XYChartItem::handleGeometryChanged(const QRectF &rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
-                if(isEmpty()) return;
+                if (isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
             	updateLayout(m_points,points);
             	update();
                return !m_clipRect.isValid() ||  m_maxX - m_minX == 0 || m_maxY - m_minY ==0 ;
             }
-            void XYChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
+            void XYChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(calculateDomainPoint(event->pos()));
             }

src/xychart/xychartitem_p.h +8 -8

             {
                  Q_OBJECT
             public:
-                 explicit XYChartItem(QXYSeries* series, ChartPresenter *presenter);
+                 explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
-                ~ XYChartItem(){};
+                ~XYChartItem(){};
                 QVector<QPointF> points() const {return m_points;}
                 QRectF clipRect() const { return m_clipRect;}
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                void handleGeometryChanged(const QRectF& size);
+                void handleGeometryChanged(const QRectF &size);
             signals:
                 void clicked(const QPointF& point);
             protected:
-                virtual void setLayout(QVector<QPointF>& points);
+                virtual void setLayout(QVector<QPointF> &points);
-                virtual void updateLayout(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints,int index = 0);
+                virtual void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
-                QPointF calculateGeometryPoint(const QPointF& point) const;
+                QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateGeometryPoint(int index) const;
-                QPointF calculateDomainPoint(const QPointF& point) const;
+                QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
-                void mousePressEvent( QGraphicsSceneMouseEvent * event );
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 inline bool isEmpty();

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