HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1295:2f3c0756d825

BarModelMapper: implemented model updated slots. Some more work needed with categories

Marek Rosa -

r1295:2f3c0756d825

parent child

Context file:

r1295:2f3c0756d825

Collapse all files

src/barchart/qbarmodelmapper.cpp +50 -34

             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 //    connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 //    connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 //    connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::firstBarSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSection;
             }
             void QBarModelMapper::setFirstBarSection(int firstBarSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSection = firstBarSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::lastBarSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSection;
             }
             void QBarModelMapper::setLastBarSection(int lastBarSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSection = lastBarSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::categoriesSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_categoriesSection;
             }
             void QBarModelMapper::setCategoriesSection(int categoriesSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_categoriesSection = categoriesSection;
                 d->initializeBarFromModel();
             }
             void QBarModelMapper::reset()
             {
                 Q_D(QBarModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_orientation = Qt::Vertical;
                 d->m_firstBarSection = -1;
                 d->m_lastBarSection = -1;
                 d->m_categoriesSection = -1;
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSection(-1),
                 m_lastBarSection(-1),
                 m_categoriesSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
+            QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
+            {
+                if (!index.isValid())
+                    return 0;
+                if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSection && index.column() <= m_lastBarSection) {
+                    if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count))
+                        return m_series->barSets().at(index.column() - m_firstBarSection);
+                } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSection && index.row() <= m_lastBarSection) {
+                    if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
+                        return m_series->barSets().at(index.row() - m_firstBarSection);
+                }
+                return 0; // This part of model has not been mapped to any slice
+            }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSection || barSection > m_lastBarSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
             QModelIndex QBarModelMapperPrivate::categoriesModelIndex(int posInCategories)
             {
                 if (m_count != -1 && posInCategories >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInCategories + m_first, m_categoriesSection);
                 else
                     return m_model->index(m_categoriesSection, posInCategories + m_first);
             }
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
-                //    blockSeriesSignals();
+                blockSeriesSignals();
-                //    QModelIndex index;
+                QModelIndex index;
                 //    QPointF oldPoint;
                 //    QPointF newPoint;
-                //    for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
+                for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
-                //        for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
+                    for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
-                //            index = topLeft.sibling(row, column);
+                        index = topLeft.sibling(row, column);
-                //            if (m_orientation == Qt::Vertical && (index.column() == m_xSection|| index.column() == m_ySection)) {
+                        QBarSet* bar = barSet(index);
-                //                if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
+                        if (bar) {
-                //                    oldPoint = m_series->points().at(index.row() - m_first);
+                            if (m_orientation == Qt::Vertical)
-                //                    newPoint.setX(m_model->data(m_model->index(index.row(), m_xSection)).toReal());
+                                bar->replace(row - m_first, m_model->data(index).toReal());
-                //                    newPoint.setY(m_model->data(m_model->index(index.row(), m_ySection)).toReal());
+                            else
-                //                }
+                                bar->replace(column - m_first, m_model->data(index).toReal());
-                //            } else if (m_orientation == Qt::Horizontal && (index.row() == m_xSection || index.row() == m_ySection)) {
-                //                if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
-                //                    oldPoint = m_series->points().at(index.column() - m_first);
-                //                    newPoint.setX(m_model->data(m_model->index(m_xSection, index.column())).toReal());
+                blockSeriesSignals(false);
-                //                    newPoint.setY(m_model->data(m_model->index(m_ySection, index.column())).toReal());
-                //                }
-                //            } else {
-                //                continue;
-                //            }
-                //            m_series->replace(oldPoint, newPoint);
-                //        }
-                //        blockSeriesSignals(false);
-                //    }
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
+                Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
-                    insertData(start, end);
+                    //        insertData(start, end);
+                    initializeBarFromModel();
                 else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
+                Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
-                    removeData(start, end);
+                    //        removeData(start, end);
+                    initializeBarFromModel();
                 else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
+                Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
-                    insertData(start, end);
+                    //        insertData(start, end);
+                    initializeBarFromModel();
                 else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
+                Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
-                    removeData(start, end);
+                    //        removeData(start, end);
+                    initializeBarFromModel();
                 else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
-                    for (int i = first; i <= last; i++) {
+                    for (int k = 0; k < m_series->barSets().count(); k++) {
-                        QPointF point;
+                        for (int i = first; i <= last; i++) {
-                        point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
+                            QBar point;
-                        point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
+                            point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
-                        m_series->insert(i - m_first, point);
+                            point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
+                            m_series->insert(i - m_first, point);
+                        }
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->points().size() > m_count)
                         for (int i = m_series->points().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->points().at(i));
                         }
                 }*/
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 //    int removedCount = end - start + 1;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int toRemove = qMin(m_series->count(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->count() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->points().at(i - m_first));
                     }
                     if (m_count != -1) {
                         int itemsAvailable;     // check how many are available to be added
                         if (m_orientation == Qt::Vertical)
                             itemsAvailable = m_model->rowCount() - m_first - m_series->count();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->count();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->count());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->count();
                         if (toBeAdded > 0)
                             for (int i = m_series->count(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 point.setX(m_model->data(xModelIndex(i), Qt::DisplayRole).toDouble());
                                 point.setY(m_model->data(yModelIndex(i), Qt::DisplayRole).toDouble());
                                 m_series->insert(i, point);
                             }
                     }
                 }*/
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
-                //    m_series->clear();
+                m_series->clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSection; i <= m_lastBarSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     QBarSet *barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal).toString());
                     //    QModelIndex yIndex = yModelIndex(pointPos);
                     while (barIndex.isValid()) {
                         barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                         posInBar++;
                         barIndex = barModelIndex(i, posInBar);
                     }
                     m_series->append(barSet);
                 }
                 if (m_categoriesSection != -1) {
                     int posInCategories = 0;
                     QStringList categories;
                     QModelIndex categoriesIndex = categoriesModelIndex(posInCategories);
                     while (categoriesIndex.isValid()) {
                         categories.append(m_model->data(categoriesIndex, Qt::DisplayRole).toString());
                         posInCategories++;
                         categoriesIndex = categoriesModelIndex(posInCategories);
                     }
                     m_series->setCategories(categories);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarmodelmapper_p.h +3 0

             #ifndef QBARMODELMAPPER_P_H
             #define QBARMODELMAPPER_P_H
             #include "qchartglobal.h"
             #include <QObject>
             #include "qbarmodelmapper.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QBarSet;
             class QBarModelMapperPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QBarModelMapperPrivate(QBarModelMapper *q);
             public Q_SLOTS:
                 // for the model
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelRowsAdded(QModelIndex parent, int start, int end);
                 void modelRowsRemoved(QModelIndex parent, int start, int end);
                 void modelColumnsAdded(QModelIndex parent, int start, int end);
                 void modelColumnsRemoved(QModelIndex parent, int start, int end);
             //    // for the series
             //    void handlePointAdded(int pointPos);
             //    void handlePointRemoved(int pointPos);
             //    void handlePointReplaced(int pointPos);
                 void initializeBarFromModel();
             private:
+                QBarSet* barSet(QModelIndex index);
                 QModelIndex barModelIndex(int barSection, int posInBar);
                 QModelIndex categoriesModelIndex(int posInCategories);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
                 void blockModelSignals(bool block = true);
                 void blockSeriesSignals(bool block = true);
             private:
                 QBarSeries *m_series;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;
                 Qt::Orientation m_orientation;
                 int m_firstBarSection;
                 int m_lastBarSection;
                 int m_categoriesSection;
                 bool m_seriesSignalsBlock;
                 bool m_modelSignalsBlock;
             private:
                 QBarModelMapper *q_ptr;
                 Q_DECLARE_PUBLIC(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_P_H

src/barchart/qbarseries.cpp +7 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$
             **
             ****************************************************************************/
             #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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                 the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                 and y-value is the height of the bar. The category names are ignored with this series and x-axis
                 shows the x-values.
                 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.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
                 if(d->m_dataset){
                     d->m_dataset->removeSeries(this);
                 }
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             /*!
                 Sets the \a categories, which are used to to group the data.
             */
             void QBarSeries::setCategories(QBarCategories categories)
             {
                 Q_D(QBarSeries);
                 d->setCategories(categories);
                 emit d->categoriesUpdated();
             }
             void QBarSeries::setBarMargin(qreal margin)
             {
                 Q_D(QBarSeries);
                 d->setBarMargin(margin);
             }
             qreal QBarSeries::barMargin() const
             {
                 Q_D(const QBarSeries);
                 return d->barMargin();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 return d->append(set);
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
                 Returns true, if set was removed.
             */
             bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 return d->remove(set);
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
                 Returns true, if all sets were appended succesfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 return d->append(sets);
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
             bool QBarSeries::remove(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 return d->remove(sets);
             }
+            void QBarSeries::clear()
+            {
+                Q_D(QBarSeries);
+                d->m_barSets.clear();
+                d->m_categories.clear();
+            }
             /*!
                 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->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->categories();
             }
             void QBarSeries::setVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 d->setVisible(visible);
             }
             bool QBarSeries::isVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->isVisible();
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QBarSeries);
                 if (d->m_labelsVisible != visible) {
                     d->m_labelsVisible = visible;
                     emit d->updatedBars();
                 }
             }
             bool QBarSeries::isLabelsVisible() const
             {
                 Q_D(const QBarSeries);
                 return d->m_labelsVisible;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barMargin(0.5),  // Default value is 50% of category width
                 m_labelsVisible(false),
                 m_visible(true)
             {
             }
             void QBarSeriesPrivate::setCategories(QBarCategories categories)
             {
                 m_categories = categories;
             }
             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();
             }
             int QBarSeriesPrivate::categoryCount() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories.count();
                 }
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i=0; i<m_barSets.count(); i++) {
                     if (m_barSets.at(i)->count() > count) {
                         count = m_barSets.at(i)->count();
                     }
                 }
                 return count;
             }
             QBarCategories QBarSeriesPrivate::categories() const
             {
                 if (m_categories.count() > 0) {
                     return m_categories;
                 }
                 // No categories defined. retun list of indices.
                 QBarCategories categories;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     categories.append(QString::number(i));
                 }
                 return categories;
             }
             void QBarSeriesPrivate::setBarMargin(qreal margin)
             {
                 if (margin > 1.0) {
                     margin = 1.0;
                 } else if (margin < 0.0) {
                     margin = 0.0;
                 }
                 m_barMargin = margin;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barMargin() const
             {
                 return m_barMargin;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             void QBarSeriesPrivate::setVisible(bool visible)
             {
                 if (m_visible != visible) {
                     m_visible = visible;
                     emit updatedBars();
                 }
             }
             bool QBarSeriesPrivate::isVisible() const
             {
                 return m_visible;
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 if ((category >= 0) && (category < m_categories.count())) {
                     return m_categories.at(category);
                 }
                 return QString::number(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).y();
                         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).y();
                         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).y();
             }
             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).y();
                 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).y();
                 }
                 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).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             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 = categoryCount();
                 qreal y = max();
                 minX = qMin(minX, x) - 0.5;
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x) - 0.5;
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,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;
             }
             bool QBarSeriesPrivate::append(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if ((m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();      // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::remove(QBarSet *set)
             {
                 Q_Q(QBarSeries);
                 if (!m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                 }
                 if (m_dataset) {
                     m_dataset->updateSeries(q);   // this notifies legend
                 }
                 emit restructuredBars();        // this notifies barchartitem
                 return true;
             }
             bool QBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
                 Q_Q(QBarSeries);
                 bool setsRemoved = false;
                 foreach (QBarSet* set, sets) {
                     if (m_barSets.contains(set)) {
                         m_barSets.removeOne(set);
                         QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(barsetChanged()));
                         setsRemoved = true;
                     }
                 }
                 if (setsRemoved) {
                     if (m_dataset) {
                         m_dataset->updateSeries(q);   // this notifies legend
                     }
                     emit restructuredBars();        // this notifies barchartitem
                 }
                 return setsRemoved;
             }
             #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>
             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(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setCategories(QBarCategories categories);
                 void setBarMargin(qreal margin);
                 qreal barMargin() const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool append(QList<QBarSet* > sets);
                 bool remove(QList<QBarSet* > sets);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
+                void clear();
                 void setVisible(bool visible = true);
                 bool isVisible() const;
                 void setLabelsVisible(bool visible = true);
                 bool isLabelsVisible() const;
             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;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/xychart/qxymodelmapper.cpp +2 -2

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

tests/tablemodelchart/tablewidget.cpp +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QVXYModelMapper>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QVPieModelMapper>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             #include <QHeaderView>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent),
                   m_series(0),
                   m_mapper(0),
                   m_model(0),
                   m_pieMapper(0),
                   m_pieMapper2(0)
                 //      specialPie(0)
             {
                 setGeometry(1900, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 //    m_tableView->setMinimumHeight(300);
                 m_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 QPushButton* addColumnRightButton = new QPushButton("Add column to the right");
                 connect(addColumnRightButton, SIGNAL(clicked()), this, SLOT(addColumnRight()));
                 QPushButton* removeColumnButton = new QPushButton("Remove column");
                 connect(removeColumnButton, SIGNAL(clicked()), this, SLOT(removeColumn()));
                 QPushButton* specialPieButton = new QPushButton("Add slices using series API");
                 connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 QPushButton* specialPieButton2 = new QPushButton("Remove slices using series API");
                 connect(specialPieButton2, SIGNAL(clicked()), this, SLOT(testPie2()));
                 QPushButton* specialPieButton3 = new QPushButton("Modify slices using series API");
                 connect(specialPieButton3, SIGNAL(clicked()), this, SLOT(testPie3()));
                 QPushButton* xyTestButton = new QPushButton("Append XY point");
                 connect(xyTestButton, SIGNAL(clicked()), this, SLOT(testXY()));
                 QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(spinBoxLabel);
                 buttonsLayout->addWidget(m_linesCountSpinBox);
                 //    buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 //    buttonsLayout->addWidget(addColumnRightButton);
                 //    buttonsLayout->addWidget(removeColumnButton);
                 buttonsLayout->addWidget(specialPieButton);
                 buttonsLayout->addWidget(specialPieButton2);
                 buttonsLayout->addWidget(specialPieButton3);
                 buttonsLayout->addWidget(xyTestButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 m_barRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                 radioLayout->addWidget(m_splineRadioButton);
                 radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 //    radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 2, 0);
                 mainLayout->addLayout(radioLayout, 3, 0);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 1, 1, 2, 1);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
             }
             void TableWidget::addColumnRight()
             {
                 m_model->insertColumns(m_tableView->currentIndex().column() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeColumn()
             {
                 m_model->removeColumns(m_tableView->currentIndex().column(), qMin(m_model->columnCount() - m_tableView->currentIndex().column(), m_linesCountSpinBox->value()));
             }
             void TableWidget::updateChartType(bool toggle)
             {
                 // this if is needed, so that the function is only called once.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     //        specialPie = 0;
                     m_chart->removeAllSeries();
                     m_series = 0;
                     //        m_chart->axisX()->setNiceNumbersEnabled(false);
                     //        m_chart->axisY()->setNiceNumbersEnabled(false);
                     if (m_mapper) {
                         m_mapper->deleteLater();
                         m_mapper = 0;
                     }
                     if (m_pieMapper) {
                         m_pieMapper->deleteLater();
                         m_pieMapper = 0;
                     }
                     if (m_pieMapper2) {
                         m_pieMapper2->deleteLater();
                         m_pieMapper2 = 0;
                     }
                     //        if (m_series) {
                     //            delete m_series;
                     //            m_series = 0;
                     //        }
                     // renable axes of the chart (pie hides them)
                     // x axis
                     QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     //        QPen pen;
                     //        pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QLineSeries;
                         m_mapper = new QVXYModelMapper;
                         m_mapper->setModel(m_model);
                         m_mapper->setSeries(m_series);
                         m_mapper->setXColumn(0);
                         m_mapper->setYColumn(1);
                         m_mapper->setFirst(3);
                         m_mapper->setCount(4);
                         //            m_series->setModelMapping(0,1, Qt::Vertical);
                         //            m_series->setModelMappingRange(3, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 3, 2, 4));
                         //            // series 2
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(3);
                         //            mapper->setMapY(4);
                         //            //            mapper->setFirst(3);
                         //            //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(3, 0, 2, 1000));
                         //            // series 3
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(5);
                         //            mapper->setMapY(6);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(2, -1);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(5, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         m_mapper = new QVXYModelMapper;
                         m_mapper->setSeries(m_series);
                         m_mapper->setModel(m_model);
                         m_mapper->setXColumn(0);
                         m_mapper->setYColumn(1);
                         m_mapper->setFirst(0);
                         m_mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 2, 1000));
                         //            // series 2
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(2);
                         //            mapper->setMapY(3);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 2, 2, 4));
                         //            // series 3
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(4);
                         //            mapper->setMapY(5);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }        else if (m_scatterRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QScatterSeries;
                         m_mapper = new QVXYModelMapper;
                         m_mapper->setSeries(m_series);
                         m_mapper->setModel(m_model);
                         m_mapper->setXColumn(0);
                         m_mapper->setYColumn(1);
                         m_mapper->setFirst(0);
                         m_mapper->setCount(-1);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                         //            // series 2
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(1, 6);
                         //            //        series->setModelMapping(2,3, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                         //            // series 3
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //        series->setModelMapping(4,5, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     } else if (m_pieRadioButton->isChecked()) {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         // pie 1
                         m_pieSeries = new QPieSeries;
                         m_pieMapper = new QVPieModelMapper;
                         m_pieMapper->setValuesColumn(1);
                         m_pieMapper->setLabelsColumn(7);
                         m_pieMapper->setSeries(m_pieSeries);
                         m_pieMapper->setModel(m_model);
                         m_pieMapper->setFirst(2);
                         //                        m_pieMapper->setCount(5);
                         //                    pieSeries->setModelMapper(mapper);
                         m_pieSeries->setLabelsVisible(true);
                         m_pieSeries->setPieSize(0.35);
                         m_pieSeries->setHorizontalPosition(0.25);
                         m_pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(m_pieSeries);
                         seriesColorHex = "#" + QString::number(m_pieSeries->slices().at(m_pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 2, 1, 50));
                         //                            pieSeries->slices().at(0)->setValue(400);
                         //                            pieSeries->slices().at(0)->setLabel(QString("36"));
                         // pie 2
                         m_pieSeries2 = new QPieSeries;
                         m_pieMapper2 = new QVPieModelMapper;
                         m_pieMapper2->setValuesColumn(0);
                         m_pieMapper2->setLabelsColumn(7);
                         m_pieMapper2->setModel(m_model);
                         m_pieMapper2->setSeries(m_pieSeries2);
                         m_pieMapper2->setFirst(2);
                         m_pieSeries2->setLabelsVisible(true);
                         m_pieSeries2->setPieSize(0.35);
                         m_pieSeries2->setHorizontalPosition(0.75);
                         m_pieSeries2->setVerticalPosition(0.65);
                         m_chart->addSeries(m_pieSeries2);
                         seriesColorHex = "#" + QString::number(m_pieSeries2->slices().at(m_pieSeries2->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 1, 1000));
                         //            // pie 3
                         //            pieSeries = new QPieSeries;
                         //            pieSeries->setModel(m_model);
                         //            pieSeries->setModelMapping(2,2, Qt::Vertical);
                         //            pieSeries->setLabelsVisible(true);
                         //            pieSeries->setPieSize(0.35);
                         //            pieSeries->setHorizontalPosition(0.5);
                         //            pieSeries->setVerticalPosition(0.75);
                         //            m_chart->addSeries(pieSeries);
                         //            seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                         //            // special pie
                         //            specialPie = new QPieSeries;
                         //            specialPie->append(17, "1");
                         //            specialPie->append(45, "2");
                         //            specialPie->append(77, "3");
                         //            specialPie->append(37, "4");
                         //            specialPie->append(27, "5");
                         //            specialPie->append(47, "6");
                         //            specialPie->setPieSize(0.35);
                         //            specialPie->setHorizontalPosition(0.8);
                         //            specialPie->setVerticalPosition(0.75);
                         //            specialPie->setLabelsVisible(true);
                         //            m_chart->addSeries(specialPie);
                     }
                     //        else if (m_areaRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            QLineSeries* upperLineSeries = new QLineSeries;
                     //            upperLineSeries->setModel(m_model);
                     //            upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
                     //            //            upperLineSeries->setModelMappingRange(1, 5);
                     //            QLineSeries* lowerLineSeries = new QLineSeries;
                     //            lowerLineSeries->setModel(m_model);
                     //            lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                     //            QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                     //            m_chart->addSeries(areaSeries);
                     //            seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                     //            m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     //        }
                     else if (m_barRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         QGroupedBarSeries* barSeries = new QGroupedBarSeries();
             //            barSeries->setCategories(QStringList());
             //            barSeries->setModel(m_model);
                         //            barSeries->setModelMappingRange(2, 5);
                         //                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         int first = 3;
-                        int count = 4;
+            //            int count = 4;
                         QVBarModelMapper *mapper = new QVBarModelMapper;
                         mapper->setCategoriesSection(5);
                         mapper->setFirstBarSection(2);
                         mapper->setLastBarSection(4);
                         mapper->setFirst(first);
-                        mapper->setCount(count);
+            //            mapper->setCount(count);
                         mapper->setSeries(barSeries);
                         mapper->setModel(m_model);
             //            barSeries->setModelMapper(mapper);
                         m_chart->addSeries(barSeries);
                         QList<QBarSet*> barsets = barSeries->barSets();
                         for (int i = 0; i < barsets.count(); i++) {
                             seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
-                            m_model->addMapping(seriesColorHex, QRect(2 + i, first, 1, count));
+                            m_model->addMapping(seriesColorHex, QRect(2 + i, first, 1, barsets.at(i)->count()));
                         }
                     }
                     if (!m_barRadioButton->isChecked()) {
                         m_chart->axisX()->setRange(0, 500);
                         m_chart->axisY()->setRange(0, 220);
                     }
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             void TableWidget::testPie()
             {
                 //    m_pieMapper->setCount(-1);
                 QPieSlice *slice = new QPieSlice("Hehe", 145);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 slice = new QPieSlice("Hoho", 34);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 //    m_series->modelMapper()->setMapX(4);
                 //    m_tableView->setColumnWidth(10, 250);
                 //    if (specialPie) {
                 //        specialPie->remove(specialPie->slices().at(2));
                 //        //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
                 //        specialPie->append(4, "heloo");
                 //    }
             }
             void TableWidget::testPie2()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     m_pieSeries->remove(slice);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     m_pieSeries->remove(slice);
                 }
             }
             void TableWidget::testPie3()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     slice->setLabel("Dalej");
                     slice->setValue(222);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     slice->setLabel("Prawie");
                     slice->setValue(111);
                 }
             }
             void TableWidget::testXY()
             {
                 //    if (m_series->type() != QAbstractSeries::SeriesTypeLine) {
                 //        m_series->append(QPointF(150, 75));
                 //    }
                 if (m_series->count() > 0) {
                     m_series->remove(m_series->points().last());
                 }
             }
             TableWidget::~TableWidget()
             {
             }

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