HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1330:80cc71f77e52

Minor fix to pie model mapper

Marek Rosa -

r1330:80cc71f77e52

parent child

Context file:

r1330:80cc71f77e52

Collapse all files

src/piechart/qhpiemodelmapper.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QHPIEMODELMAPPER_H
             #define QHPIEMODELMAPPER_H
             #include "qpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QHPieModelMapper : public QPieModelMapper
             {
                 Q_OBJECT
                 Q_PROPERTY(int valuesRow READ valuesRow WRITE setValuesRow)
                 Q_PROPERTY(int labelsRow READ labelsRow WRITE setLabelsRow)
             public:
-                QHPieModelMapper(QObject *parent = 0);
+                explicit QHPieModelMapper(QObject *parent = 0);
                 int valuesRow() const;
                 void setValuesRow(int valuesRow);
                 int labelsRow() const;
                 void setLabelsRow(int labelsRow);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHPIEMODELMAPPER_H

src/piechart/qpiemodelmapper.cpp 0 -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 "qpiemodelmapper.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieModelMapper::QPieModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QPieModelMapperPrivate(this))
             {
             }
             QPieModelMapper::~QPieModelMapper()
             {
                 //    Q_D(QPieModelMapper);
                 //    disconnect(d->m_model, 0, d, 0);
             }
             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();
             }
             Qt::Orientation QPieModelMapper::orientation() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_orientation;
             }
             void QPieModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QPieModelMapper);
                 d->m_orientation = orientation;
                 d->initializePieFromModel();
             }
             int QPieModelMapper::valuesSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_valuesSection;
             }
             void QPieModelMapper::setValuesSection(int valuesSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_valuesSection = qMax(-1, valuesSection);
                 d->initializePieFromModel();
             }
             int QPieModelMapper::labelsSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_labelsSection;
             }
             void QPieModelMapper::setLabelsSection(int labelsSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_labelsSection = qMax(-1, labelsSection);
                 d->initializePieFromModel();
             }
             void QPieModelMapper::reset()
             {
                 Q_D(QPieModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
-                d->m_orientation = Qt::Vertical;
                 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

tests/tablemodelchart/customtablemodel.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "customtablemodel.h"
             #include <QVector>
             #include <QTime>
             #include <QRect>
             #include <QColor>
             CustomTableModel::CustomTableModel(QObject *parent) :
                 QAbstractTableModel(parent)
             {
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 m_columnCount = 7;
-                m_rowCount = 1029;
+                m_rowCount = 29;
                 m_labels.append("Apples");
                 m_labels.append("Oranges");
                 m_labels.append("Pears");
                 m_labels.append("Peaches");
                 m_labels.append("Coconuts");
                 m_labels.append("Bananas");
                 m_labels.append("Kiwis");
                 m_labels.append("Grapes");
                 m_labels.append("Plums");
                 // m_data
                 for (int i = 0; i < m_rowCount; i++)
                 {
                     QVector<qreal>* dataVec = new QVector<qreal>(m_columnCount);
                     for (int k = 0; k < dataVec->size(); k++)
                     {
                         if (k%2 == 0)
                             dataVec->replace(k, i * 50 + qrand()%20);
                         else
                             dataVec->replace(k, qrand()%100);
                     }
                     m_data.append(dataVec);
                     //        m_labels.append(QString("Row: %1").arg((i + 1)));
                 }
             }
             int CustomTableModel::rowCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
                 return m_data.count();
             }
             int CustomTableModel::columnCount(const QModelIndex & parent) const
             {
                 Q_UNUSED(parent)
                 return m_columnCount;// + 1;
             }
             QVariant CustomTableModel::headerData (int section, Qt::Orientation orientation, int role ) const
             {
                 if (role != Qt::DisplayRole)
                     return QVariant();
                 if (orientation == Qt::Horizontal)
                 {
                     switch(section)
                     {
                     case 7:
                         return "Fruit";
                     case 1:
                         return "Count";
                     case 2:
                         return "Ordered";
                     default:
                         if (section%2 == 0)
                             return "x";
                         else
                             return "y";
                     }
                 }
                 else
                     return QString("%1").arg(section /*+ 1*/);
             }
             QVariant CustomTableModel::data(const QModelIndex & index, int role) const
             {
                 if (role == Qt::DisplayRole)
                 {
                     switch(index.column())
                     {
             //        case 7:
             //            return m_labels[index.row()];
                     default:
                         return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 else if (role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
             //        case 7:
             //            return m_labels[index.row()];
                     default:
                         return m_data[index.row()]->at(index.column());
                         break;
                     }
                 }
                 else if (role == Qt::BackgroundRole)
                 {
                     QRect rect;
                     foreach(rect, m_mapping)
                         if(rect.contains(index.column(), index.row()))
                             return QColor(m_mapping.key(rect));
                     // cell not mapped return white color
                     return QColor(Qt::white);
                 }
                 return QVariant();
             }
             bool CustomTableModel::setData ( const QModelIndex & index, const QVariant & value, int role)
             {
                 if (index.isValid() && role == Qt::EditRole)
                 {
                     switch(index.column())
                     {
                     case 7:
                         m_labels.replace(index.row(), value.toString());
                         break;
                     default:
                         m_data[index.row()]->replace(index.column(), value.toDouble());
                         break;
                     }
                     emit dataChanged(index, index);
                     return true;
                 }
                 return false;
             }
             Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
             {
                 return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
             }
             bool CustomTableModel::insertRows ( int row, int count, const QModelIndex & parent)
             {
                 Q_UNUSED(parent)
                 if (row < 0)
                     row = 0;
                 beginInsertRows(QModelIndex(), row /*dataTable.count()*/, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
                     //        m_points.insert(row, QPointF(10,20));
                     QVector<qreal>* dataVec = new QVector<qreal>(m_columnCount);
                     QVector<QColor>* colorVec = new QVector<QColor>(m_columnCount);
                     for (int k = 0; k < dataVec->size(); k++)
                     {
                         if (k%2 == 0)
                             //                dataVec->replace(k, i * 50 + qrand()%20);
                         {
                             int difference = 0;
                             if (i < m_data.size())
                             {
                                 if (i - 1 >= 0)
                                 {
                                     if (row > 0)
                                         difference = (int)((qAbs(m_data[i]->at(k) - m_data[row - 1]->at(k)))/count);
                                     else
                                         difference = (int)((qAbs(m_data[i]->at(k)/count)));
                                     dataVec->replace(k, m_data[i - 1]->at(k) + qrand()%qMax(1, difference));
                                 }
                                 else
                                     dataVec->replace(k, qrand()%40 + 10);
                             }
                             else
                             {
                                 if (i - 1 >= 0)
                                 {
                                     dataVec->replace(k, m_data[i - 1]->at(k) + qrand()%40 + 10);
                                 }
                                 else
                                 {
                                     dataVec->replace(k, qrand()%40 + 10);
                                 }
                             }
                         }
                         else
                             dataVec->replace(k, qrand()%100);
                         colorVec->replace(k, QColor(Qt::white));
                     }
                     m_data.insert(i, dataVec);
                     m_labels.insert(i,(QString("Row: %1").arg(i + 1)));
                 }
                 endInsertRows();
                 return true;
             }
             bool CustomTableModel::removeRows ( int row, int count, const QModelIndex & parent)
             {
                 if (row > this->rowCount() - 1)
                     return false;
                 if (row < 0)
                     row = 0;
                 if (row + count > rowCount())
                     return false;
                 beginRemoveRows(parent, row, row + count - 1);
                 for (int i = row; i < row + count; i++)
                 {
                     QVector<qreal>* item = m_data.at(row);
                     m_data.removeAt(row);
                     delete item;
                     m_labels.removeAt(row);
                 }
                 endRemoveRows();
                 return true;
             }
             bool CustomTableModel::insertColumns ( int column, int count, const QModelIndex & parent)
             {
                 if (column < 0)
                     column = 0;
                 beginInsertColumns(parent, column, column + count - 1);
                 m_columnCount += count;
                 for (int i = column; i < column + count; i++)
                     for (int k = 0; k < rowCount(); k++)
                         if (k - 1 >= 0) {
                             m_data[k]->insert(i, m_data[k - 1]->at(i) + qrand()%40 + 10);
                         } else {
                             m_data[k]->insert(i, qrand()%40);
                         }
                 endInsertColumns();
                 return true;
             }
             bool CustomTableModel::removeColumns ( int column, int count, const QModelIndex & parent)
             {
                 if (column > columnCount() - 1)
                     return false;
                 if (column < 0)
                     column = 0;
                 if (column + count > columnCount())
                     return false;
                 beginRemoveColumns(parent, column, column + count -1);
                 m_columnCount -= count;
                 for (int i = column; i < column + count; i++)
                     for (int k = 0; k < rowCount(); k++)
                         m_data[k]->remove(column);
                 endRemoveColumns();
                 return true;
             }
             void CustomTableModel::addMapping(QString color, QRect area)
             {
                 m_mapping.insertMulti(color, area);
             }
             void CustomTableModel::addMapping(QString color, int left, int top, int right, int bottom)
             {
                 addMapping(color, QRect(QPoint(left, top), QPoint(right, bottom)));
             }

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