HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1081:85cf7da340c6

PieSeries model support - further refactoring

Marek Rosa -

r1081:85cf7da340c6

parent child

Context file:

r1081:85cf7da340c6

Collapse all files

src/piechart/qpieseries.cpp +43 -14

                  if(model)
                  {
                      d->m_model = 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)));
                      return true;
                  }
                  else
              }
-             void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
+             void QPieSeriesPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
              {
                  Q_UNUSED(parent);
+                 if (m_mapOrientation == Qt::Vertical)
+                     insertData(start, end);
+                 else if (start <= m_mapValues || start <= m_mapLabels) // if the changes affect the map - reinitialize the pie
+                     initializePieFromModel();
+             }
+             void QPieSeriesPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
+             {
+                 Q_UNUSED(parent);
+                 if (m_mapOrientation == Qt::Vertical)
+                     removeData(start, end);
+                 else if (start <= m_mapValues || start <= m_mapLabels) // if the changes affect the map - reinitialize the pie
+                     initializePieFromModel();
+             }
+             void QPieSeriesPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
+             {
+                 Q_UNUSED(parent);
+                 if (m_mapOrientation == Qt::Horizontal)
+                     insertData(start, end);
+                 else if (start <= m_mapValues || start <= m_mapLabels) // if the changes affect the map - reinitialize the pie
+                     initializePieFromModel();
+             }
+             void QPieSeriesPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
+             {
+                 Q_UNUSED(parent);
+                 if (m_mapOrientation == Qt::Horizontal)
+                     removeData(start, end);
+                 else if (start <= m_mapValues || start <= m_mapLabels) // if the changes affect the map - reinitialize the pie
+                     initializePieFromModel();
+             }
+             void QPieSeriesPrivate::insertData(int start, int end)
+             {
                  Q_Q(QPieSeries);
-                 // series uses model as a data sourceupda
                  if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
                      return;
                  } else {
                  }
              }
-             void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
+             void QPieSeriesPrivate::removeData(int start, int end)
              {
-                 Q_UNUSED(parent);
                  Q_Q(QPieSeries);
                  int removedCount = end - start + 1;
                  if (m_mapCount != -1 && start >= m_mapFirst + m_mapCount) {
                  // clear current content
                  q->clear();
-                 // connect the signals
-                 connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex,QModelIndex)));
-                 if (m_mapOrientation == Qt::Vertical) {
-                     connect(m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
-                     connect(m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
-                 } else {
-                     connect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
-                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                 }
                  // create the initial slices set
                  if (m_mapOrientation == Qt::Vertical) {
                      int sliceCount = 0;
                      for (int i = m_mapFirst; i < m_mapFirst + sliceCount; i++)
                          q->append(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
                  }
+                 q->setLabelsVisible(true);
              }
              bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)

src/piechart/qpieseries_p.h +9 -3

                  void sliceClicked();
                  void sliceHovered(bool state);
                  void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
-                 void modelDataAdded(QModelIndex parent, int start, int end);
-                 void modelDataRemoved(QModelIndex parent, int start, int end);
-                 void initializePieFromModel();
+                 void modelRowsAdded(QModelIndex parent, int start, int end);
+                 void modelRowsRemoved(QModelIndex parent, int start, int end);
+                 void modelColumnsAdded(QModelIndex parent, int start, int end);
+                 void modelColumnsRemoved(QModelIndex parent, int start, int end);
                  bool setRealValue(qreal &value, qreal newValue, qreal max, qreal min = 0.0);
+             private:
+                 void initializePieFromModel();
+                 void insertData(int start, int end);
+                 void removeData(int start, int end);
              public:
                  QList<QPieSlice*> m_slices;
                  qreal m_pieRelativeHorPos;

src/xychart/qxyseries.cpp +2 0

                      QObject::disconnect(d->m_model, 0, this, 0);
                      d->m_mapX = -1;
                      d->m_mapY = -1;
+                     d->m_mapFirst = 0;
+                     d->m_mapCount = -1;
                      d->m_mapOrientation = Qt::Vertical;
                  }

src/xychart/xychartitem.cpp +5 -3

                      int addedCount = end - start + 1;
                      if (m_series->mapCount() != -1 && addedCount > m_series->mapCount())
                          addedCount = m_series->mapCount();
-                     int first = qMax(start, m_series->mapFirst());
-                     int last = qMin(first + addedCount - 1, m_series->count() + m_series->mapFirst() - 1);
+                     int first = qMax(start, m_series->mapFirst());  // get the index of the first item that will be added
+                     int last = qMin(first + addedCount - 1, m_series->count() + m_series->mapFirst() - 1);  // get the index of the last item that will be added
                      for (int i = first; i <= last; i++) {
-                         handlePointAdded(i - m_series->mapFirst());
+                         handlePointAdded(i - m_series->mapFirst());
-                     }
+                     // the map is limited therefore the items that are now outside the map
+                     // need to be removed from the drawn points
                      if (m_series->mapCount() != -1 && m_points.size() > m_series->mapCount())
                          for (int i = m_points.size() - 1; i >= m_series->mapCount(); i--)
                              handlePointRemoved(i);

test/auto/qlineseries/tst_qlineseries.cpp +49 -3

                  void setModelMapping();
                  void setModelMappingRange_data();
                  void setModelMappingRange();
+                 void modelUpdated();
+                 void modelUpdatedCustomMapping();
                  private:
                  void append_data();
                  void count_data();
                  QFETCH(int, count);
                  QLineSeries series;
-                 QStandardItemModel *model = new QStandardItemModel(0, 3);
+                 QStandardItemModel *model = new QStandardItemModel(0, 2);
                  series.setModel(model);
                  series.setModelMapping(0, 1);
                  series.setModelMappingRange(first, count);
                  QVERIFY2(series.count() == 0, "No rows in the model, count should be 0");
                  for (int row = 0; row < 3; ++row) {
-                     for (int column = 0; column < 3; column++) {
+                     for (int column = 0; column < 2; column++) {
                          QStandardItem *item = new QStandardItem(row * column);
                          model->setItem(row, column, item);
                      }
                  // let's add few more rows to the model
                  for (int row = 0; row < 10; ++row) {
                      QList<QStandardItem *> newRow;
-                     for (int column = 0; column < 3; column++) {
+                     for (int column = 0; column < 2; column++) {
                          newRow.append(new QStandardItem(row * column));
                      }
                      model->appendRow(newRow);
                  else
                      QVERIFY2(series.count() == model->rowCount() - qMax(first, 0), "Count should be the number of items in a model after first item, but not less then 0");
+                 // unset the model, values should be default
+                 series.setModel(0);
+                 QCOMPARE(series.mapFirst(), 0);
+                 QCOMPARE(series.mapCount(), -1);
+                 QVERIFY2(series.count() == 0, "No rows in the model, count should be 0");
+             }
+             void tst_QLineSeries::modelUpdated()
+             {
+                 QStandardItemModel *model = new QStandardItemModel;
+                 for (int row = 0; row < 10; ++row) {
+                     QList<QStandardItem *> newRow;
+                     for (int column = 0; column < 2; column++) {
+                         newRow.append(new QStandardItem(row * column));
+                     }
+                     model->appendRow(newRow);
+                 }
+                 QLineSeries series;
+                 series.setModel(model);
+                 series.setModelMapping(0, 1);
+                 model->setData(model->index(3, 1), 34);
+                 // check that the update data is correctly taken from the model
+                 QVERIFY(qFuzzyCompare(series.points().at(3).y(), 34));
+             }
+             void tst_QLineSeries::modelUpdatedCustomMapping()
+             {
+                 QStandardItemModel *model = new QStandardItemModel;
+                 for (int row = 0; row < 10; ++row) {
+                     QList<QStandardItem *> newRow;
+                     for (int column = 0; column < 2; column++) {
+                         newRow.append(new QStandardItem(row * column));
+                     }
+                     model->appendRow(newRow);
+                 }
+                 QLineSeries series;
+                 series.setModel(model);
+                 series.setModelMapping(0, 1);
+                 series.setModelMappingRange(3, 4);
+                 model->setData(model->index(3, 1), 34);
+                 QVERIFY(qFuzzyCompare(series.points().at(0).y(), 34));
              }
              QTEST_MAIN(tst_QLineSeries)

test/tablemodelchart/customtablemodel.cpp +58 -72

              CustomTableModel::CustomTableModel(QObject *parent) :
                  QAbstractTableModel(parent)
              {
-                 //    m_points.append(QPointF(10, 50));
-                 //    m_labels.append("Apples");
-                 //    m_points.append(QPointF(60, 70));
-                 //    m_labels.append("Oranges");
-                 //    m_points.append(QPointF(110, 50));
-                 //    m_labels.append("Bananas");
-                 //    m_points.append(QPointF(140, 40));
-                 //    m_labels.append("Lemons");
-                 //    m_points.append(QPointF(200, 150));
-                 //    m_labels.append("Plums");
-                 //    m_points.append(QPointF(225, 75));
-                 //    m_labels.append("Pearls");
                  qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
+                 m_columnCount = 6;
+                 m_rowCount = 8;
                  // m_data
-                 for (int i = 0; i < 8; i++)
+                 for (int i = 0; i < m_rowCount; i++)
                  {
-                     QVector<qreal>* dataVec = new QVector<qreal>(6);
-             //        QVector<QColor>* colorVec = new QVector<QColor>(6);
+                     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);
-             //            colorVec->replace(k, QColor(Qt::white));
                      }
                      m_data.append(dataVec);
                      m_labels.append(QString("Row: %1").arg((i + 1)));
-             //        m_rowsColors.append(colorVec);
                  }
              }
              int CustomTableModel::rowCount(const QModelIndex & parent) const
              {
                  Q_UNUSED(parent)
-                 //    return m_points.count();
                  return m_data.count();
              }
              int CustomTableModel::columnCount(const QModelIndex & parent) const
              {
                  Q_UNUSED(parent)
-                 //    return 3;
-                 return 6;
+                 return m_columnCount;
              }
              QVariant CustomTableModel::headerData (int section, Qt::Orientation orientation, int role ) const
                  {
                      switch(section)
                      {
-                     //        case 0:
-                     //            return "x";
-                     //        case 1:
-                     //            return "y";
-                     //        case 2:
-                     case 6:
-                         return "Fruit";
+                     //        case 6:
+                     //            return "Fruit";
                      default:
                          if (section%2 == 0)
                              return "x";
                          else
                              return "y";
-                         //            return "What?";
                      }
                  }
                  else
                  {
                      switch(index.column())
                      {
-                     //        case 0:
-                     //            return m_points[index.row()].x();
-                     //        case 1:
-                     //            return m_points[index.row()].y();
-                     //        case 2:
-                     case 6:
-                         return m_labels[index.row()];
+                     //        case 6:
+                     //            return m_labels[index.row()];
                      default:
                          return m_data[index.row()]->at(index.column());
                          break;
                  {
                      switch(index.column())
                      {
-                     //        case 0:
-                     //            return m_points[index.row()].x();
-                     //        case 1:
-                     //            return m_points[index.row()].y();
-                     //        case 2:
-                     case 6:
-                         return m_labels[index.row()];
+                     //        case 6:
+                     //            return m_labels[index.row()];
                      default:
                          return m_data[index.row()]->at(index.column());
                          break;
                      }
                  }
                  else if (role == Qt::BackgroundRole)
+                     {
-                         QRect rect;
-                         foreach(rect, m_mapping)
-                             if(rect.contains(index.column(), index.row()))
-                                 return QColor(m_mapping.key(rect));
+                 {
+                     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);
+                     }
+                     // cell not mapped return white color
+                     return QColor(Qt::white);
+                 }
                  return QVariant();
              }
                  {
                      switch(index.column())
                      {
-                     //        case 0:
-                     //            m_points[index.row()].setX(value.toDouble());
-                     //            break;
-                     //        case 1:
-                     //            m_points[index.row()].setY(value.toDouble());
+                     //        case 6:
+                     //            m_labels.replace(index.row(), value.toString());
                      //            break;
-                     //        case 2:
-                     case 6:
-                         m_labels.replace(index.row(), value.toString());
-                         break;
                      default:
                          m_data[index.row()]->replace(index.column(), value.toDouble());
                          break;
-                         //            return false;
                      }
                      emit dataChanged(index, index);
                      return true;
                  }
-             //    else if (role == Qt::BackgroundRole)
-             //        {
-             //            m_rowsColors[index.row()]->replace(index.column(), value.value<QColor>());
-             //            return true;
-             //        }
                  return false;
              }
              Qt::ItemFlags CustomTableModel::flags ( const QModelIndex & index ) const
              {
-                 //    if (!index.isValid())
-                 //                return Qt::ItemIsEnabled;
                  return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
              }
                  for (int i = row; i < row + count; i++)
                  {
                      //        m_points.insert(row, QPointF(10,20));
-                     QVector<qreal>* dataVec = new QVector<qreal>(6);
-                     QVector<QColor>* colorVec = new QVector<QColor>(6);
+                     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)
                      }
                      m_data.insert(i, dataVec);
                      m_labels.insert(i,(QString("Row: %1").arg(i + 1)));
-             //        m_rowsColors.insert(i, colorVec);
                  }
                  endInsertRows();
                  return true;
                  beginRemoveRows(parent, row, row + count - 1);
                  for (int i = row; i < row + count; i++)
                  {
-                     //        m_points.removeAt(row);
                      QVector<qreal>* item = m_data.at(row);
                      m_data.removeAt(row);
                      delete item;
                  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);

test/tablemodelchart/customtablemodel.h +5 -2

                  Qt::ItemFlags flags ( const QModelIndex & index ) const;
                  bool insertRows ( int row, int count, const QModelIndex & parent = QModelIndex() );
                  bool removeRows ( int row, int count, const QModelIndex & parent = QModelIndex() );
+                 bool insertColumns ( int column, int count, const QModelIndex & parent = QModelIndex() );
+                 bool removeColumns ( int column, int count, const QModelIndex & parent = QModelIndex() );
                  void addMapping(QString color, QRect area);
                  void addMapping(QString color, int left, int top, int right, int bottom);
                  //public slots:
              private:
                  QList<QVector<qreal> * > m_data;
-             //    QList<QVector<QColor> * > m_rowsColors;
                  QHash<QString, QRect> m_mapping;
                  QList<QPointF> m_points;
-                 QStringList m_labels;
+                 QStringList m_labels;
+                 int m_columnCount;
+                 int m_rowCount;
              };

test/tablemodelchart/tablewidget.cpp +18 0

                  QPushButton* removeRowButton = new QPushButton("Remove row");
                  connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
+                 QPushButton* addColumnRightButton = new QPushButton("Add column on the right");
+                 connect(addColumnRightButton, SIGNAL(clicked()), this, SLOT(addColumnRight()));
+                 QPushButton* removeColumnButton = new QPushButton("Remove column");
+                 connect(removeColumnButton, SIGNAL(clicked()), this, SLOT(removeColumn()));
                  QPushButton* specialPieButton = new QPushButton("Test pie");
                  connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                  buttonsLayout->addWidget(addRowAboveButton);
                  buttonsLayout->addWidget(addRowBelowButton);
                  buttonsLayout->addWidget(removeRowButton);
+                 buttonsLayout->addWidget(addColumnRightButton);
+                 buttonsLayout->addWidget(removeColumnButton);
                  buttonsLayout->addWidget(specialPieButton);
                  buttonsLayout->addStretch();
                  m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
              }
+             void TableWidget::addColumnRight()
+             {
+                 m_model->insertColumns(m_tableView->currentIndex().column() + 1, m_linesCountSpinBox->value());
+             }
+             void TableWidget::removeColumn()
+             {
+                 m_model->removeColumns(m_tableView->currentIndex().column(), qMin(m_model->columnCount() - m_tableView->currentIndex().column(), m_linesCountSpinBox->value()));
+             }
              void TableWidget::updateChartType(bool toggle)
              {
                  // this if is needed, so that the function is only called once.

test/tablemodelchart/tablewidget.h +2 0

                  void addRowAbove();
                  void addRowBelow();
                  void removeRow();
+                 void addColumnRight();
+                 void removeColumn();
                  void updateChartType(bool toggle);
                  void testPie();

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