HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2870:ea9744cf9a34

Fix model resetting in with model mappers...

Joni Poikelin -

r2870:ea9744cf9a34

parent child

Context file:

r2870:ea9744cf9a34

Collapse all files

src/charts/barchart/qbarmodelmapper.cpp +1 0

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #include <QtCharts/QBarModelMapper>
             #include <private/qbarmodelmapper_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QChart>
             #include <QtCore/QAbstractItemModel>
             QT_CHARTS_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(modelReset()), d, SLOT(initializeBarFromModel()));
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QAbstractBarSeries *QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QAbstractBarSeries *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(barsetsAdded(QList<QBarSet*>)), d, SLOT(barSetsAdded(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(barsetsRemoved(QList<QBarSet*>)), d, SLOT(barSetsRemoved(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row of the model contains the \a first values of the QBarSets in the series.
                 The default value is 0.
             */
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the number of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             /*!
                 Sets the \a count of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = qMax(-1, firstBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = qMax(-1, lastBarSetSection);
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-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_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         return m_series->barSets().at(index.column() - m_firstBarSetSection);
                     }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 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_firstBarSetSection || barSection > m_lastBarSetSection)
                     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);
             }
             void QBarModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             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();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet *bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
                             QBarSet *bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
                                 bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::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_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::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_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::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_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::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_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently barchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently barchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->barSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for (int i = 0; i < sets.count(); i++) {
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 }
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBarSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBarSetSection, sets.count());
                 for (int i = firstIndex + m_firstBarSetSection; i < firstIndex + m_firstBarSetSection + sets.count(); i++) {
                     m_model->setHeaderData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, sets.at(i - firstIndex - m_firstBarSetSection)->label());
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBarSetSection)->count(); j++)
                         m_model->setData(barModelIndex(i, j), sets.at(i - firstIndex - m_firstBarSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_barSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBarSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_barSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBarSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesAdded(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += count;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(index + m_first, count);
                 else
                     m_model->insertColumns(index + m_first, count);
                 for (int j = index; j < index + count; j++)
                     m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, j), m_barSets.at(barSetIndex)->at(j));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesRemoved(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= count;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(index + m_first, count);
                 else
                     m_model->removeColumns(index + m_first, count);
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setHeaderData(barSetIndex + m_firstBarSetSection, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, m_barSets.at(barSetIndex)->label());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, index), m_barSets.at(barSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_barSets.clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     // check if there is such model index
                     if (barIndex.isValid()) {
                         QBarSet *barSet = new QBarSet(m_model->headerData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical).toString());
                         while (barIndex.isValid()) {
                             barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             barIndex = barModelIndex(i, posInBar);
                         }
                         connect(barSet, SIGNAL(valuesAdded(int,int)), this, SLOT(valuesAdded(int,int)));
                         connect(barSet, SIGNAL(valuesRemoved(int,int)), this, SLOT(valuesRemoved(int,int)));
                         connect(barSet, SIGNAL(valueChanged(int)), this, SLOT(barValueChanged(int)));
                         connect(barSet, SIGNAL(labelChanged()), this, SLOT(barLabelChanged()));
                         m_series->append(barSet);
                         m_barSets.append(barSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/boxplotchart/qboxplotmodelmapper.cpp +1 0

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #include <QtCharts/QBoxPlotModelMapper>
             #include <private/qboxplotmodelmapper_p.h>
             #include <QtCharts/QBoxPlotSeries>
             #include <QtCharts/QBoxSet>
             #include <QtCharts/QChart>
             #include <QtCore/QAbstractItemModel>
             QT_CHARTS_BEGIN_NAMESPACE
             QBoxPlotModelMapper::QBoxPlotModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBoxPlotModelMapperPrivate(this))
             {
             }
             QAbstractItemModel *QBoxPlotModelMapper::model() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_model;
             }
             void QBoxPlotModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBoxPlotModelMapper);
                 if (d->m_model)
                     disconnect(d->m_model, 0, d, 0);
                 d->m_model = model;
                 d->initializeBoxFromModel();
                 // connect signals from the model
+                connect(d->m_model, SIGNAL(modelReset()), d, SLOT(initializeBoxFromModel()));
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QBoxPlotSeries *QBoxPlotModelMapper::series() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_series;
             }
             void QBoxPlotModelMapper::setSeries(QBoxPlotSeries *series)
             {
                 Q_D(QBoxPlotModelMapper);
                 if (d->m_series)
                     disconnect(d->m_series, 0, d, 0);
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBoxFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(boxsetsAdded(QList<QBoxSet *>)), d, SLOT(boxSetsAdded(QList<QBoxSet *>)));
                 connect(d->m_series, SIGNAL(boxsetsRemoved(QList<QBoxSet *>)), d, SLOT(boxSetsRemoved(QList<QBoxSet *>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBoxSets in the series.
                 The default value is 0.
             */
             int QBoxPlotModelMapper::first() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row/column of the model contains the \a first values of the QBoxSets in the series.
                 The default value is 0.
             */
             void QBoxPlotModelMapper::setFirst(int first)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns the number of rows/columns of the model that are mapped as the data for QBoxPlotSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBoxPlotModelMapper::count() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_count;
             }
             /*!
                 Sets the \a count of rows/columns of the model that are mapped as the data for QBoxPlotSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBoxPlotModelMapper::setCount(int count)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns the orientation that is used when QBoxPlotModelMapper accesses the model.
                 This means whether the consecutive values of the box-and-whiskers set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBoxPlotModelMapper::orientation() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBoxPlotModelMapper accesses the model.
                 This mean whether the consecutive values of the box-and-whiskers set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBoxPlotModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first box set
             */
             int QBoxPlotModelMapper::firstBoxSetSection() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_firstBoxSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first box set
                 Parameter \a firstBoxSetSection specifies the section of the model.
             */
             void QBoxPlotModelMapper::setFirstBoxSetSection(int firstBoxSetSection)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_firstBoxSetSection = qMax(-1, firstBoxSetSection);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last box set
             */
             int QBoxPlotModelMapper::lastBoxSetSection() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_lastBoxSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last box set
                 Parameter \a lastBoxSetSection specifies the section of the model.
             */
             void QBoxPlotModelMapper::setLastBoxSetSection(int lastBoxSetSection)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_lastBoxSetSection = qMax(-1, lastBoxSetSection);
                 d->initializeBoxFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxPlotModelMapperPrivate::QBoxPlotModelMapperPrivate(QBoxPlotModelMapper *q) :
                 QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBoxSetSection(-1),
                 m_lastBoxSetSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBoxPlotModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBoxPlotModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBoxSet *QBoxPlotModelMapperPrivate::boxSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBoxSetSection && index.column() <= m_lastBoxSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count))
                         return m_series->boxSets().at(index.column() - m_firstBoxSetSection);
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBoxSetSection && index.row() <= m_lastBoxSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->boxSets().at(index.row() - m_firstBoxSetSection);
                 }
                 return 0; // This part of model has not been mapped to any boxset
             }
             QModelIndex QBoxPlotModelMapperPrivate::boxModelIndex(int boxSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (boxSection < m_firstBoxSetSection || boxSection > m_lastBoxSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, boxSection);
                 else
                     return m_model->index(boxSection, posInBar + m_first);
             }
             void QBoxPlotModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             void QBoxPlotModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBoxSet *box = boxSet(index);
                         if (box) {
                             if (m_orientation == Qt::Vertical)
                                 box->setValue(row - m_first, m_model->data(index).toReal());
                             else
                                 box->setValue(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 Q_UNUSED(orientation);
                 Q_UNUSED(first);
                 Q_UNUSED(last);
             }
             void QBoxPlotModelMapperPrivate::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_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::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_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::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_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::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_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QBoxPlotModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently boxplotchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently boxplotchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::boxSetsAdded(QList<QBoxSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->boxSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for (int i = 0; i < sets.count(); i++) {
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 }
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBoxSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBoxSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBoxSetSection, sets.count());
                 for (int i = firstIndex + m_firstBoxSetSection; i < firstIndex + m_firstBoxSetSection + sets.count(); i++) {
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBoxSetSection)->count(); j++)
                         m_model->setData(boxModelIndex(i, j), sets.at(i - firstIndex - m_firstBoxSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::boxSetsRemoved(QList<QBoxSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_boxSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBoxSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_boxSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBoxSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBoxSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::boxValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int boxSetIndex = m_boxSets.indexOf(qobject_cast<QBoxSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(boxModelIndex(boxSetIndex + m_firstBoxSetSection, index), m_boxSets.at(boxSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::initializeBoxFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_boxSets.clear();
                 // create the initial box-and-whiskers sets
                 for (int i = m_firstBoxSetSection; i <= m_lastBoxSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex boxIndex = boxModelIndex(i, posInBar);
                     // check if there is such model index
                     if (boxIndex.isValid()) {
                         QBoxSet *boxSet = new QBoxSet();
                         while (boxIndex.isValid()) {
                             boxSet->append(m_model->data(boxIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             boxIndex = boxModelIndex(i, posInBar);
                         }
                         connect(boxSet, SIGNAL(valueChanged(int)), this, SLOT(boxValueChanged(int)));
                         m_series->append(boxSet);
                         m_boxSets.append(boxSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qboxplotmodelmapper.cpp"
             #include "moc_qboxplotmodelmapper_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/piechart/qpiemodelmapper.cpp +1 0

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #include <QtCharts/QPieModelMapper>
             #include <private/qpiemodelmapper_p.h>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QPieSlice>
             #include <QtCore/QAbstractItemModel>
             QT_CHARTS_BEGIN_NAMESPACE
             QPieModelMapper::QPieModelMapper(QObject *parent)
                 : QObject(parent),
                   d_ptr(new QPieModelMapperPrivate(this))
             {
             }
             QAbstractItemModel *QPieModelMapper::model() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_model;
             }
             void QPieModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QPieModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializePieFromModel();
                 //    connect signals from the model
+                connect(d->m_model, SIGNAL(modelReset()), d, SLOT(initializePieFromModel()));
                 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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QPieSeries *QPieModelMapper::series() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_series;
             }
             void QPieModelMapper::setSeries(QPieSeries *series)
             {
                 Q_D(QPieModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializePieFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(added(QList<QPieSlice*>)), d, SLOT(slicesAdded(QList<QPieSlice*>)));
                 connect(d->m_series, SIGNAL(removed(QList<QPieSlice*>)), d, SLOT(slicesRemoved(QList<QPieSlice*>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Defines which row/column of the model contains the first slice value.
                 Minimal and default value is: 0
             */
             int QPieModelMapper::first() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row/column of the model contains the \a first slice value.
                 Minimal and default value is: 0
             */
             void QPieModelMapper::setFirst(int first)
             {
                 Q_D(QPieModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializePieFromModel();
             }
             /*!
                 Defines the number of rows/columns of the model that are mapped as the data for QPieSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QPieModelMapper::count() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_count;
             }
             /*!
                 Defines the \a count of rows/columns of the model that are mapped as the data for QPieSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QPieModelMapper::setCount(int count)
             {
                 Q_D(QPieModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializePieFromModel();
             }
             /*!
                 Returns the orientation that is used when QPieModelMapper accesses the model.
                 This mean whether the consecutive values/labels of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QPieModelMapper::orientation() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QPieModelMapper accesses the model.
                 This mean whether the consecutive values/labels of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QPieModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QPieModelMapper);
                 d->m_orientation = orientation;
                 d->initializePieFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the values of the pie's slices
             */
             int QPieModelMapper::valuesSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_valuesSection;
             }
             /*!
                 Sets the model section that is kept in sync with the pie slices values.
                 Parameter \a valuesSection specifies the section of the model.
             */
             void QPieModelMapper::setValuesSection(int valuesSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_valuesSection = qMax(-1, valuesSection);
                 d->initializePieFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the labels of the pie's slices
             */
             int QPieModelMapper::labelsSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_labelsSection;
             }
             /*!
                 Sets the model section that is kept in sync with the pie slices labels.
                 Parameter \a labelsSection specifies the section of the model.
             */
             void QPieModelMapper::setLabelsSection(int labelsSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_labelsSection = qMax(-1, labelsSection);
                 d->initializePieFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieModelMapperPrivate::QPieModelMapperPrivate(QPieModelMapper *q) :
                 QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_valuesSection(-1),
                 m_labelsSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QPieModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QPieModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QPieSlice *QPieModelMapperPrivate::pieSlice(QModelIndex index) const
             {
                 if (!index.isValid())
                     return 0; // index is invalid
                 if (m_orientation == Qt::Vertical && (index.column() == m_valuesSection || index.column() == m_labelsSection)) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                             return m_series->slices().at(index.row() - m_first);
                         else
                             return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && (index.row() == m_valuesSection || index.row() == m_labelsSection)) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
                         if (m_model->index(m_valuesSection, index.column()).isValid() && m_model->index(m_labelsSection, index.column()).isValid())
                             return m_series->slices().at(index.column() - m_first);
                         else
                             return 0;
                     }
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QPieModelMapperPrivate::valueModelIndex(int slicePos)
             {
                 if (m_count != -1 && slicePos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(slicePos + m_first, m_valuesSection);
                 else
                     return m_model->index(m_valuesSection, slicePos + m_first);
             }
             QModelIndex QPieModelMapperPrivate::labelModelIndex(int slicePos)
             {
                 if (m_count != -1 && slicePos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(slicePos + m_first, m_labelsSection);
                 else
                     return m_model->index(m_labelsSection, slicePos + m_first);
             }
             bool QPieModelMapperPrivate::isLabelIndex(QModelIndex index) const
             {
                 if (m_orientation == Qt::Vertical && index.column() == m_labelsSection)
                     return true;
                 else if (m_orientation == Qt::Horizontal && index.row() == m_labelsSection)
                     return true;
                 return false;
             }
             bool QPieModelMapperPrivate::isValueIndex(QModelIndex index) const
             {
                 if (m_orientation == Qt::Vertical && index.column() == m_valuesSection)
                     return true;
                 else if (m_orientation == Qt::Horizontal && index.row() == m_valuesSection)
                     return true;
                 return false;
             }
             void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice *> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (slices.count() == 0)
                     return;
                 int firstIndex = m_series->slices().indexOf(slices.at(0));
                 if (firstIndex == -1)
                     return;
                 if (m_count != -1)
                     m_count += slices.count();
                 for (int i = firstIndex; i < firstIndex + slices.count(); i++) {
                     m_slices.insert(i, slices.at(i - firstIndex));
                     connect(slices.at(i - firstIndex), SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                     connect(slices.at(i - firstIndex), SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                 }
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(firstIndex + m_first, slices.count());
                 else
                     m_model->insertColumns(firstIndex + m_first, slices.count());
                 for (int i = firstIndex; i < firstIndex + slices.count(); i++) {
                     m_model->setData(valueModelIndex(i), slices.at(i - firstIndex)->value());
                     m_model->setData(labelModelIndex(i), slices.at(i - firstIndex)->label());
                 }
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice *> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (slices.count() == 0)
                     return;
                 int firstIndex = m_slices.indexOf(slices.at(0));
                 if (firstIndex == -1)
                     return;
                 if (m_count != -1)
                     m_count -= slices.count();
                 for (int i = firstIndex + slices.count() - 1; i >= firstIndex; i--)
                     m_slices.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(firstIndex + m_first, slices.count());
                 else
                     m_model->removeColumns(firstIndex + m_first, slices.count());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::sliceLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 QPieSlice *slice = qobject_cast<QPieSlice *>(QObject::sender());
                 m_model->setData(labelModelIndex(m_series->slices().indexOf(slice)), slice->label());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::sliceValueChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 QPieSlice *slice = qobject_cast<QPieSlice *>(QObject::sender());
                 m_model->setData(valueModelIndex(m_series->slices().indexOf(slice)), slice->value());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             void QPieModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 QPieSlice *slice;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         slice = pieSlice(index);
                         if (slice) {
                             if (isValueIndex(index))
                                 slice->setValue(m_model->data(index, Qt::DisplayRole).toReal());
                             if (isLabelIndex(index))
                                 slice->setLabel(m_model->data(index, Qt::DisplayRole).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::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_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::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_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::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_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::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_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QPieModelMapperPrivate::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++) {
                         QModelIndex valueIndex = valueModelIndex(i - m_first);
                         QModelIndex labelIndex = labelModelIndex(i - m_first);
                         if (valueIndex.isValid() && labelIndex.isValid()) {
                             QPieSlice *slice = new QPieSlice;
                             slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                             slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                             connect(slice, SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                             connect(slice, SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                             m_series->insert(i - m_first, slice);
                             m_slices.insert(i - m_first, slice);
                         }
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->slices().size() > m_count)
                         for (int i = m_series->slices().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->slices().at(i));
                             m_slices.removeAt(i);
                         }
                 }
             }
             void QPieModelMapperPrivate::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->slices().size(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->slices().size() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->slices().at(i - m_first));
                         m_slices.removeAt(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->slices().size();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->slices().size();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->slices().size());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->slices().size();
                         if (toBeAdded > 0)
                             for (int i = m_series->slices().size(); i < currentSize + toBeAdded; i++) {
                                 QModelIndex valueIndex = valueModelIndex(i - m_first);
                                 QModelIndex labelIndex = labelModelIndex(i - m_first);
                                 if (valueIndex.isValid() && labelIndex.isValid()) {
                                     QPieSlice *slice = new QPieSlice;
                                     slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                                     slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                                     m_series->insert(i, slice);
                                     m_slices.insert(i, slice);
                                 }
                             }
                     }
                 }
             }
             void QPieModelMapperPrivate::initializePieFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_slices.clear();
                 // create the initial slices set
                 int slicePos = 0;
                 QModelIndex valueIndex = valueModelIndex(slicePos);
                 QModelIndex labelIndex = labelModelIndex(slicePos);
                 while (valueIndex.isValid() && labelIndex.isValid()) {
                     QPieSlice *slice = new QPieSlice;
                     slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                     slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                     connect(slice, SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                     m_series->append(slice);
                     m_slices.append(slice);
                     slicePos++;
                     valueIndex = valueModelIndex(slicePos);
                     labelIndex = labelModelIndex(slicePos);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qpiemodelmapper_p.cpp"
             #include "moc_qpiemodelmapper.cpp"
             QT_CHARTS_END_NAMESPACE

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