HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1054:e65f6f3d183f

QXYSeries: support for adding data to model when using custom mapping

Marek Rosa -

r1054:e65f6f3d183f

parent child

Context file:

r1054:e65f6f3d183f

Collapse all files

src/qabstractseries.cpp +14 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \enum QAbstractSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \fn QSeriesType QAbstractSeries::type() const
                 \brief The type of the series.
             */
             /*!
                 \fn bool QAbstractSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property
             */
             /*!
                 \fn void QAbstractSeries::setName(const QString& name)
                 \brief Sets a \a name for the series.
                 The name of a series is shown in the legend for QXYSeries.
                 \sa QChart::setTitle()
                 \sa QPieSlice::setLabel()
                 \sa QBarSet::setName()
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
             }
             /*!
                 \brief Returns the pointer to the model that is used as the series data source
             */
             QAbstractItemModel* QAbstractSeries::model() const
             {
                 return d_ptr->m_model;
             }
+            int QAbstractSeries::mapFirst() const
+            {
+                return d_ptr->m_mapFirst;
+            }
+            int QAbstractSeries::mapCount() const
+            {
+                return d_ptr->m_mapCount;
+            }
             void QAbstractSeries::setName(const QString& name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 \brief Returns the name of the series.
                 \sa setName()
             */
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
-            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q): q_ptr(q),m_model(0)
+            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q):
+                q_ptr(q),
+                m_model(0),
+                m_mapFirst(0),
+                m_mapCount(-1)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QABSTRACTSERIES_H
             #define QABSTRACTSERIES_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QAbstractSeries : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString name READ name WRITE setName)
                 Q_ENUMS(QSeriesType)
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
                 QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractSeries();
                 virtual QSeriesType type() const = 0;
                 virtual bool setModel(QAbstractItemModel* model) = 0;
                 QAbstractItemModel* model() const;
+                int mapFirst() const;
+                int mapCount() const;
                 void setName(const QString& name);
                 QString name() const;
             protected:
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartDataSet;
                 friend class ChartPresenter;
                 friend class QLegendPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qabstractseries_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTSERIES_P_H
             #define QABSTRACTSERIES_P_H
             #include "qabstractseries.h"
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class ChartPresenter;
             class Chart;
             class LegendMarker;
             class QLegend;
             class QAbstractSeriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
                 virtual void scaleDomain(Domain& domain) = 0;
                 virtual Chart* createGraphics(ChartPresenter* presenter) = 0;
                 virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
             protected:
                 QAbstractSeries *q_ptr;
                 QAbstractItemModel *m_model;
+                int m_mapFirst;
+                int m_mapCount;
                 QString m_name;
                 friend class QAbstractSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries.cpp +65 -25

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QXYSeries API.
             */
             /*!
                 \fn void QXYSeriesPrivate::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 d->m_x<<x;
                 d->m_y<<y;
                 emit d->pointAdded(d->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 QXYSeries::append(const QPointF &point)
             {
                 append(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     append(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 d->m_x[index] = x;
                 d->m_y[index] = y;
                 emit d->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)
             {
                 replace(point.x(),point.y());
             }
             /*!
               Removes first \a x value and related y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 Q_D(QXYSeries);
                 int index = d->m_x.indexOf(x);
                 if (index == -1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 Q_D(QXYSeries);
                 int index =-1;
                 do {
                     index = d->m_x.indexOf(x,index+1);
                 } while (index !=-1 && d->m_y.at(index)!=y);
                 if (index==-1) return;
                 d->m_x.remove(index);
                 d->m_y.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 remove(point.x(),point.y());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 Q_D(QXYSeries);
                 d->m_x.clear();
                 d->m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
-                        return d->m_model->data(d->m_model->index(pos, d->m_mapX), Qt::DisplayRole).toDouble();
+                        return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
-                        return d->m_model->data(d->m_model->index(d->m_mapX, pos), Qt::DisplayRole).toDouble();
+                        return d->m_model->data(d->m_model->index(d->m_mapX, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_x.at(pos);
                 }
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
-                        return d->m_model->data(d->m_model->index(pos, d->m_mapY), Qt::DisplayRole).toDouble();
+                        return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
-                        return d->m_model->data(d->m_model->index(d->m_mapY, pos), Qt::DisplayRole).toDouble();
+                        return d->m_model->data(d->m_model->index(d->m_mapY, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_y.at(pos);
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 Q_ASSERT(d->m_x.size() == d->m_y.size());
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical) {
-                        // data is in a column. Return the number of mapped items
+                        // data is in a column. Return the number of mapped items if the model's column have enough items
-                        return d->m_model->rowCount();
+                        // or the number of items that can be mapped
+                        if (d->m_mapCount != -1)
+                            return qMin(d->m_mapCount, qMax(d->m_model->rowCount() - d->m_mapFirst, 0));
+                        else
+                            return qMax(d->m_model->rowCount() - d->m_mapFirst, 0);
                     } else {
-                        // data is in a row. Return the number of mapped items
+                        // data is in a row. Return the number of mapped items if the model's row have enough items
-                        return d->m_model->columnCount();
+                        // or the number of items that can be mapped
+                        if (d->m_mapCount != -1)
+                            return qMin(d->m_mapCount, qMax(d->m_model->columnCount() - d->m_mapFirst, 0));
+                        else
+                            return qMax(d->m_model->columnCount() - d->m_mapFirst, 0);
                     }
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return d->m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 Q_D(QXYSeries);
                 QList<QPointF> data;
                 for (int i(0); i < d->m_x.count() && i < d->m_y.count(); i++)
                     data.append(QPointF(d->m_x.at(i), d->m_y.at(i)));
                 return data;
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns true if drawing the data points of the series is enabled.
             */
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 append(points);
                 return *this;
             }
             /*!
-               \internal
-             */
-            void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
-                Q_UNUSED(bottomRight)
-                Q_D(QXYSeries);
-                if (d->m_mapOrientation == Qt::Vertical) {
-                    if (topLeft.column() == d->m_mapX || topLeft.column() == d->m_mapY)
-                        emit d->pointReplaced(topLeft.row());
-                } else {
-                    if (topLeft.row() == d->m_mapX || topLeft.row() == d->m_mapY)
-                        emit d->pointReplaced(topLeft.column());
-            /*!
                  \fn bool QXYSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
                  \sa setModelMapping()
              */
             bool QXYSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QXYSeries);
                 // disconnect signals from old model
                 if (d->m_model) {
                     QObject::disconnect(d->m_model, 0, this, 0);
                     d->m_mapX = -1;
                     d->m_mapY = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if (model) {
                     d->m_model = model;
                     return true;
                 } else {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation parameter specifies whether the data
                  is in columns or in rows.
                  \sa setModel()
              */
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 Q_D(QXYSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapX = modelX;
                 d->m_mapY = modelY;
                 d->m_mapOrientation = orientation;
-                connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+                // connect the signals from the model
+                connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+                if (d->m_mapOrientation == Qt::Vertical) {
+                    connect(d->m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(d->m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                } else {
+                    connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
+            }
+            void QXYSeries::setModelMappingRange(int first, int count)
+            {
+                Q_D(QXYSeries);
+                d->m_mapFirst = first;
+                d->m_mapCount = count;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) : QAbstractSeriesPrivate(q),
                 m_mapX(-1),
                 m_mapY(-1),
                 m_mapOrientation( Qt::Vertical),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 Q_Q(QXYSeries);
                 for (int i = 0; i < q->count(); i++)
                 {
                     qreal x = q->x(i);
                     qreal y = q->y(i);
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
+            void QXYSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
+            {
+                for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
+                    for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
+                        if (m_mapOrientation == Qt::Vertical) {
+                            if ((column == m_mapX || column == m_mapY)                          // modified item is in a mapped column
+                                    && row >= m_mapFirst                                        // modfied item in not before first item
+                                    && (m_mapCount == -1 || row < m_mapFirst + m_mapCount))     // map is not limited or item lays before the end of map
+                                emit pointReplaced(row - m_mapFirst);
+                        } else {
+                            if ((row == m_mapX || row == m_mapY)                                // modified item is in a mapped row
+                                    && column >= m_mapFirst                                     // modfied item in not before first item
+                                    && (m_mapCount == -1 || column < m_mapFirst + m_mapCount))  // map is not limited or item lays before the end of map
+                                emit pointReplaced(column - m_mapFirst);
+                        }
+                    }
+                }
+            }
+            void QXYSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
+            {
+                Q_UNUSED(parent);
+                emit pointsAdded(start, end);
+            }
+            void QXYSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
+            {
+                Q_UNUSED(parent);
+                emit pointsRemoved(start, end);
+            }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d,QObject *parent = 0);
                 ~QXYSeries();
             public:
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF &point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 bool setModel(QAbstractItemModel *model);
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
+                void setModelMappingRange(int first, int count = -1);
-            private Q_SLOTS:
+            //private Q_SLOTS:
-                void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
+            //    void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void selected();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries);
                 Q_DISABLE_COPY(QXYSeries);
                 friend class XYLegendMarker;
                 friend class XYChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries_p.h +9 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QXYSERIES_P_H
             #define QXYSERIES_P_H
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeries;
             class QXYSeriesPrivate: public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QXYSeriesPrivate(QXYSeries* q);
                 void scaleDomain(Domain& domain);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
+            private Q_SLOTS:
+                void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
+                void modelDataAdded(QModelIndex parent, int start, int end);
+                void modelDataRemoved(QModelIndex parent, int start, int end);
             Q_SIGNALS:
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
+                void pointsRemoved(int start, int end);
                 void pointAdded(int index);
+                void pointsAdded(int start, int end);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 int m_mapX;
                 int m_mapY;
                 Qt::Orientation m_mapOrientation;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QXYSeries);
                 friend class QScatterSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychartitem.cpp +70 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
                 m_minX(0),
                 m_maxX(0),
                 m_minY(0),
                 m_maxY(0),
                 m_series(series)
             {
                 connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
+                connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
                 connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+                connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
                 connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
             }
             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);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (m_series->x(index) - m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChartItem::calculateGeometryPoints() 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 y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
                     points << QPointF(x,y);
                 }
                 return points;
             }
             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);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
             void XYChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (animator()) {
                     animator()->updateLayout(this,oldPoints,newPoints,index);
                 } else {
                     setLayout(newPoints);
                 }
             }
             void XYChartItem::setLayout(QVector<QPointF> &points)
             {
                 m_points = points;
                 update();
             }
             //handlers
             void XYChartItem::handlePointAdded(int index)
             {
-                Q_ASSERT(index<m_series->count());
+                if (m_series->model() == 0) {
-                Q_ASSERT(index>=0);
+                    Q_ASSERT(index<m_series->count());
+                    Q_ASSERT(index>=0);
+                }
                 QVector<QPointF> points = m_points;
                 QPointF point;
                 point = calculateGeometryPoint(index);
                 points.insert(index, point);
                 updateLayout(m_points, points, index);
                 update();
             }
+            void XYChartItem::handlePointsAdded(int start, int end)
+            {
+                if (m_series->model() == 0) {
+                    for (int i = start; i <= end; i++)
+                        handlePointAdded(i);
+                } else {
+                    // series uses model as a data source
+                    int first = m_series->mapFirst();
+                    int count = m_series->mapCount();
+                    int addedCount = end - start + 1;
+                    if (count != -1 && start >= first + count) {
+                        return;
+                    }
+                    // adding items to unlimited map
+                    else if (count == -1 && start >= first) {
+                        for (int i = start; i <= end; i++)
+                            handlePointAdded(i - first);
+                    } else if (count == - 1 && start < first) {
+                        // not all newly added items
+                        for (int i = first; i < first + addedCount; i++)
+                            handlePointAdded(i - first);
+                    }
+                    // commented out code below does the same thing, but its more confusing.
+                    //        } else if (count == -1) {
+                    //            int begin = qMax(start, first);
+                    //            for (int i = begin; i < begin + (end - start + 1); i++)
+                    //                handlePointAdded(i - first);
+                    //        }
+                    // adding items to limited map
+                    else if (start >= first) {
+                        // remove the items that will no longer fit into the map
+                        // int toRemove = addedCount - (count - points().size());
+                        for (int i = start; i <= end; i++) {
+                            handlePointAdded(i - first);
+                        }
+                        if (m_points.size() > count)
+                            for (int i = m_points.size() - 1; i >= count; i--)
+                                handlePointRemoved(i);
+                        //            update();
+                    } else {
+                        //
+                        for (int i = first; i < first + addedCount; i++) {
+                            handlePointAdded(i - first);
+                        }
+                        if (m_points.size() > count)
+                            for (int i = m_points.size() - 1; i >= count; i--)
+                                handlePointRemoved(i);
+                    }
+                }
+            }
             void XYChartItem::handlePointRemoved(int index)
             {
-                Q_ASSERT(index<m_series->count() + 1);
+                if (m_series->model() == 0) {
-                Q_ASSERT(index>=0);
+                    Q_ASSERT(index<m_series->count() + 1);
+                    Q_ASSERT(index>=0);
+                }
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 updateLayout(m_points, points, index);
                 update();
             }
+            void XYChartItem::handlePointsRemoved(int start, int end)
+            {
+                Q_UNUSED(start)
+                Q_UNUSED(end)
+            }
             void XYChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.replace(index,point);
                 updateLayout(m_points,points,index);
                 update();
             }
             void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateLayout(m_points,points);
                 update();
             }
             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;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateLayout(m_points,points);
                 update();
             }
             bool XYChartItem::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY);
             }
             void XYChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychartitem_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChartItem :  public ChartItem
             {
                  Q_OBJECT
             public:
                  explicit XYChartItem(QXYSeries *series, ChartPresenter *presenter);
                 ~XYChartItem(){};
                 QVector<QPointF> points() const {return m_points;}
                 QRectF clipRect() const { return m_clipRect;}
             public Q_SLOTS:
                 void handlePointAdded(int index);
+                void handlePointsAdded(int start, int end);
                 void handlePointRemoved(int index);
+                void handlePointsRemoved(int start, int end);
                 void handlePointReplaced(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF& point);
             protected:
                 virtual void setLayout(QVector<QPointF> &points);
                 virtual void updateLayout(QVector<QPointF> &oldPoints,QVector<QPointF> &newPoints,int index = 0);
                 QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 friend class XYAnimation;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/tablemodelchart/tablewidget.cpp +4 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 m_tableView->setMinimumHeight(300);
                 //    tableView->setMinimumSize(340, 480);
                 //    tableView->setItemDelegate(new QStyledItemDelegate);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
+            //    m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(spinBoxLabel);
                 buttonsLayout->addWidget(m_linesCountSpinBox);
                 buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 m_lineRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                 radioLayout->addWidget(m_splineRadioButton);
                 radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 1, 1);
                 mainLayout->addLayout(radioLayout, 2, 1);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 2, 0);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
             }
             void TableWidget::updateChartType(bool toggle)
             {
                 // this if is needed, so that the function is only called once.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     m_chart->removeAllSeries();
                     m_chart->axisX()->setNiceNumbersEnabled(false);
                     m_chart->axisY()->setNiceNumbersEnabled(false);
                     // renable axes of the chart (pie hides them)
                     // x axis
                     QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     QPen pen;
                     pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
-            //            m_series->setModelMappingRange(1, 4);
+                        m_series->setModelMappingRange(4, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
-                        m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 4));
+                        m_model->addMapping(seriesColorHex, QRect(0, 4, 2, 4));
                         // series 2
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                         // series 3
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
-            //            m_series->setModelMappingRange(2, 0);
+                        m_series->setModelMappingRange(2, -1);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
             //            m_series->setModelMappingRange(1, 4);
                         //        series->setModelMapping(0,1, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 4));
                         // series 2
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
             //            m_series->setModelMappingRange(0, 0);
                         //        series->setModelMapping(2,3, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                         // series 3
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
             //            m_series->setModelMappingRange(2, 0);
                         //        series->setModelMapping(4,5, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }
                     else if (m_scatterRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
             //            m_series->setModelMappingRange(2, 0);
                         //        series->setModelMapping(0,1, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                         // series 2
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
             //            m_series->setModelMappingRange(1, 6);
                         //        series->setModelMapping(2,3, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                         // series 3
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
                         //        series->setModelMapping(4,5, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     }
                     else if (m_pieRadioButton->isChecked())
                     {
                         // pie 1
                         QPieSeries* pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(0,0, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.2);
                         pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 1, 1000));
                         // pie 2
                         pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(1,1, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.8);
                         pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 0, 1, 1000));
                         // pie 3
                         pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(2,2, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.5);
                         pieSeries->setVerticalPosition(0.65);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                     }
                     else if (m_areaRadioButton->isChecked())
                     {
                         QLineSeries* upperLineSeries = new QLineSeries;
                         upperLineSeries->setModel(m_model);
                         upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
             //            upperLineSeries->setModelMappingRange(1, 5);
                         QLineSeries* lowerLineSeries = new QLineSeries;
                         lowerLineSeries->setModel(m_model);
                         lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                         QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                         m_chart->addSeries(areaSeries);
                         seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     }
                     else if (m_barRadioButton->isChecked())
                     {
                         QBarSeries* barSeries = new QBarSeries(QStringList());
                         barSeries->setModel(m_model);
                         barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         m_chart->addSeries(barSeries);
                         QList<QBarSet*> barsets = barSeries->barSets();
                         for (int i = 0; i < barsets.count(); i++) {
                             seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                             m_model->addMapping(seriesColorHex, QRect(2 + i, 0, 1, 1000));
                         }
                     }
                     if (!m_barRadioButton->isChecked())
                         m_chart->axisX()->setRange(0, 500);
                     m_chart->axisY()->setRange(0, 120);
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             TableWidget::~TableWidget()
             {
             }

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