HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1347:573b982b92ef

ModelMappers dosc update

Marek Rosa -

r1347:573b982b92ef

parent child

Context file:

r1347:573b982b92ef

Collapse all files

src/barchart/qbarmodelmapper.cpp +3 0

             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "qchart.h"
             #include "qaxis.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             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::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = firstBarSetSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = lastBarSetSection;
                 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_firstBarSetSection = -1;
                 d->m_lastBarSetSection = -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_firstBarSetSection(-1),
                 m_lastBarSetSection(-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_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     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->barSets().at(index.column() - m_firstBarSetSection);
             //            else
             //                return 0;
                     }
                 } 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);
             }
             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();
                 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);
                         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::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);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || 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);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || 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);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || 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);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || 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 k = 0; k < m_series->barSets().count(); k++) {
                         for (int i = first; i <= last; i++) {
                             QBar 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);
                         }
             >>>>>>> Stashed changes
                     }
                     // 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();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; 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_series->chart() && 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->chart()->axisX()->categories()->insert(categories);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qhbarmodelmapper.cpp +3 0

             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetRow);
             }
             int QHBarModelMapper::categoriesRow() const
             {
                 return QBarModelMapper::categoriesSection();
             }
             void QHBarModelMapper::setCategoriesRow(int categoriesRow)
             {
                 return QBarModelMapper::setCategoriesSection(categoriesRow);
             }
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qvbarmodelmapper.cpp +3 0

             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
             }
             int QVBarModelMapper::categoriesColumn() const
             {
                 return QBarModelMapper::categoriesSection();
             }
             void QVBarModelMapper::setCategoriesColumn(int categoriesColumn)
             {
                 return QBarModelMapper::setCategoriesSection(categoriesColumn);
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qhpiemodelmapper.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHPieModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 This class is used to create a connection between QPieSeries and QAbstractItemModel derived model object that keeps the consecutive pie slices data in rows.
                 It is possible to use both QAbstractItemModel and QPieSeries model API. QHPieModelMapper makes sure that Pie and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \property QHPieModelMapper::valuesRow
                 \brief Defines which row of the model is kept in sync with the values of the pie's slices
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QHPieModelMapper::labelsRow
                 \brief Defines which row of the model is kept in sync with the labels of the pie's slices
                 Default value is: -1 (invalid mapping)
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QHPieModelMapper::QHPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 QPieModelMapper::setOrientation(Qt::Horizontal);
             }
             /*!
                 Returns which row of the model is kept in sync with the values of the pie's slices
             */
             int QHPieModelMapper::valuesRow() const
             {
                 return QPieModelMapper::valuesSection();
             }
             /*!
                 Sets the model row that is kept in sync with the pie slices values.
                 Parameter \a valuesRow specifies the row of the model.
             */
             void QHPieModelMapper::setValuesRow(int valuesRow)
             {
                 QPieModelMapper::setValuesSection(valuesRow);
             }
             /*!
                 Returns which row of the model is kept in sync with the labels of the pie's slices
             */
             int QHPieModelMapper::labelsRow() const
             {
                 return QPieModelMapper::labelsSection();
             }
             /*!
                 Sets the model row that is kept in sync with the pie's slices labels.
                 Parameter \a labelsRow specifies the row of the model.
             */
             void QHPieModelMapper::setLabelsRow(int labelsRow)
             {
                 QPieModelMapper::setLabelsSection(labelsRow);
             }
             #include "moc_qhpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpiemodelmapper.cpp +3 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpiemodelmapper_p.h"
             #include "qpiemodelmapper.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \property QPieModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \property QPieModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \property QPieModelMapper::first
                 \brief Defines which item of the model's row/column should be mapped as the value/label of the first slice of the pie
                 Minimal and default value is: 0
             */
             /*!
                 \property QPieModelMapper::count
                 \brief Defines the number of rows/columns of the model that are mapped as the data for the pie.
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             /*!
                 \class QPieModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 The instance of this class cannot be created directly. QHPieModelMapper of QVPieModelMapper should be used instead. This class is used to create a connection between QPieSeries and QAbstractItemModel derived model object.
                 It is possible to use both QAbstractItemModel and QPieSeries model API. QPieModelMapper makes sure that Pie and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             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(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)));
             }
             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*>)));
             }
             int QPieModelMapper::first() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_first;
             }
             void QPieModelMapper::setFirst(int first)
             {
                 Q_D(QPieModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializePieFromModel();
             }
             int QPieModelMapper::count() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_count;
             }
             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();
             }
             /*!
                 Resets the QPieModelMapper to the default state.
                 first: 0; count: -1; valuesSection: -1; labelsSection: -1;
             */
             void QPieModelMapper::reset()
             {
                 Q_D(QPieModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_valuesSection = -1;
                 d->m_labelsSection = -1;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieModelMapperPrivate::QPieModelMapperPrivate(QPieModelMapper *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::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::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());
                             slice->setLabelVisible();
                             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());
                                     slice->setLabelVisible();
                                     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);
                     //        m_series->append(m_model->data(labelIndex, Qt::DisplayRole).toString(), m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                     slicePos++;
                     valueIndex = valueModelIndex(slicePos);
                     labelIndex = labelModelIndex(slicePos);
                 }
                 m_series->setLabelsVisible(true);
                 blockSeriesSignals(false);
             }
             #include "moc_qpiemodelmapper_p.cpp"
             #include "moc_qpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qvpiemodelmapper.cpp +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
-            #include "qpiemodelmapper_p.h"
             #include "qvpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVPieModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 This class is used to create a connection between QPieSeries and QAbstractItemModel derived model object that keeps the consecutive pie slices data in columns.
                 It is possible to use both QAbstractItemModel and QPieSeries model API. QVPieModelMapper makes sure that Pie and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \property QVPieModelMapper::valuesColumn
                 \brief Defines which column of the model is kept in sync with the values of the pie's slices
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QVPieModelMapper::labelsColumn
                 \brief Defines which column of the model is kept in sync with the labels of the pie's slices
                 Default value is: -1 (invalid mapping)
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QVPieModelMapper::QVPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 QPieModelMapper::setOrientation(Qt::Vertical);
             }
             /*!
                 Returns which column of the model is kept in sync with the values of the pie's slices
             */
             int QVPieModelMapper::valuesColumn() const
             {
                 return QPieModelMapper::valuesSection();
             }
             /*!
                 Sets the model column that is kept in sync with the pie slices values.
                 Parameter \a valuesColumn specifies the row of the model.
             */
             void QVPieModelMapper::setValuesColumn(int valuesColumn)
             {
                 QPieModelMapper::setValuesSection(valuesColumn);
             }
             /*!
                 Returns which column of the model is kept in sync with the labels of the pie's slices
             */
             int QVPieModelMapper::labelsColumn() const
             {
                 return QPieModelMapper::labelsSection();
             }
             /*!
                 Sets the model column that is kept in sync with the pie's slices labels.
                 Parameter \a labelsColumn specifies the row of the model.
             */
             void QVPieModelMapper::setLabelsColumn(int labelsColumn)
             {
                 QPieModelMapper::setLabelsSection(labelsColumn);
             }
             #include "moc_qvpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qhxymodelmapper.cpp +3 0

             #include "qhxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHXYModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
             /*!
                 \property QHXYModelMapper::xRow
                 \brief Defines which row of the model is kept in sync with the x values of the QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QHXYModelMapper::yRow
                 \brief Defines which row of the model is kept in sync with the  y values of the QXYSeries
                 Default value is: -1 (invalid mapping)
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QHXYModelMapper::QHXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHXYModelMapper::xRow() const
             {
                 return QXYModelMapper::xSection();
             }
             void QHXYModelMapper::setXRow(int xRow)
             {
                 return QXYModelMapper::setXSection(xRow);
             }
             int QHXYModelMapper::yRow() const
             {
                 return QXYModelMapper::ySection();
             }
             void QHXYModelMapper::setYRow(int yRow)
             {
                 return QXYModelMapper::setYSection(yRow);
             }
             #include "moc_qhxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qvxymodelmapper.cpp +3 0

             #include "qvxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVXYModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
             /*!
                 \property QVXYModelMapper::xColumn
                 \brief Defines which column of the model is kept in sync with the x values of QXYSeries
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QVXYModelMapper::yColumn
                 \brief Defines which column of the model is kept in sync with the y values of QXYSeries
                 Default value is: -1 (invalid mapping)
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QVXYModelMapper::QVXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Vertical);
             }
             int QVXYModelMapper::xColumn() const
             {
                 return QXYModelMapper::xSection();
             }
             void QVXYModelMapper::setXColumn(int xColumn)
             {
                 return QXYModelMapper::setXSection(xColumn);
             }
             int QVXYModelMapper::yColumn() const
             {
                 return QXYModelMapper::ySection();
             }
             void QVXYModelMapper::setYColumn(int yColumn)
             {
                 return QXYModelMapper::setYSection(yColumn);
             }
             #include "moc_qvxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxymodelmapper.cpp +4 -1

             #include "qxymodelmapper.h"
             #include "qxymodelmapper_p.h"
             #include "qxyseries.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \property QXYModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \property QXYModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \property QXYModelMapper::first
                 \brief Defines which item of the model's row/column should be mapped as the first x/y pair
                 Minimal and default value is: 0
             */
             /*!
                 \property QXYModelMapper::count
                 \brief Defines the number of rows/columns of the model that are mapped as the data for QXYSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             /*!
                 \class QXYModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 The instance of this class cannot be created directly. QHXYModelMapper of QVXYModelMapper should be used instead. This class is used to create a connection between QXYSeries and QAbstractItemModel derived model object.
-                It is possible to use both QAbstractItemModel and QPieSeries model API. QPieModelMapper makes sure that QXYSeries and the model are kept in sync.
+                It is possible to use both QAbstractItemModel and QXYSeries model API. QXYModelMapper makes sure that QXYSeries and the model are kept in sync.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
+            /*!
+                Constructs a mapper object which is a child of \a parent.
+            */
             QXYModelMapper::QXYModelMapper(QObject *parent):
                 QObject(parent),
                 d_ptr(new QXYModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             }
             void QXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QXYModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeXYFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QXYSeries* QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;
             }
             void QXYModelMapper::setSeries(QXYSeries *series)
             {
                 Q_D(QXYModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeXYFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(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();
             }
             /*!
                 Returns the orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QXYModelMapper::orientation() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QXYModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QXYModelMapper);
                 d->m_orientation = orientation;
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the x values of the QXYSeries
             */
             int QXYModelMapper::xSection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_xSection;
             }
             /*!
                 Sets the model section that is kept in sync with the x values of the QXYSeries.
                 Parameter \a xSection specifies the section of the model.
             */
             void QXYModelMapper::setXSection(int xSection)
             {
                 Q_D(QXYModelMapper);
                 d->m_xSection = xSection;
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the y values of the QXYSeries
             */
             int QXYModelMapper::ySection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_ySection;
             }
             /*!
                 Sets the model section that is kept in sync with the y values of the QXYSeries.
                 Parameter \a ySection specifies the section of the model.
             */
             void QXYModelMapper::setYSection(int ySection)
             {
                 Q_D(QXYModelMapper);
                 d->m_ySection = ySection;
                 d->initializeXYFromModel();
             }
             /*!
                 Resets the QXYModelMapper to the default state.
                 first: 0; count: -1; xSection: -1; ySection: -1;
             */
             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)) {
                                 QModelIndex xIndex = xModelIndex(index.row() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.row() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.row() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).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)) {
                                 QModelIndex xIndex = xModelIndex(index.column() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.column() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.column() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).toReal());
                                 }
                             }
                         } else {
                             continue;
                         }
                         m_series->replace(oldPoint, newPoint);
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::insertData(int start, int end)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int i = first; i <= last; i++) {
                         QPointF point;
                         QModelIndex xIndex = xModelIndex(i - m_first);
                         QModelIndex yIndex = yModelIndex(i - m_first);
                         if (xIndex.isValid() && yIndex.isValid()) {
                             point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yIndex, 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;
                                 QModelIndex xIndex = xModelIndex(i);
                                 QModelIndex yIndex = yModelIndex(i);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                                     point.setY(m_model->data(yIndex, 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

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