HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1262:61ed30bfe89b

XYModelMapper slots for series signals implemented

Marek Rosa -

r1262:61ed30bfe89b

parent child

Context file:

r1262:61ed30bfe89b

Collapse all files

src/xychart/qxymodelmapper.cpp +35 -4

             #include "qxymodelmapper.h"
             #include "qxymodelmapper_p.h"
             #include "qxyseries.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QXYModelMapper::QXYModelMapper(QObject *parent):
                 QObject(parent),
                 d_ptr(new QXYModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             }
             void QXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QXYModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeXYFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QXYSeries* QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;
             }
             void QXYModelMapper::setSeries(QXYSeries *series)
             {
                 Q_D(QXYModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeXYFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
-                connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(pointReplaced(int)));
+                connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QXYModelMapper::first() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_first;
             }
             void QXYModelMapper::setFirst(int first)
             {
                 Q_D(QXYModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::count() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_count;
             }
             void QXYModelMapper::setCount(int count)
             {
                 Q_D(QXYModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeXYFromModel();
             }
             Qt::Orientation QXYModelMapper::orientation() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_orientation;
             }
             void QXYModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QXYModelMapper);
                 d->m_orientation = orientation;
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::xSection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_xSection;
             }
             void QXYModelMapper::setXSection(int xSection)
             {
                 Q_D(QXYModelMapper);
                 d->m_xSection = xSection;
                 d->initializeXYFromModel();
             }
             int QXYModelMapper::ySection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_ySection;
             }
             void QXYModelMapper::setYSection(int ySection)
             {
                 Q_D(QXYModelMapper);
                 d->m_ySection = ySection;
                 d->initializeXYFromModel();
             }
             void QXYModelMapper::reset()
             {
                 Q_D(QXYModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_orientation = Qt::Vertical;
                 d->m_xSection = -1;
                 d->m_ySection = -1;
                 d->initializeXYFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYModelMapperPrivate::QXYModelMapperPrivate(QXYModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_xSection(-1),
                 m_ySection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QXYModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QXYModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QModelIndex QXYModelMapperPrivate::xModelIndex(int xPos)
             {
                 if (m_count != -1 && xPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(xPos + m_first, m_xSection);
                 else
                     return m_model->index(m_xSection, xPos + m_first);
             }
             QModelIndex QXYModelMapperPrivate::yModelIndex(int yPos)
             {
                 if (m_count != -1 && yPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(yPos + m_first, m_ySection);
                 else
                     return m_model->index(m_ySection, yPos + m_first);
             }
             void QXYModelMapperPrivate::handlePointAdded(int pointPos)
             {
-                Q_UNUSED(pointPos)
+                if (m_seriesSignalsBlock)
+                    return;
+                if (m_count != -1)
+                    m_count += 1;
+                blockModelSignals();
+                if (m_orientation == Qt::Vertical)
+                    m_model->insertRows(pointPos + m_first, 1);
+                else
+                    m_model->insertColumns(pointPos + m_first, 1);
+                m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
+                m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
+                blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointRemoved(int pointPos)
             {
-                Q_UNUSED(pointPos)
+                if (m_seriesSignalsBlock)
+                    return;
+                if (m_count != -1)
+                    m_count -= 1;
+                blockModelSignals();
+                if (m_orientation == Qt::Vertical)
+                    m_model->removeRow(pointPos + m_first);
+                else
+                    m_model->removeColumn(pointPos + m_first);
+                blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointReplaced(int pointPos)
             {
-                Q_UNUSED(pointPos)
+                if (m_seriesSignalsBlock)
+                    return;
+                blockModelSignals();
+                m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
+                m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
+                blockModelSignals(false);
             }
             void QXYModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 QPointF oldPoint;
                 QPointF newPoint;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         if (m_orientation == Qt::Vertical && (index.column() == m_xSection|| index.column() == m_ySection)) {
                             if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                                 oldPoint = m_series->points().at(index.row() - m_first);
                                 newPoint.setX(m_model->data(m_model->index(index.row(), m_xSection)).toReal());
                                 newPoint.setY(m_model->data(m_model->index(index.row(), m_ySection)).toReal());
                             }
                         } else if (m_orientation == Qt::Horizontal && (index.row() == m_xSection || index.row() == m_ySection)) {
                             if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
                                 oldPoint = m_series->points().at(index.column() - m_first);
                                 newPoint.setX(m_model->data(m_model->index(m_xSection, index.column())).toReal());
                                 newPoint.setY(m_model->data(m_model->index(m_ySection, index.column())).toReal());
                             }
                         } else {
                             continue;
                         }
                         m_series->replace(oldPoint, newPoint);
                     }
                     blockSeriesSignals(false);
                 }
             }
             void QXYModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::insertData(int start, int end)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int i = first; i <= last; i++) {
                         QPointF point;
                         point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                         point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                         m_series->insert(i - m_first, point);
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->points().size() > m_count)
                         for (int i = m_series->points().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->points().at(i));
                         }
                 }
             }
             void QXYModelMapperPrivate::removeData(int start, int end)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 int removedCount = end - start + 1;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } else {
                     int toRemove = qMin(m_series->points().size(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->points().size() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->points().at(i - m_first));
                     }
                     if (m_count != -1) {
                         int itemsAvailable;     // check how many are available to be added
                         if (m_orientation == Qt::Vertical)
                             itemsAvailable = m_model->rowCount() - m_first - m_series->points().size();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->points().size();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->points().size());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->points().size();
                         if (toBeAdded > 0)
                             for (int i = m_series->points().size(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 point.setX(m_model->data(xModelIndex(i), Qt::DisplayRole).toDouble());
                                 point.setY(m_model->data(yModelIndex(i), Qt::DisplayRole).toDouble());
                                 m_series->insert(i, point);
                             }
                     }
                 }
             }
             void QXYModelMapperPrivate::initializeXYFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial slices set
                 int pointPos = 0;
                 QModelIndex xIndex = xModelIndex(pointPos);
                 QModelIndex yIndex = yModelIndex(pointPos);
                 while (xIndex.isValid() && yIndex.isValid()) {
                     QPointF point;
                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                     point.setY(m_model->data(yIndex, Qt::DisplayRole).toDouble());
                     m_series->append(point);
                     pointPos++;
                     xIndex = xModelIndex(pointPos);
                     yIndex = yModelIndex(pointPos);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qxymodelmapper.cpp"
             #include "moc_qxymodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +8 -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 "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             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 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)
             {
                 append(QPointF(x,y));
             }
             /*!
                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)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
-                emit d->pointAdded(d->m_points.count()-1);
+            //    emit d->pointAdded(d->m_points.count()-1);
+                emit pointAdded(d->m_points.count()-1);
             }
             /*!
                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);
                 }
             }
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
-                emit d->pointReplaced(index);
+            //    emit d->pointReplaced(index);
+                emit pointReplaced(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
-                emit d->pointRemoved(index);
+            //    emit d->pointRemoved(index);
+                emit pointRemoved(index);
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 Q_D(QXYSeries);
                 foreach(const QPointF& point, d->m_points) {
                     remove(point);
                 }
             }
             void QXYSeries::insert(int index, const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points.insert(index, point);
-                emit d->pointAdded(index);
+            //    emit d->pointAdded(index);
+                emit pointAdded(index);
             }
             void QXYSeries::clear()
             {
                 Q_D(QXYSeries);
                 for (int i = d->m_points.size() - 1; i >= 0; i--)
                     remove(d->m_points.at(i));
             }
             /*!
                 \internal \a pos
             */
             QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.toList();
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 return d->m_points.count();
             }
             /*!
                 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;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
                 QAbstractSeriesPrivate(q),
                 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);
                 const QList<QPointF>& points = q->points();
                 if(points.isEmpty()){
                     minX=0.0;
                     minY=0.0;
                     maxX=1.0;
                     maxY=1.0;
                 }
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 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 QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             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 oldX,qreal oldY,qreal newX,qreal newY);
                 void replace(const QPointF &oldPoint,const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
                 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;
             Q_SIGNALS:
                 void clicked(const QPointF &point);
+                void pointReplaced(int index);
+                void pointRemoved(int index);
+                void pointAdded(int index);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries_p.h +3 -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$
             **
             ****************************************************************************/
             //  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);
             Q_SIGNALS:
                 void updated();
-                void pointReplaced(int index);
+            //    void pointReplaced(int index);
-                void pointRemoved(int index);
+            //    void pointRemoved(int index);
-                void pointAdded(int index);
+            //    void pointAdded(int index);
             protected:
                 QVector<QPointF> m_points;
                 QPen m_pen;
                 QBrush m_brush;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QXYSeries);
                 friend class QScatterSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychart.cpp +7 -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 "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             #include "qxymodelmapper.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter):Chart(presenter),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series),
             m_animation(0),
             m_dirty(true)
             {
-                QObject::connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
+            //    QObject::connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
-                QObject::connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
+            //    QObject::connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
-                QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
+            //    QObject::connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
-                QObject::connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
+                QObject::connect(series, SIGNAL(pointReplaced(int)), this,SLOT(handlePointReplaced(int)));
+                QObject::connect(series, SIGNAL(pointAdded(int)), this,SLOT(handlePointAdded(int)));
+                QObject::connect(series, SIGNAL(pointRemoved(int)), this,SLOT(handlePointRemoved(int)));
+                QObject::connect(this, SIGNAL(clicked(QPointF)), series,SIGNAL(clicked(QPointF)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF>& points)
             {
                 m_points = points;
             }
             void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
             void XYChart::setAnimation(XYAnimation* animation)
             {
                 m_animation=animation;
             }
             void XYChart::setDirty(bool dirty)
             {
             	m_dirty=dirty;
             }
             QPointF XYChart::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 XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX)* deltaX;
                 qreal y = (vector[index].y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX)* deltaX;
                     qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChart::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 XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (m_animation) {
                     m_animation->setValues(oldPoints, newPoints, index);
                     setGeometryPoints(newPoints);
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QVector<QPointF> points;
             	if(m_animation) {
             		m_animation->setAnimationType(XYAnimation::AddPointAnimation);
             	}
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		QPointF point = calculateGeometryPoint(index);
             		points.insert(index, point);
             	}
                 updateChart(m_points,points,index);
             }
             void XYChart::handlePointRemoved(int index)
             {
             	Q_ASSERT(index<=m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_animation) {
             		m_animation->setAnimationType(XYAnimation::RemovePointAnimation);
             	}
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		points = m_points;
             		points.remove(index);
             	}
             	updateChart(m_points,points,index);
             }
             void XYChart::handlePointReplaced(int index)
             {
             	Q_ASSERT(index<m_series->count());
             	Q_ASSERT(index>=0);
             	QVector<QPointF> points;
             	if(m_animation) {
             		m_animation->setAnimationType(XYAnimation::ReplacePointAnimation);
             	}
             	if(m_dirty) {
             		points = calculateGeometryPoints();
             	} else {
             		QPointF point = calculateGeometryPoint(index);
             		points = m_points;
             		points.replace(index,point);
             	}
             	updateChart(m_points,points,index);
             }
             void XYChart::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();
                 if(m_animation) {
                     m_animation->setAnimationType(XYAnimation::ReplacePointAnimation);
                 }
                 updateChart(m_points,points);
             }
             void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 m_origin=rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 if(m_animation) {
                       m_animation->setAnimationType(XYAnimation::NewAnimation);
                 }
                 updateChart(m_points,points);
             }
             bool XYChart::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/tablemodelchart/tablewidget.cpp +19 -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 "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QVXYModelMapper>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QVPieModelMapper>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QBarModelMapper>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             #include <QHeaderView>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
                 //      specialPie(0)
             {
                 setGeometry(1900, 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);
                 m_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 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()));
                 QPushButton* addColumnRightButton = new QPushButton("Add column to the right");
                 connect(addColumnRightButton, SIGNAL(clicked()), this, SLOT(addColumnRight()));
                 QPushButton* removeColumnButton = new QPushButton("Remove column");
                 connect(removeColumnButton, SIGNAL(clicked()), this, SLOT(removeColumn()));
                 QPushButton* specialPieButton = new QPushButton("Add slices using series API");
                 connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 QPushButton* specialPieButton2 = new QPushButton("Remove slices using series API");
                 connect(specialPieButton2, SIGNAL(clicked()), this, SLOT(testPie2()));
                 QPushButton* specialPieButton3 = new QPushButton("Modify slices using series API");
                 connect(specialPieButton3, SIGNAL(clicked()), this, SLOT(testPie3()));
+                QPushButton* xyTestButton = new QPushButton("Append XY point");
+                connect(xyTestButton, SIGNAL(clicked()), this, SLOT(testXY()));
                 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->addWidget(addColumnRightButton);
                 //    buttonsLayout->addWidget(removeColumnButton);
                 buttonsLayout->addWidget(specialPieButton);
                 buttonsLayout->addWidget(specialPieButton2);
                 buttonsLayout->addWidget(specialPieButton3);
+                buttonsLayout->addWidget(xyTestButton);
                 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, 2, 0);
                 mainLayout->addLayout(radioLayout, 3, 0);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 1, 1, 2, 1);
                 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::addColumnRight()
             {
                 m_model->insertColumns(m_tableView->currentIndex().column() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeColumn()
             {
                 m_model->removeColumns(m_tableView->currentIndex().column(), qMin(m_model->columnCount() - m_tableView->currentIndex().column(), 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) {
                     //        specialPie = 0;
                     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())
                     {
-                        //            m_chart->setAnimationOptions(QChart::NoAnimation);
+                                    m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QLineSeries(this);
                         QVXYModelMapper *mapper = new QVXYModelMapper;
                         mapper->setModel(m_model);
                         mapper->setSeries(m_series);
                         mapper->setXColumn(0);
                         mapper->setYColumn(1);
                         mapper->setFirst(3);
-                        //            mapper->setCount(4);
+                                    mapper->setCount(4);
                         //            m_series->setModelMapping(0,1, Qt::Vertical);
                         //            m_series->setModelMappingRange(3, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 3, 2, 4));
                         //            // series 2
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(3);
                         //            mapper->setMapY(4);
                         //            //            mapper->setFirst(3);
                         //            //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            //            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(3, 0, 2, 1000));
                         //            // series 3
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(5);
                         //            mapper->setMapY(6);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //            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(5, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         //            m_chart->setAnimationOptions(QChart::NoAnimation);
                         //            // series 1
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            QXYModelMapper *mapper = new QXYModelMapper;
                         //            mapper->setMapX(0);
                         //            mapper->setMapY(1);
                         //            mapper->setFirst(0);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(0, 0, 2, 1000));
                         //            // series 2
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(2);
                         //            mapper->setMapY(3);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 2, 2, 4));
                         //            // series 3
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(4);
                         //            mapper->setMapY(5);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            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())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            // 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())
                     {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         // pie 1
                         m_pieSeries = new QPieSeries;
                         m_pieMapper = new QVPieModelMapper;
                         m_pieMapper->setValuesColumn(1);
                         m_pieMapper->setLabelsColumn(7);
                         m_pieMapper->setSeries(m_pieSeries);
                         m_pieMapper->setModel(m_model);
-            //            m_pieMapper->setFirst(2);
+                        m_pieMapper->setFirst(2);
                         //                        m_pieMapper->setCount(5);
                         //                    pieSeries->setModelMapper(mapper);
                         m_pieSeries->setLabelsVisible(true);
                         m_pieSeries->setPieSize(0.35);
                         m_pieSeries->setHorizontalPosition(0.25);
                         m_pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(m_pieSeries);
                         seriesColorHex = "#" + QString::number(m_pieSeries->slices().at(m_pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 2, 1, 50));
                         //                            pieSeries->slices().at(0)->setValue(400);
                         //                            pieSeries->slices().at(0)->setLabel(QString("36"));
                         // pie 2
                         m_pieSeries2 = new QPieSeries;
                         m_pieMapper = new QVPieModelMapper;
                         m_pieMapper->setValuesColumn(0);
                         m_pieMapper->setLabelsColumn(7);
                         m_pieMapper->setModel(m_model);
                         m_pieMapper->setSeries(m_pieSeries2);
-            //            m_pieMapper->setFirst(2);
+                        m_pieMapper->setFirst(2);
                         m_pieSeries2->setLabelsVisible(true);
                         m_pieSeries2->setPieSize(0.35);
                         m_pieSeries2->setHorizontalPosition(0.75);
                         m_pieSeries2->setVerticalPosition(0.65);
                         m_chart->addSeries(m_pieSeries2);
                         seriesColorHex = "#" + QString::number(m_pieSeries2->slices().at(m_pieSeries2->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 1, 1000));
                         //            // pie 3
                         //            pieSeries = new QPieSeries;
                         //            pieSeries->setModel(m_model);
                         //            pieSeries->setModelMapping(2,2, Qt::Vertical);
                         //            pieSeries->setLabelsVisible(true);
                         //            pieSeries->setPieSize(0.35);
                         //            pieSeries->setHorizontalPosition(0.5);
                         //            pieSeries->setVerticalPosition(0.75);
                         //            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));
                         //            // special pie
                         //            specialPie = new QPieSeries;
                         //            specialPie->append(17, "1");
                         //            specialPie->append(45, "2");
                         //            specialPie->append(77, "3");
                         //            specialPie->append(37, "4");
                         //            specialPie->append(27, "5");
                         //            specialPie->append(47, "6");
                         //            specialPie->setPieSize(0.35);
                         //            specialPie->setHorizontalPosition(0.8);
                         //            specialPie->setVerticalPosition(0.75);
                         //            specialPie->setLabelsVisible(true);
                         //            m_chart->addSeries(specialPie);
                     }
                     //        else if (m_areaRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            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())
                     {
                         //                    m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         //                    QGroupedBarSeries* barSeries = new QGroupedBarSeries();
                         //                    barSeries->setCategories(QStringList());
                         //                    barSeries->setModel(m_model);
                         //                    //            barSeries->setModelMappingRange(2, 5);
                         ////                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         //                    QBarModelMapper *mapper = new QBarModelMapper;
                         //                    mapper->setMapCategories(5);
                         //                    mapper->setMapBarBottom(2);
                         //                    mapper->setMapBarTop(4);
                         //                    barSeries->setModelMapper(mapper);
                         //                    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, 220);
                     }
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             void TableWidget::testPie()
             {
                 //    m_pieMapper->setCount(-1);
                 QPieSlice *slice = new QPieSlice("Hehe", 145);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 slice = new QPieSlice("Hoho", 34);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 //    m_series->modelMapper()->setMapX(4);
                 //    m_tableView->setColumnWidth(10, 250);
                 //    if (specialPie) {
                 //        specialPie->remove(specialPie->slices().at(2));
                 //        //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
                 //        specialPie->append(4, "heloo");
                 //    }
             }
             void TableWidget::testPie2()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     m_pieSeries->remove(slice);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     m_pieSeries->remove(slice);
                 }
             }
             void TableWidget::testPie3()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     slice->setLabel("Dalej");
                     slice->setValue(222);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     slice->setLabel("Prawie");
                     slice->setValue(111);
                 }
             }
+            void TableWidget::testXY()
+            {
+            //    if (m_series->type() != QAbstractSeries::SeriesTypeLine) {
+            //        m_series->append(QPointF(150, 75));
+            //    }
+                if (m_series->count() > 0) {
+                    m_series->remove(m_series->points().last());
+                }
+            }
             TableWidget::~TableWidget()
             {
             }

tests/tablemodelchart/tablewidget.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 TABLEWIDGET_H
             #define TABLEWIDGET_H
             #include <QtGui/QWidget>
             //#include <QChartGlobal>
             #include "qchartview.h"
             //#include "qxyseries.h"
             #include <QPieSeries>
             #include <QVPieModelMapper>
             class CustomTableModel;
             class QTableView;
             class QRadioButton;
             class QSpinBox;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class TableWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 TableWidget(QWidget *parent = 0);
                 ~TableWidget();
                 public slots:
                 void addRowAbove();
                 void addRowBelow();
                 void removeRow();
                 void addColumnRight();
                 void removeColumn();
                 void updateChartType(bool toggle);
                 void testPie();
                 void testPie2();
                 void testPie3();
+                void testXY();
                 private:
                 QChartView* m_chartView;
                 QChart* m_chart;
                 QXYSeries* m_series;
                 CustomTableModel* m_model;
                 QTableView* m_tableView;
                 QRadioButton* m_lineRadioButton;
                 QRadioButton* m_splineRadioButton;
                 QRadioButton* m_scatterRadioButton;
                 QRadioButton* m_pieRadioButton;
                 QRadioButton* m_areaRadioButton;
                 QRadioButton* m_barRadioButton;
                 QSpinBox* m_linesCountSpinBox;
                 QVPieModelMapper *m_pieMapper;
                 QPieSeries* m_pieSeries;
                 QVPieModelMapper *m_pieMapper2;
                 QPieSeries* m_pieSeries2;
             //    QPieSeries* specialPie;
             };
             #endif // TABLEWIDGET_H

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