HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1056:65526593187b

PieSeries: model now supports custom mapping.

Marek Rosa -

r1056:65526593187b

parent child

Context file:

r1056:65526593187b

Collapse all files

src/animations/baranimation.cpp 0 0

NO CONTENT: modified file

src/barchart/qbarseries.cpp +192 -12

             /****************************************************************************
             **
             ** 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 "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include <QAbstractItemModel>
             #include <QModelIndex>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multiple
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, QString category)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategories categories, QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(categories, this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::QSeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
             */
             void QBarSeries::appendBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 d->m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 if (d->m_barSets.contains(set)) {
                     d->m_barSets.removeOne(set);
                     QObject::disconnect(set, SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                     emit d->restructuredBars();
                 }
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
             */
             void QBarSeries::appendBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     d->m_barSets.append(set);
                     QObject::connect(set, SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                 }
                 emit d->restructuredBars();
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
             void QBarSeries::removeBarSets(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if (d->m_barSets.contains(set)) {
                         d->m_barSets.removeOne(set);
                         QObject::disconnect(set, SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                     }
                 }
                 emit d->restructuredBars();
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                  \fn bool QBarSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QBarSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QBarSeries);
                 return d->setModel(model);
             }
             /*!
                  \fn bool QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
                  Sets column/row specified by \a categories to be used as a list of bar series categories.
                  Parameter \a bottomBoundry indicates the column/row where the first bar set is located in the model.
                  Parameter \a topBoundry indicates the column/row where the last bar set is located in the model.
                  All the columns/rows inbetween those two values are also used as data for bar sets.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QBarSeries::setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation)
             {
                 Q_D(QBarSeries);
                 d->setModelMapping(categories,bottomBoundary,topBoundary,orientation);
             }
+            void QBarSeries::setModelMappingRange(int first, int count)
+            {
+                Q_D(QBarSeries);
+                d->setModelMappingRange(first, count);
+            }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 foreach (QBarSet* s, barSets()) {
                     s->setLabelsVisible(visible);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarCategories categories, QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_categories(categories),
                 m_mapCategories(-1),
                 m_mapBarBottom(-1),
                 m_mapBarTop(-1)
             {
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 return m_categories.at(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category);
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category);
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category));
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = m_categories.count();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             bool QBarSeriesPrivate::setModel(QAbstractItemModel *model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     m_mapCategories = -1;
                     m_mapBarBottom = -1;
                     m_mapBarTop = -1;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = 0;
                     return false;
                 }
             }
             void QBarSeriesPrivate::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             {
                 Q_Q(QBarSeries);
                 if (m_model == 0)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
                 m_mapOrientation = orientation;
                 // connect the signals
-                connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+                connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
-                        this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+                if (m_mapOrientation == Qt::Vertical) {
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                } else {
+                    connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                }
                 // create the initial bars
                 m_categories.clear();
                 if (m_mapOrientation == Qt::Vertical) {
-                    for (int k = 0; k < m_model->rowCount(); k++) {
+                    int rowCount = 0;
+                    if(m_mapCount == -1)
+                        rowCount = m_model->rowCount() - m_mapFirst;
+                    else
+                        rowCount = qMin(m_mapCount, m_model->rowCount() - m_mapFirst);
+                    for (int k = m_mapFirst; k < m_mapFirst + rowCount; k++) {
                         m_categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
                     }
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
-                        for(int m = 0; m < m_model->rowCount(); m++)
+                        for(int m = m_mapFirst; m < m_mapFirst + rowCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
                         q->appendBarSet(barSet);
                     }
                 } else {
-                    for (int k = 0; k < m_model->columnCount(); k++) {
+                    int columnCount = 0;
+                    if(m_mapCount == -1)
+                        columnCount = m_model->columnCount() - m_mapFirst;
+                    else
+                        columnCount = qMin(m_mapCount, m_model->columnCount() - m_mapFirst);
+                    for (int k = m_mapFirst; k < m_mapFirst + columnCount; k++) {
                         m_categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
                     }
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Vertical, Qt::DisplayRole).toString());
-                        for(int m = 0; m < m_model->columnCount(); m++)
+                        for(int m = m_mapFirst; m < m_mapFirst + columnCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
                         q->appendBarSet(barSet);
                     }
                 }
             }
-            void QBarSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
+            void QBarSeriesPrivate::setModelMappingRange(int first, int count)
             {
-                Q_UNUSED(bottomRight)
+                m_mapFirst = first;
+                m_mapCount = count;
+            }
+            void QBarSeriesPrivate::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)
                         {
                             // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
-                    if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop)
+                            if ( row >= m_mapFirst && (m_mapCount == - 1 || row < m_mapFirst + m_mapCount)) {
-                        barsetAt(topLeft.column() - m_mapBarBottom)->replace(topLeft.row(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                if (column >= m_mapBarBottom && column <= m_mapBarTop)
+                                    barsetAt(column - m_mapBarBottom)->replace(row - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                //                    if (column == m_mapCategories);// TODO:
+                            }
                         }
                         else
                         {
                             // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
-                    if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop)
+                            if (column >= m_mapFirst && (m_mapCount == - 1 || column < m_mapFirst + m_mapCount)) {
-                        barsetAt(topLeft.row() - m_mapBarBottom)->replace(topLeft.column(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                if (row >= m_mapBarBottom && row <= m_mapBarTop)
+                                    barsetAt(row - m_mapBarBottom)->replace(column - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                //                    if (row == m_mapCategories);// TODO:
+                            }
+                        }
+                    }
+                }
+            }
+            void QBarSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
+            {
+                Q_UNUSED(parent);
+                Q_UNUSED(start);
+                Q_UNUSED(end);
+                initializeDataFromModel();
+            //    // series uses model as a data sourceupda
+            //    int addedCount = end - start + 1;
+            //    if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
+            //        return;
+            //    } else {
+            //        for (int bar = m_mapBarBottom; bar <= m_mapBarTop; bar++) {
+            //            QBarSet *barSet = barsetAt(bar - m_mapBarBottom);
+            //            // adding items to unlimited map
+            //            if (m_mapCount == -1 && start >= m_mapFirst) {
+            //                for (int i = start; i <= end; i++) {
+            //                    if (bar == m_mapBarBottom)
+            //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
+            //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
+            //                }
+            //            } else if (m_mapCount == - 1 && start < m_mapFirst) {
+            //                // not all newly added items
+            //                for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
+            //                    if (bar == m_mapBarBottom)
+            //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
+            //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
+            //                }
+            //            }
+            //            // adding items to limited map
+            //            else if (start >= m_mapFirst) {
+            //                // remove the items that will no longer fit into the map
+            //                // int toRemove = addedCount - (count - points().size());
+            //                for (int i = start; i <= end; i++) {
+            //                    if (bar == m_mapBarBottom)
+            //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
+            //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
+            //                }
+            //                if (m_barSets.size() > m_mapCount)
+            //                    for (int i = m_barSets.size() - 1; i >= m_mapCount; i--) {
+            //                        if (bar == m_mapBarBottom)
+            //                            removeCategory(i);
+            //                        barSet->remove(i);
+            //                    }
+            //            } else {
+            //                //
+            //                for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
+            //                    if (bar == m_mapBarBottom)
+            //                        insertCategory(i - m_mapFirst, m_model->data(m_model->index(i, m_mapCategories), Qt::DisplayRole).toString());
+            //                    barSet->insert(i - m_mapFirst, m_model->data(m_model->index(i, bar), Qt::DisplayRole).toDouble());
+            //                }
+            //                if (m_barSets.size() > m_mapCount)
+            //                    for (int i = m_barSets.size() - 1; i >= m_mapCount; i--) {
+            //                        if (bar == m_mapBarBottom)
+            //                            removeCategory(i);
+            //                        barSet->remove(i);
+            //                    }
+            //            }
+            //        }
+            //        emit restructuredBars();
+            //        emit barsetChanged();
+            //        emit categoriesUpdated();
+            //    }
+            }
+            void QBarSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
+            {
+                Q_UNUSED(parent);
+                Q_UNUSED(start);
+                Q_UNUSED(end);
+                initializeDataFromModel();
+            }
+            void QBarSeriesPrivate::initializeDataFromModel()
+            {
+                Q_Q(QBarSeries);
+                if (m_model == 0)
+                    return;
+                // connect the signals
+            //    connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+            //    if (m_mapOrientation == Qt::Vertical) {
+            //        connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+            //        connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+            //    } else {
+            //        connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+            //        connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+            //    }
+                // create the initial bars
+                m_categories.clear();
+                m_barSets.clear();
+                emit restructuredBars();
+                if (m_mapOrientation == Qt::Vertical) {
+                    int rowCount = 0;
+                    if(m_mapCount == -1)
+                        rowCount = m_model->rowCount() - m_mapFirst;
+                    else
+                        rowCount = qMin(m_mapCount, m_model->rowCount() - m_mapFirst);
+                    for (int k = m_mapFirst; k < m_mapFirst + rowCount; k++) {
+                        m_categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
+                    }
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
+                        QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
+                        for(int m = m_mapFirst; m < m_mapFirst + rowCount; m++)
+                            *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
+                        q->appendBarSet(barSet);
                     }
+                } else {
+                    int columnCount = 0;
+                    if(m_mapCount == -1)
+                        columnCount = m_model->columnCount() - m_mapFirst;
+                    else
+                        columnCount = qMin(m_mapCount, m_model->columnCount() - m_mapFirst);
+                    for (int k = m_mapFirst; k < m_mapFirst + columnCount; k++) {
+                        m_categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
+                    }
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
+                        QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Vertical, Qt::DisplayRole).toString());
+                        for(int m = m_mapFirst; m < m_mapFirst + columnCount; m++)
+                            *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
+                        q->appendBarSet(barSet);
+                    }
+                }
+                emit restructuredBars();
+                emit updatedBars();
+            }
+            void QBarSeriesPrivate::insertCategory(int index, const QString category)
+            {
+                m_categories.insert(index, category);
+                emit categoriesUpdated();
+            }
+            void QBarSeriesPrivate::removeCategory(int index)
+            {
+                m_categories.removeAt(index);
+                emit categoriesUpdated();
             }
             void QBarSeriesPrivate::barsetChanged()
             {
                 emit updatedBars();
             }
             void QBarSeriesPrivate::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());
                 qreal x = m_categories.count();
                 qreal y = max();
                 minX = qMin(minX, x);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +1 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 BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarCategory;
             class QBarSeriesPrivate;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QBarSeries(QBarCategories categories, QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::QSeriesType type() const;
                 void appendBarSet(QBarSet *set);            // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void appendBarSets(QList<QBarSet* > sets);
                 void removeBarSets(QList<QBarSet* > sets);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
                 bool setModel(QAbstractItemModel *model);
                 void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
+                void setModelMappingRange(int first, int count = -1);
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void hovered(QBarSet* barset, bool status);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarseries_p.h +8 0

             #ifndef QBARSERIES_P_H
             #define QBARSERIES_P_H
             #include "qbarseries.h"
             #include "qabstractseries_p.h"
             #include <QStringList>
             #include <QAbstractSeries>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Container for series
             class QBarSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QBarSeriesPrivate(QBarCategories categories, QBarSeries *parent);
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter* presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
                 bool setModel(QAbstractItemModel *model);
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
+                void setModelMappingRange(int first, int count = -1);
+                void insertCategory(int index, const QString category);
+                void removeCategory(int index);
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal absoluteCategorySum(int category);
                 qreal maxCategorySum();
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void updatedBars();
                 void restructuredBars();
+                void categoriesUpdated();
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
+                void modelDataAdded(QModelIndex parent, int start, int end);
+                void modelDataRemoved(QModelIndex parent, int start, int end);
+                void initializeDataFromModel();
                 void barsetChanged();
             protected:
                 QList<QBarSet *> m_barSets;
                 QBarCategories m_categories;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSERIESPRIVATE_P_H

src/barchart/qbarset.cpp +2 -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$
             **
             ****************************************************************************/
             #include "qbarset.h"
             #include "qbarset_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hovered(bool status)
                 \brief signals that mouse has hovered over the set. If \a status is true, then mouse was entered. If \a status is false, then mouse was left.
                 The signal is emitted if mouse is hovered on top of set
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(const QString name, QObject *parent)
                 : QObject(parent)
                 ,d_ptr(new QBarSetPrivate(name,this))
             {
             }
             /*!
                 Destroys the barset
             */
             QBarSet::~QBarSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(const QString name)
             {
                 d_ptr->m_name = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBarSet::append(const qreal value)
             {
                 d_ptr->m_values.append(value);
                 emit d_ptr->restructuredBars();
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
                 \sa remove()
             */
             void QBarSet::insert(const int index, const qreal value)
             {
                 d_ptr->m_values.insert(index, value);
-                emit d_ptr->updatedBars();
+            //    emit d_ptr->updatedBars();
             }
             /*!
                 Removes the value specified by \a index
                 \sa insert()
             */
             void QBarSet::remove(const int index)
             {
                 d_ptr->m_values.removeAt(index);
-                emit d_ptr->updatedBars();
+            //    emit d_ptr->updatedBars();
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::replace(const int index, const qreal value)
             {
                 d_ptr->m_values.replace(index,value);
                 emit d_ptr->updatedBars();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::at(const int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::operator [] (int index) const
             {
                 return d_ptr->m_values.at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count() const
             {
                 return d_ptr->m_values.count();
             }
             /*!
                 Returns sum of all values in barset.
             */
             qreal QBarSet::sum() const
             {
                 qreal total(0);
                 for (int i=0; i < d_ptr->m_values.count(); i++) {
                     total += d_ptr->m_values.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                   if(d_ptr->m_pen!=pen){
                       d_ptr->m_pen = pen;
                       emit d_ptr->updatedBars();
                   }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 if(d_ptr->m_brush!=brush){
                   d_ptr->m_brush = brush;
                   emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Sets \a pen of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelPen(const QPen &pen)
             {
                 if(d_ptr->m_labelPen!=pen){
                     d_ptr->m_labelPen = pen;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns pen of the values that are drawn on top of this barset
             */
             QPen QBarSet::labelPen() const
             {
                 return d_ptr->m_labelPen;
             }
             /*!
                 Sets \a brush of the values that are drawn on top of this barset
             */
             void QBarSet::setLabelBrush(const QBrush &brush)
             {
                 if(d_ptr->m_labelBrush!=brush){
                     d_ptr->m_labelBrush = brush;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns brush of the values that are drawn on top of this barset
             */
             QBrush QBarSet::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             /*!
                 Sets the \a font for values that are drawn on top of this barset
             */
             void QBarSet::setLabelFont(const QFont &font)
             {
                 if(d_ptr->m_labelFont!=font) {
                     d_ptr->m_labelFont = font;
                     emit d_ptr->updatedBars();
                 }
             }
             /*!
                 Returns the pen for values that are drawn on top of this set
             */
             QFont QBarSet::labelFont() const
             {
                 return d_ptr->m_labelFont;
             }
             /*!
                 Sets visibility of bar labels. If \a visible is true, labels are drawn on top of barsets.
             */
             void QBarSet::setLabelsVisible(bool visible)
             {
                 if(d_ptr->m_labelsVisible!=visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->labelsVisibleChanged(visible);
                 }
             }
             /*!
                 Returns the visibility of values
             */
             bool QBarSet::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSetPrivate::QBarSetPrivate(const QString name, QBarSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_name(name),
                 m_labelsVisible(false)
             {
             }
             QBarSetPrivate::~QBarSetPrivate()
             {
             }
             #include "moc_qbarset.cpp"
             #include "moc_qbarset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +241 -27

             /****************************************************************************
             **
             ** 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 "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::QSeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit d->added(slices);
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QPieSlice* slice)
             {
                 append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(index <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit d->added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
                 emit d->removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 0;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit d->removed(slices);
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeHorPos, relativePosition, 1.0))
                     emit d->piePositionChanged();
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeVerPos, relativePosition, 1.0))
                     emit d->piePositionChanged();
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeSize, relativeSize, 1.0))
                     emit d->pieSizeChanged();
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieStartAngle, angle, d->m_pieEndAngle))
                     d->updateDerivativeData();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieEndAngle, angle, 360.0, d->m_pieStartAngle))
                     d->updateDerivativeData();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                  \fn bool QPieSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(d->m_model)
                 {
                     disconnect(d->m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     d->m_model = model;
                     return true;
                 }
                 else
                 {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
                  Sets column/row specified by \a modelValuesLine to be used as a list of pie slice values for the pie.
                  Parameter \a modelValuesLine indicates the column/row where the values for the pie slices are located in the model.
                  Parameter \a modelLabelsLine indicates the column/row where the labels for the pie slices are located in the model.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
-                // connect the signals
+                d->initializePieFromModel();
-                connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+                //    // connect the signals
+                //    connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
-                // create the initial slices set
+                //    // create the initial slices set
-                if (d->m_mapOrientation == Qt::Vertical) {
+                //    if (d->m_mapOrientation == Qt::Vertical) {
-                    for (int i = 0; i < d->m_model->rowCount(); i++)
+                //        for (int i = 0; i < d->m_model->rowCount(); i++)
-                        append(d->m_model->data(d->m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
+                //            append(d->m_model->data(d->m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
-                } else {
+                //    } else {
-                    for (int i = 0; i < d->m_model->columnCount(); i++)
+                //        for (int i = 0; i < d->m_model->columnCount(); i++)
-                        append(d->m_model->data(d->m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
+                //            append(d->m_model->data(d->m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
+                //    }
             }
+            void QPieSeries::setModelMappingRange(int first, int count)
+            {
+                Q_D(QPieSeries);
+                d->m_mapFirst = first;
+                d->m_mapCount = count;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_mapValues(0),
                 m_mapLabels(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_sum = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate sum of all slices
                 foreach (QPieSlice* s, m_slices)
                     m_sum += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_sum;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     PieSliceData::data(s).emitChangedSignal(s);
             }
             QPieSeriesPrivate* QPieSeriesPrivate::seriesData(QPieSeries &series)
             {
                 return series.d_func();
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
-                Q_UNUSED(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 ( topLeft.row() >= m_mapFirst && (m_mapCount == - 1 || topLeft.row() < m_mapFirst + m_mapCount)) {
                                 if (topLeft.column() == m_mapValues)
-                        if (m_mapValues == m_mapLabels)
+                                    m_slices.at(topLeft.row() - m_mapFirst)->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                if (topLeft.column() == m_mapLabels)
-                            m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                    m_slices.at(topLeft.row() - m_mapFirst)->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
-                            m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
-                        else
-                            m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             }
-                    else if (topLeft.column() == m_mapLabels)
-                        m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
+                            if (topLeft.column() >= m_mapFirst && (m_mapCount == - 1 || topLeft.column() < m_mapFirst + m_mapCount)) {
                                 if (topLeft.row() == m_mapValues)
-                        if (m_mapValues == m_mapLabels)
+                                    m_slices.at(topLeft.column() - m_mapFirst)->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                                if (topLeft.row() == m_mapLabels)
+                                    m_slices.at(topLeft.column() - m_mapFirst)->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
+                            }
+                        }
+                    }
+                }
+            }
+            void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
-                            m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                Q_UNUSED(parent);
-                            m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
+                Q_Q(QPieSeries);
+                // series uses model as a data sourceupda
+                int addedCount = end - start + 1;
+                if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
+                    return;
+                } else {
+                    int first = qMax(start, m_mapFirst);
+                    int last = qMin(first + addedCount - 1, end);
+                    for (int i = first; i <= last; i++) {
+                        QPieSlice *slice = new QPieSlice;
+                        if (m_mapOrientation == Qt::Vertical) {
+                            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                        } else {
+                            slice->setValue(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble());
+                            slice->setLabel(m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
+                        }
+                        slice->setLabelVisible();
+                        q->insert(i - m_mapFirst, slice);
+                    }
+                    if (m_mapCount != -1 && m_slices.size() > m_mapCount)
+                        for (int i = m_slices.size() - 1; i >= m_mapCount; i--)
+                            q->remove(q->slices().at(i));
+                }
+                //    // adding items to unlimited map
+                //    else if (m_mapCount == -1 && start >= m_mapFirst) {
+                //        for (int i = start; i <= end; i++) {
+                //            QPieSlice *slice = new QPieSlice;
+                //            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                //            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                //            slice->setLabelVisible(true);
+                //            q->insert(i - m_mapFirst, slice);
+                //            //            handlePointAdded(i - first);
+                //        }
+                //    } else if (m_mapCount == - 1 && start < m_mapFirst) {
+                //        // not all newly added items
+                //        for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
+                //            QPieSlice *slice = new QPieSlice;
+                //            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                //            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                //            slice->setLabelVisible(true);
+                //            q->insert(i - m_mapFirst, slice);
+                //            //            handlePointAdded(i - first);
+                //        }
+                //    }
+                //    // adding items to limited map
+                //    else if (start >= m_mapFirst) {
+                //        // remove the items that will no longer fit into the map
+                //        // int toRemove = addedCount - (count - points().size());
+                //        for (int i = start; i <= end; i++) {
+                //            QPieSlice *slice = new QPieSlice;
+                //            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                //            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                //            slice->setLabelVisible(true);
+                //            q->insert(i - m_mapFirst, slice);
+                //        }
+                //        if (m_slices.size() > m_mapCount)
+                //            for (int i = m_slices.size() - 1; i >= m_mapCount; i--)
+                //                q->remove(q->slices().at(i));
+                //        //                handlePointRemoved(i);
+                //        //            update();
+                //    } else {
+                //        //
+                //        for (int i = m_mapFirst; i < m_mapFirst + addedCount; i++) {
+                //            QPieSlice *slice = new QPieSlice;
+                //            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                //            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                //            slice->setLabelVisible(true);
+                //            q->insert(i - m_mapFirst, slice);
+                //            //            handlePointAdded(i - first);
+                //        }
+                //        if (m_slices.size() > m_mapCount)
+                //            for (int i = m_slices.size() - 1; i >= m_mapCount; i--)
+                //                q->remove(q->slices().at(i));
+                //        //                handlePointRemoved(i);
+                //    }
+            }
+            void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
+            {
+                Q_UNUSED(parent);
+                Q_Q(QPieSeries);
+                int removedCount = end - start + 1;
+                if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
+                    return;
                 }
+            //    else if (m_mapCount == -1) {
+            //        int first = qMax(start, m_mapFirst);
+            //        int last = qMax(end, m_mapFirst + removedCount - 1);
+            //        for (int i = last; i >= first; i--)
+            //            q->remove(q->slices().at(i - m_mapFirst));
+            //    }
+            //    else {
+            //        int toRemove = qMin(m_slices.size() - 1, removedCount);
+            //        int first = qMax(start, m_mapFirst);
+            //        int last = qMax(end, m_mapFirst + toRemove - 1);
+            //    }
+                // removing items from unlimited map
+                else if (m_mapCount == -1 && start >= m_mapFirst) {
+                    for (int i = end; i >= start; i--)
+                        q->remove(q->slices().at(i - m_mapFirst));
+                    //            handlePointRemoved(i - m_mapFirst);
+                } else if (m_mapCount == - 1 && start < m_mapFirst) {
+                    // not all removed items
+                    for (int i = m_mapFirst + removedCount - 1; i >= m_mapFirst; i--)
+                        q->remove(q->slices().at(i - m_mapFirst));
+                    //            handlePointRemoved(i - m_mapFirst);
+                }
+                // removing items from limited map
+                else if (start >= m_mapFirst) {
+                    //
+            //        int sizeAfter = m_slices.size();
+                    int lastExisting = qMin(m_mapFirst + m_slices.size() - 1, end);
+                    for (int i = lastExisting; i >= start; i--) {
+                        q->remove(q->slices().at(i - m_mapFirst));
+            //            sizeAfter--;
+                        //            handlePointRemoved(i - m_mapFirst);
+                    }
+                    // the map is limited, so after removing the items some new items may have fall within the mapped area
+                    int itemsAvailable;
+                    if (m_mapOrientation == Qt::Vertical)
+                        itemsAvailable = m_model->rowCount() - m_mapFirst - m_slices.size();
                     else
+                        itemsAvailable = m_model->columnCount() - m_mapFirst - m_slices.size();
+                    int toBeAdded = qMin(itemsAvailable, m_mapCount - m_slices.size());
+                    int currentSize = m_slices.size();
+                    if (itemsAvailable > 0)
+                        for (int i = m_slices.size() + m_mapFirst; i < currentSize + toBeAdded + m_mapFirst; i++) {
+                            //                handlePointAdded(i);
+                            QPieSlice *slice = new QPieSlice;
+                            slice->setValue(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble());
+                            slice->setLabel(m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                            slice->setLabelVisible(true);
+                            q->insert(i - m_mapFirst, slice);
+                        }
+                    //        for (int i = lastExisting; i >= start; i--) {
+                    //            q->remove(q->slices().at(i - m_mapFirst));
+                    ////            sizeAfter--;
+                    ////            handlePointRemoved(i - m_mapFirst);
+                    //        }
+                } else {
+                    // first remove item lays before the mapped area
+                    int toRemove = qMin(m_slices.size(), removedCount);
+                    for (int i = m_mapFirst; i < m_mapFirst + toRemove; i++)
+                        q->remove(q->slices().at(0));
+                    //            handlePointRemoved(0);
+                    // the map is limited, so after removing the items some new items may have fall into the map
+                    int itemsAvailable;
+                    if (m_mapOrientation == Qt::Vertical)
+                        itemsAvailable = m_model->rowCount() - m_mapFirst - m_slices.size();
+                    else
+                        itemsAvailable = m_model->columnCount() - m_mapFirst - m_slices.size();
+                    int toBeAdded = qMin(itemsAvailable, m_mapCount - m_slices.size());
+                    int currentSize = m_slices.size();
+                    if (itemsAvailable > 0)
+                        for (int i = m_slices.size(); i < currentSize + toBeAdded; i++) {
+                            QPieSlice *slice = new QPieSlice;
+                            slice->setValue(m_model->data(m_model->index(i + m_mapFirst, m_mapValues), Qt::DisplayRole).toDouble());
+                            slice->setLabel(m_model->data(m_model->index(i + m_mapFirst, m_mapLabels), Qt::DisplayRole).toString());
+                            slice->setLabelVisible(true);
+                            q->insert(i, slice);
+                            //                handlePointAdded(i);
+                        }
+                }
+            }
+            void QPieSeriesPrivate::initializePieFromModel()
             {
-                            m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
+                Q_Q(QPieSeries);
+                // clear current content
+                q->clear();
+                // connect the signals
+                connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
+                if (m_mapOrientation == Qt::Vertical) {
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                } else {
+                    connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
-                    else if (topLeft.row() == m_mapLabels)
-                        m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
+                // create the initial slices set
+                if (m_mapOrientation == Qt::Vertical) {
+                    int sliceCount = 0;
+                    if(m_mapCount == -1)
+                        sliceCount = m_model->rowCount() - m_mapFirst;
+                    else
+                        sliceCount = qMin(m_mapCount, m_model->rowCount() - m_mapFirst);
+                    for (int i = m_mapFirst; i < m_mapFirst + sliceCount; i++)
+                        q->append(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
+                } else {
+                    int sliceCount = 0;
+                    if(m_mapCount == -1)
+                        sliceCount = m_model->columnCount() - m_mapFirst;
+                    else
+                        sliceCount = qMin(m_mapCount, m_model->columnCount() - m_mapFirst);
+                    for (int i = m_mapFirst; i < m_mapFirst + sliceCount; i++)
+                        q->append(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)
             {
                 // Remove rounding errors
                 qreal roundedValue = newValue;
                 if (qFuzzyIsNull(min) && qFuzzyIsNull(newValue))
                     roundedValue = 0.0;
                 else if (qFuzzyCompare(newValue, max))
                     roundedValue = max;
                 else if (qFuzzyCompare(newValue, min))
                     roundedValue = min;
                 // Check if the position is valid after removing the rounding errors
                 if (roundedValue < min || roundedValue > max) {
                     qWarning("QPieSeries: Illegal value");
                     return false;
                 }
                 if (!qFuzzyIsNull(value - roundedValue)) {
                     value = roundedValue;
                     return true;
                 }
                 // The change was so small it is considered a rounding error
                 return false;
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
             #ifndef QT_NO_DEBUG
                 qWarning() << __FILE__<<__FUNCTION__<<"not implemented";
             #endif
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +1 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 PIESERIES_H
             #define PIESERIES_H
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
                 Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
                 Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
                 Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
                 Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
                 QSeriesType type() const;
                 void append(QPieSlice* slice);
                 void append(QList<QPieSlice*> slices);
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* append(qreal value, QString name);
                 void insert(int index, QPieSlice* slice);
                 void remove(QPieSlice* slice);
                 void clear();
                 QList<QPieSlice*> slices() const;
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 void setLabelsVisible(bool visible = true);
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
+                void setModelMappingRange(int first, int count = -1);
             Q_SIGNALS:
                 void clicked(QPieSlice* slice);
                 void hovered(QPieSlice* slice, bool state);
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseries_p.h +4 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 QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
             #include "qabstractseries_p.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendPrivate;
             class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter *presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend *legend);
                 void updateDerivativeData();
                 static QPieSeriesPrivate* seriesData(QPieSeries &series);
             Q_SIGNALS:
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void piePositionChanged();
                 void pieSizeChanged();
             public Q_SLOTS:
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHovered(bool state);
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
+                void modelDataAdded(QModelIndex parent, int start, int end);
+                void modelDataRemoved(QModelIndex parent, int start, int end);
+                void initializePieFromModel();
                 bool setRealValue(qreal &value, qreal newValue, qreal max, qreal min = 0.0);
             public:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
                 // model map
                 int m_mapValues;
                 int m_mapLabels;
+                bool m_modelReady;
             private:
                 friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

src/xychart/xychartitem.cpp +2 -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$
             **
             ****************************************************************************/
             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QAbstractItemModel>
             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)
             {
                 if (m_series->model() == 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)
             {
                 if (m_series->model() == 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)
                 if (m_series->model() == 0) {
                     for (int i = end; i >= start; i--)
                         handlePointRemoved(i);
                 } else {
                     // series uses model as a data source
                     int first = m_series->mapFirst();
                     int count = m_series->mapCount();
                     int removedCount = end - start + 1;
                     if (count != -1 && start >= first + count) {
                         return;
                     }
                     // removing items from unlimited map
                     else if (count == -1 && start >= first) {
                         for (int i = end; i >= start; i--)
                             handlePointRemoved(i - first);
                     } else if (count == - 1 && start < first) {
                         // not all removed items
                         for (int i = first + removedCount - 1; i >= first; i--)
                             handlePointRemoved(i - first);
                     }
                     // removing items from limited map
                     else if (start >= first) {
                         //
                         int lastExisting = qMin(first + m_points.size() - 1, end);
                         for (int i = lastExisting; i >= start; i--) {
                             handlePointRemoved(i - first);
                         }
-                        // the map is limited, so after removing the items some new items may have fall into the map
+                        // the map is limited, so after removing the items some new items may have fall within the mapped area
                         int itemsAvailable;
                         if (m_series->mapOrientation() == Qt::Vertical)
                             itemsAvailable = m_series->model()->rowCount() - first - m_points.size();
                         else
                             itemsAvailable = m_series->model()->columnCount() - first - m_points.size();
                         int toBeAdded = qMin(itemsAvailable, count - m_points.size());
                         int currentSize = m_points.size();
                         if (itemsAvailable > 0)
                             for (int i = m_points.size(); i < currentSize + toBeAdded; i++)
                                 handlePointAdded(i);
                     } else {
-                        // TODO:
+                        // first removed item lays before the mapped area
                         int toRemove = qMin(m_points.size() - 1, removedCount);
                         for (int i = first; i < first + toRemove; i++)
                             handlePointRemoved(0);
                         // the map is limited, so after removing the items some new items may have fall into the map
                         int itemsAvailable;
                         if (m_series->mapOrientation() == Qt::Vertical)
                             itemsAvailable = m_series->model()->rowCount() - first - m_points.size();
                         else
                             itemsAvailable = m_series->model()->columnCount() - first - m_points.size();
                         int toBeAdded = qMin(itemsAvailable, count - m_points.size());
                         int currentSize = m_points.size();
                         if (itemsAvailable > 0)
                             for (int i = m_points.size(); i < currentSize + toBeAdded; i++)
                                 handlePointAdded(i);
                     }
                 }
             }
             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

test/tablemodelchart/customtablemodel.cpp +1 -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 "customtablemodel.h"
             #include <QVector>
             #include <QTime>
             #include <QRect>
             #include <QColor>
             CustomTableModel::CustomTableModel(QObject *parent) :
                 QAbstractTableModel(parent)
             {
                 //    m_points.append(QPointF(10, 50));
                 //    m_labels.append("Apples");
                 //    m_points.append(QPointF(60, 70));
                 //    m_labels.append("Oranges");
                 //    m_points.append(QPointF(110, 50));
                 //    m_labels.append("Bananas");
                 //    m_points.append(QPointF(140, 40));
                 //    m_labels.append("Lemons");
                 //    m_points.append(QPointF(200, 150));
                 //    m_labels.append("Plums");
                 //    m_points.append(QPointF(225, 75));
                 //    m_labels.append("Pearls");
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // m_data
-                for (int i = 0; i < 6; i++)
+                for (int i = 0; i < 8; i++)
                 {
                     QVector<qreal>* dataVec = new QVector<qreal>(6);
             //        QVector<QColor>* colorVec = new QVector<QColor>(6);
                     for (int k = 0; k < dataVec->size(); k++)
                     {
                         if (k%2 == 0)
                             dataVec->replace(k, i * 50 + qrand()%20);
                         else
                             dataVec->replace(k, qrand()%100);
             //            colorVec->replace(k, QColor(Qt::white));
                     }
                     m_data.append(dataVec);
                     m_labels.append(QString("Row: %1").arg((i + 1)));
             //        m_rowsColors.append(colorVec);
                 }
             }
             int CustomTableModel::rowCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
                 //    return m_points.count();
                 return m_data.count();
             }
             int CustomTableModel::columnCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
                 //    return 3;
                 return 6;
             }
             QVariant CustomTableModel::headerData (int section, Qt::Orientation orientation, int role ) const
             {
                 if (role != Qt::DisplayRole)
                     return QVariant();
                 if (orientation == Qt::Horizontal)
                 {
                     switch(section)
                     {
                     //        case 0:
                     //            return "x";
                     //        case 1:
                     //            return "y";
                     //        case 2:
                     case 6:
                         return "Fruit";
                     default:
                         if (section%2 == 0)
                             return "x";
                         else
                             return "y";
                         //            return "What?";
                     }
                 }
                 else
                     return QString("%1").arg(section /*+ 1*/);
             }
             QVariant CustomTableModel::data(const QModelIndex & index, int role) const
             {
                 if (role == Qt::DisplayRole)
                 {
                     switch(index.column())
                     {
                     //        case 0:
                     //            return m_points[index.row()].x();
                     //        case 1:
                     //            return m_points[index.row()].y();
                     //        case 2:
                     case 6:
                         return m_labels[index.row()];
                     default:
                         return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 else if (role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
                     //        case 0:
                     //            return m_points[index.row()].x();
                     //        case 1:
                     //            return m_points[index.row()].y();
                     //        case 2:
                     case 6:
                         return m_labels[index.row()];
                     default:
                         return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 else if (role == Qt::BackgroundRole)
                     {
                         QRect rect;
                         foreach(rect, m_mapping)
                             if(rect.contains(index.column(), index.row()))
                                 return QColor(m_mapping.key(rect));
                         // cell not mapped return white color
                         return QColor(Qt::white);
                     }
                 return QVariant();
             }
             bool CustomTableModel::setData ( const QModelIndex & index, const QVariant & value, int role)
             {
                 if (index.isValid() && role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
                     //        case 0:
                     //            m_points[index.row()].setX(value.toDouble());
                     //            break;
                     //        case 1:
                     //            m_points[index.row()].setY(value.toDouble());
                     //            break;
                     //        case 2:
                     case 6:
                         m_labels.replace(index.row(), value.toString());
                         break;
                     default:
                         m_data[index.row()]->replace(index.column(), value.toDouble());
                         break;
                         //            return false;
                     }
                     emit dataChanged(index, index);
                     return true;
                 }
             //    else if (role == Qt::BackgroundRole)
             //        {
             //            m_rowsColors[index.row()]->replace(index.column(), value.value<QColor>());
             //            return true;
             //        }
                 return false;
             }
             Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
             {
                 //    if (!index.isValid())
                 //                return Qt::ItemIsEnabled;
                 return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
             }
             bool CustomTableModel::insertRows ( int row, int count, const QModelIndex & parent)
             {
                 Q_UNUSED(parent)
                 if (row < 0)
                     row = 0;
                 beginInsertRows(QModelIndex(), row /*dataTable.count()*/, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
                     //        m_points.insert(row, QPointF(10,20));
                     QVector<qreal>* dataVec = new QVector<qreal>(6);
                     QVector<QColor>* colorVec = new QVector<QColor>(6);
                     for (int k = 0; k < dataVec->size(); k++)
                     {
                         if (k%2 == 0)
                             //                dataVec->replace(k, i * 50 + qrand()%20);
                         {
                             int difference = 0;
                             if (i < m_data.size())
                             {
                                 if (i - 1 >= 0)
                                 {
                                     if (row > 0)
                                         difference = (int)((qAbs(m_data[i]->at(k) - m_data[row - 1]->at(k)))/count);
                                     else
                                         difference = (int)((qAbs(m_data[i]->at(k)/count)));
                                     dataVec->replace(k, m_data[i - 1]->at(k) + qrand()%qMax(1, difference));
                                 }
                                 else
                                     dataVec->replace(k, qrand()%40 + 10);
                             }
                             else
                             {
                                 if (i - 1 >= 0)
                                 {
                                     dataVec->replace(k, m_data[i - 1]->at(k) + qrand()%40 + 10);
                                 }
                                 else
                                 {
                                     dataVec->replace(k, qrand()%40 + 10);
                                 }
                             }
                         }
                         else
                             dataVec->replace(k, qrand()%100);
                         colorVec->replace(k, QColor(Qt::white));
                     }
                     m_data.insert(i, dataVec);
                     m_labels.insert(i,(QString("Row: %1").arg(i + 1)));
             //        m_rowsColors.insert(i, colorVec);
                 }
                 endInsertRows();
                 return true;
             }
             bool CustomTableModel::removeRows ( int row, int count, const QModelIndex & parent)
             {
                 if (row > this->rowCount() - 1)
                     return false;
                 if (row < 0)
                     row = 0;
                 if (row + count > rowCount())
                     return false;
                 beginRemoveRows(parent, row, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
                     //        m_points.removeAt(row);
                     QVector<qreal>* item = m_data.at(row);
                     m_data.removeAt(row);
                     delete item;
                     m_labels.removeAt(row);
                 }
                 endRemoveRows();
                 return true;
             }
             void CustomTableModel::addMapping(QString color, QRect area)
             {
                 m_mapping.insertMulti(color, area);
             }
             void CustomTableModel::addMapping(QString color, int left, int top, int right, int bottom)
             {
                 addMapping(color, QRect(QPoint(left, top), QPoint(right, bottom)));
             }

test/tablemodelchart/tablewidget.cpp +46 -13

             /****************************************************************************
             **
             ** 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 "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)
+                : QWidget(parent),specialPie(0)
             {
-                setGeometry(100, 100, 1000, 600);
+                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);
                 //    tableView->setMinimumSize(340, 480);
                 //    tableView->setItemDelegate(new QStyledItemDelegate);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
-            //    m_chart->setAnimationOptions(QChart::SeriesAnimations);
+                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* specialPieButton = new QPushButton("Test pie");
+                connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 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(specialPieButton);
                 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) {
+                    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())
                     {
                         // series 1
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
                         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, 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, -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->setModelMappingRange(3, 3);
                         pieSeries->setModelMapping(0,0, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
-                        pieSeries->setPieSize(0.4);
+                        pieSeries->setPieSize(0.35);
                         pieSeries->setHorizontalPosition(0.2);
-                        pieSeries->setVerticalPosition(0.35);
+                        pieSeries->setVerticalPosition(0.3);
                         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));
+                        m_model->addMapping(seriesColorHex, QRect(0, 3, 1, 3));
                         // pie 2
                         pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
+                        pieSeries->setModelMappingRange(2, -1);
                         pieSeries->setModelMapping(1,1, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
-                        pieSeries->setPieSize(0.4);
+                        pieSeries->setPieSize(0.35);
                         pieSeries->setHorizontalPosition(0.8);
-                        pieSeries->setVerticalPosition(0.35);
+                        pieSeries->setVerticalPosition(0.3);
                         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));
+                        m_model->addMapping(seriesColorHex, QRect(1, 2, 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->setPieSize(0.35);
-                        pieSeries->setHorizontalPosition(0.5);
+                        pieSeries->setHorizontalPosition(0.2);
-                        pieSeries->setVerticalPosition(0.65);
+                        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())
                     {
                         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->setModelMappingRange(2, 5);
                         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->axisY()->setRange(0, 120);
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
+            void TableWidget::testPie()
+            {
+                if (specialPie) {
+                    specialPie->remove(specialPie->slices().at(2));
+                    //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
+                    specialPie->append(4, "heloo");
+                }
+            }
             TableWidget::~TableWidget()
             {
             }

test/tablemodelchart/tablewidget.h +7 -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$
             **
             ****************************************************************************/
             #ifndef TABLEWIDGET_H
             #define TABLEWIDGET_H
             #include <QtGui/QWidget>
+            //#include <QChartGlobal>
             #include "qchartview.h"
-            #include "qxyseries.h"
+            //#include "qxyseries.h"
+            //#include <QPieSeries>
-            QTCOMMERCIALCHART_USE_NAMESPACE
             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 updateChartType(bool toggle);
+                void testPie();
                 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;
+                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