HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2559:c86e17a9d40c

Removing unused connections and slots...

Mika Salmela -

r2559:c86e17a9d40c

parent child

Context file:

r2559:c86e17a9d40c

Collapse all files

src/boxplotchart/qboxplotmodelmapper.cpp 0 -43

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "qboxplotmodelmapper.h"
             #include "qboxplotmodelmapper_p.h"
             #include "qboxplotseries.h"
             #include "qboxset.h"
             #include "qchart.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBoxPlotModelMapper::QBoxPlotModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBoxPlotModelMapperPrivate(this))
             {
             }
             QAbstractItemModel *QBoxPlotModelMapper::model() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_model;
             }
             void QBoxPlotModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBoxPlotModelMapper);
                 if (d->m_model)
                     disconnect(d->m_model, 0, d, 0);
                 d->m_model = model;
                 d->initializeBoxFromModel();
                 // connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QBoxPlotSeries *QBoxPlotModelMapper::series() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_series;
             }
             void QBoxPlotModelMapper::setSeries(QBoxPlotSeries *series)
             {
                 Q_D(QBoxPlotModelMapper);
                 if (d->m_series)
                     disconnect(d->m_series, 0, d, 0);
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBoxFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(boxsetsAdded(QList<QBoxSet *>)), d, SLOT(boxSetsAdded(QList<QBoxSet *>)));
                 connect(d->m_series, SIGNAL(boxsetsRemoved(QList<QBoxSet *>)), d, SLOT(boxSetsRemoved(QList<QBoxSet *>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBoxSets in the series.
                 The default value is 0.
             */
             int QBoxPlotModelMapper::first() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row/column of the model contains the \a first values of the QBoxSets in the series.
                 The default value is 0.
             */
             void QBoxPlotModelMapper::setFirst(int first)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns the number of rows/columns of the model that are mapped as the data for QBoxPlotSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBoxPlotModelMapper::count() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_count;
             }
             /*!
                 Sets the \a count of rows/columns of the model that are mapped as the data for QBoxPlotSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBoxPlotModelMapper::setCount(int count)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns the orientation that is used when QBoxPlotModelMapper accesses the model.
                 This means whether the consecutive values of the box-and-whiskers set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBoxPlotModelMapper::orientation() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBoxPlotModelMapper accesses the model.
                 This mean whether the consecutive values of the box-and-whiskers set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBoxPlotModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first box set
             */
             int QBoxPlotModelMapper::firstBoxSetSection() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_firstBoxSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first box set
                 Parameter \a firstBoxSetSection specifies the section of the model.
             */
             void QBoxPlotModelMapper::setFirstBoxSetSection(int firstBoxSetSection)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_firstBoxSetSection = qMax(-1, firstBoxSetSection);
                 d->initializeBoxFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last box set
             */
             int QBoxPlotModelMapper::lastBoxSetSection() const
             {
                 Q_D(const QBoxPlotModelMapper);
                 return d->m_lastBoxSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last box set
                 Parameter \a lastBoxSetSection specifies the section of the model.
             */
             void QBoxPlotModelMapper::setLastBoxSetSection(int lastBoxSetSection)
             {
                 Q_D(QBoxPlotModelMapper);
                 d->m_lastBoxSetSection = qMax(-1, lastBoxSetSection);
                 d->initializeBoxFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxPlotModelMapperPrivate::QBoxPlotModelMapperPrivate(QBoxPlotModelMapper *q) :
                 QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBoxSetSection(-1),
                 m_lastBoxSetSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBoxPlotModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBoxPlotModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBoxSet *QBoxPlotModelMapperPrivate::boxSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBoxSetSection && index.column() <= m_lastBoxSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count))
                         return m_series->boxSets().at(index.column() - m_firstBoxSetSection);
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBoxSetSection && index.row() <= m_lastBoxSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->boxSets().at(index.row() - m_firstBoxSetSection);
                 }
                 return 0; // This part of model has not been mapped to any boxset
             }
             QModelIndex QBoxPlotModelMapperPrivate::boxModelIndex(int boxSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (boxSection < m_firstBoxSetSection || boxSection > m_lastBoxSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, boxSection);
                 else
                     return m_model->index(boxSection, posInBar + m_first);
             }
             void QBoxPlotModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             void QBoxPlotModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBoxSet *box = boxSet(index);
                         if (box) {
                             if (m_orientation == Qt::Vertical)
                                 box->setValue(row - m_first, m_model->data(index).toReal());
                             else
                                 box->setValue(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 Q_UNUSED(orientation);
                 Q_UNUSED(first);
                 Q_UNUSED(last);
             }
             void QBoxPlotModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_firstBoxSetSection || start <= m_lastBoxSetSection) // if the changes affect the map - reinitialize
                     initializeBoxFromModel();
                 blockSeriesSignals(false);
             }
             void QBoxPlotModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QBoxPlotModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently boxplotchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently boxplotchart needs to be fully recalculated when change is made.
                 // Re-initialize
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::boxSetsAdded(QList<QBoxSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->boxSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for (int i = 0; i < sets.count(); i++) {
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 }
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBoxSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBoxSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBoxSetSection, sets.count());
                 for (int i = firstIndex + m_firstBoxSetSection; i < firstIndex + m_firstBoxSetSection + sets.count(); i++) {
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBoxSetSection)->count(); j++)
                         m_model->setData(boxModelIndex(i, j), sets.at(i - firstIndex - m_firstBoxSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::boxSetsRemoved(QList<QBoxSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_boxSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBoxSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_boxSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBoxSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBoxSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
-            void QBoxPlotModelMapperPrivate::valuesAdded(int index, int count)
-                if (m_seriesSignalsBlock)
-                    return;
-                if (m_count != -1)
-                    m_count += count;
-                int boxSetIndex = m_boxSets.indexOf(qobject_cast<QBoxSet *>(QObject::sender()));
-                blockModelSignals();
-                if (m_orientation == Qt::Vertical)
-                    m_model->insertRows(index + m_first, count);
-                else
-                    m_model->insertColumns(index + m_first, count);
-                for (int j = index; j < index + count; j++)
-                    m_model->setData(boxModelIndex(boxSetIndex + m_firstBoxSetSection, j), m_boxSets.at(boxSetIndex)->at(j));
-                blockModelSignals(false);
-                initializeBoxFromModel();
-            void QBoxPlotModelMapperPrivate::valuesRemoved(int index, int count)
-                if (m_seriesSignalsBlock)
-                    return;
-                if (m_count != -1)
-                    m_count -= count;
-                blockModelSignals();
-                if (m_orientation == Qt::Vertical)
-                    m_model->removeRows(index + m_first, count);
-                else
-                    m_model->removeColumns(index + m_first, count);
-                blockModelSignals(false);
-                initializeBoxFromModel();
             void QBoxPlotModelMapperPrivate::boxValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int boxSetIndex = m_boxSets.indexOf(qobject_cast<QBoxSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(boxModelIndex(boxSetIndex + m_firstBoxSetSection, index), m_boxSets.at(boxSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBoxFromModel();
             }
             void QBoxPlotModelMapperPrivate::initializeBoxFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_boxSets.clear();
                 // create the initial box-and-whiskers sets
                 for (int i = m_firstBoxSetSection; i <= m_lastBoxSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex boxIndex = boxModelIndex(i, posInBar);
                     // check if there is such model index
                     if (boxIndex.isValid()) {
                         QBoxSet *boxSet = new QBoxSet();
                         while (boxIndex.isValid()) {
                             boxSet->append(m_model->data(boxIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             boxIndex = boxModelIndex(i, posInBar);
                         }
-                        connect(boxSet, SIGNAL(valuesAdded(int,int)), this, SLOT(valuesAdded(int,int)));
-                        connect(boxSet, SIGNAL(valuesRemoved(int,int)), this, SLOT(valuesRemoved(int,int)));
                         connect(boxSet, SIGNAL(valueChanged(int)), this, SLOT(boxValueChanged(int)));
                         m_series->append(boxSet);
                         m_boxSets.append(boxSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qboxplotmodelmapper.cpp"
             #include "moc_qboxplotmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/qboxplotmodelmapper_p.h 0 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QBOXPLOTMODELMAPPER_P_H
             #define QBOXPLOTMODELMAPPER_P_H
             #include <QObject>
             #include "qboxplotmodelmapper.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBoxSet;
             class QBoxPlotModelMapperPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QBoxPlotModelMapperPrivate(QBoxPlotModelMapper *q);
             public Q_SLOTS:
                 // for the model
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last);
                 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);
                 void handleModelDestroyed();
                 // for the series
                 void boxSetsAdded(QList<QBoxSet *> sets);
                 void boxSetsRemoved(QList<QBoxSet *> sets);
-                void valuesAdded(int index, int count);
-                void valuesRemoved(int index, int count);
                 void boxValueChanged(int index);
                 void handleSeriesDestroyed();
                 void initializeBoxFromModel();
             private:
                 QBoxSet *boxSet(QModelIndex index);
                 QModelIndex boxModelIndex(int boxSection, int posInBox);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
                 void blockModelSignals(bool block = true);
                 void blockSeriesSignals(bool block = true);
             private:
                 QBoxPlotSeries *m_series;
                 QList<QBoxSet *> m_boxSets;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;
                 Qt::Orientation m_orientation;
                 int m_firstBoxSetSection;
                 int m_lastBoxSetSection;
                 bool m_seriesSignalsBlock;
                 bool m_modelSignalsBlock;
             private:
                 QBoxPlotModelMapper *q_ptr;
                 Q_DECLARE_PUBLIC(QBoxPlotModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBOXPLOTMODELMAPPER_P_H

tests/boxplottester/mainwidget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 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 "mainwidget.h"
             #include "customtablemodel.h"
             #include <QVBoxPlotModelMapper>
             #include <QTableView>
             #include <QHeaderView>
             #include <QChartView>
             #include <QBoxPlotSeries>
             #include <QBoxSet>
             #include <QLegend>
             #include <QBarCategoryAxis>
             #include <QBrush>
             #include <QColor>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             #include <QBarCategoryAxis>
             #include <QLogValueAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             QString addCategories[] = {"Jul", "Aug", "Sep", "Nov", "Dec"};
             static const int maxAddCategories = 5;
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_chart(0),
                 m_axis(0),
                 rowPos(0),
                 nSeries(0),
                 nNewBoxes(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 // Create add a series button
                 QPushButton *addSeriesButton = new QPushButton("Add a series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, rowPos++, 1);
                 // Create remove a series button
                 QPushButton *removeSeriesButton = new QPushButton("Remove a series");
                 connect(removeSeriesButton, SIGNAL(clicked()), this, SLOT(removeSeries()));
                 grid->addWidget(removeSeriesButton, rowPos++, 1);
                 // Create add a single box button
                 QPushButton *addBoxButton = new QPushButton("Add a box");
                 connect(addBoxButton, SIGNAL(clicked()), this, SLOT(addBox()));
                 grid->addWidget(addBoxButton, rowPos++, 1);
                 // Create insert a box button
                 QPushButton *insertBoxButton = new QPushButton("Insert a box");
                 connect(insertBoxButton, SIGNAL(clicked()), this, SLOT(insertBox()));
                 grid->addWidget(insertBoxButton, rowPos++, 1);
                 // Create add a single box button
                 QPushButton *removeBoxButton = new QPushButton("Remove a box");
                 connect(removeBoxButton, SIGNAL(clicked()), this, SLOT(removeBox()));
                 grid->addWidget(removeBoxButton, rowPos++, 1);
                 // Create clear button
                 QPushButton *clearButton = new QPushButton("Clear");
                 connect(clearButton, SIGNAL(clicked()), this, SLOT(clear()));
                 grid->addWidget(clearButton, rowPos++, 1);
                 // Create clear button
                 QPushButton *clearBoxButton = new QPushButton("ClearBox");
                 connect(clearBoxButton, SIGNAL(clicked()), this, SLOT(clearBox()));
                 grid->addWidget(clearBoxButton, rowPos++, 1);
                 // Create set brush button
                 QPushButton *setBrushButton = new QPushButton("Set brush");
                 connect(setBrushButton, SIGNAL(clicked()), this, SLOT(setBrush()));
                 grid->addWidget(setBrushButton, rowPos++, 1);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
-                m_model = new CustomTableModel;
+                m_model = new CustomTableModel();
                 QTableView *tableView = new QTableView;
                 tableView->setModel(m_model);
                 tableView->setMaximumWidth(200);
                 grid->addWidget(tableView, rowPos++, 0, 3, 2, Qt::AlignLeft);
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
             #else
                 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
             #endif
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
                 legendToggled(false);
                 animationToggled(false);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), rowPos, 0);
                 grid->addWidget(chartTheme, rowPos++, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 QCheckBox *animationCheckBox = new QCheckBox("Animation");
                 connect(animationCheckBox, SIGNAL(toggled(bool)), this, SLOT(animationToggled(bool)));
                 animationCheckBox->setChecked(false);
                 grid->addWidget(animationCheckBox, rowPos++, 0);
                 QCheckBox *legendCheckBox = new QCheckBox("Legend");
                 connect(legendCheckBox, SIGNAL(toggled(bool)), this, SLOT(legendToggled(bool)));
                 legendCheckBox->setChecked(false);
                 grid->addWidget(legendCheckBox, rowPos++, 0);
                 QCheckBox *titleCheckBox = new QCheckBox("Title");
                 connect(titleCheckBox, SIGNAL(toggled(bool)), this, SLOT(titleToggled(bool)));
                 titleCheckBox->setChecked(false);
                 grid->addWidget(titleCheckBox, rowPos++, 0);
                 QCheckBox *modelMapperCheckBox = new QCheckBox("Use model mapper");
                 connect(modelMapperCheckBox, SIGNAL(toggled(bool)), this, SLOT(modelMapperToggled(bool)));
                 modelMapperCheckBox->setChecked(false);
                 grid->addWidget(modelMapperCheckBox, rowPos++, 0);
             }
             void MainWidget::addSeries()
             {
                 qDebug() << "BoxPlotTester::MainWidget::addSeries()";
                 if (nSeries > 9)
                     return;
                 // Initial data
                 QBoxSet *set0 = new QBoxSet();
                 QBoxSet *set1 = new QBoxSet();
                 QBoxSet *set2 = new QBoxSet();
                 QBoxSet *set3 = new QBoxSet();
                 QBoxSet *set4 = new QBoxSet();
                 QBoxSet *set5 = new QBoxSet();
                 //      low  bot   med   top  upp
                 *set0 << -1 << 2 << 4 << 13 << 15;
                 *set1 << 5 << 6 << 7.5 << 8 << 12;
                 *set2 << 3 << 5 << 5.7 << 8 << 9;
                 *set3 << 5 << 6 << 6.8 << 7 << 8;
                 *set4 << 4 << 5 << 5.2 << 6 << 7;
                 *set5 << 4 << 7 << 8.2 << 9 << 10;
                 m_series[nSeries] = new QBoxPlotSeries();
                 m_series[nSeries]->append(set0);
                 m_series[nSeries]->append(set1);
                 m_series[nSeries]->append(set2);
                 m_series[nSeries]->append(set3);
                 m_series[nSeries]->append(set4);
                 m_series[nSeries]->append(set5);
                 m_series[nSeries]->setName("Box & Whiskers");
                 connect(m_series[nSeries], SIGNAL(clicked(QBoxSet*)), this, SLOT(boxClicked(QBoxSet*)));
                 connect(m_series[nSeries], SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(boxHovered(bool, QBoxSet*)));
                 connect(set1, SIGNAL(clicked()), this, SLOT(singleBoxClicked()));
                 connect(set2, SIGNAL(hovered(bool)), this, SLOT(singleBoxHovered(bool)));
                 m_chart->addSeries(m_series[nSeries]);
                 if (!m_axis) {
                     QStringList categories;
                     categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                     m_axis = new QBarCategoryAxis();
                     m_axis->append(categories);
                     m_chart->createDefaultAxes();
                 }
                 m_chart->setAxisX(m_axis, m_series[nSeries]);
                 nSeries++;
             }
             void MainWidget::removeSeries()
             {
                 qDebug() << "BoxPlotTester::MainWidget::removeSeries()";
                 if (nSeries > 0) {
                     nSeries--;
                     m_chart->removeSeries(m_series[nSeries]);
                     delete m_series[nSeries];
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::addBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::addBox()";
                 if (nSeries > 0 && nNewBoxes < maxAddCategories) {
                     QBoxSet *newSet = new QBoxSet();
                     newSet->setValue(QBoxSet::LowerExtreme, 5.0);
                     newSet->setValue(QBoxSet::LowerQuartile, 6.0);
                     newSet->setValue(QBoxSet::Median, 6.8);
                     newSet->setValue(QBoxSet::UpperQuartile, 7.0);
                     newSet->setValue(QBoxSet::UpperExtreme, 8.0);
                     m_series[0]->append(newSet);
                     m_axis->append(addCategories[nNewBoxes]);
                     nNewBoxes++;
                 }
             }
             void MainWidget::insertBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::insertBox()";
                 if (nSeries > 0) {
                     QBoxSet *newSet = new QBoxSet();
                     *newSet << 2 << 6 << 6.8 << 7 << 10;
                     for (int i = 0; i < nSeries; i++)
                         m_series[i]->insert(1, newSet);
                     m_axis->append(addCategories[nNewBoxes]);
                     nNewBoxes++;
                 }
             }
             void MainWidget::removeBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::removeBox";
                 if (nSeries > 0) {
                     for (int i = 0; i < nSeries; i++) {
                         qDebug() << "m_series[i]->count() = " << m_series[i]->count();
                         if (m_series[i]->count() > 3) {
                             QList<QBoxSet *> sets = m_series[i]->boxSets();
                             m_series[i]->remove(sets.at(m_series[i]->count() - 3));
                         }
                     }
                     if (m_axis->count() > 3)
                         m_axis->remove(m_axis->at(1));
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::clear()
             {
                 qDebug() << "BoxPlotTester::MainWidget::clear";
                 if (nSeries > 0)
                     m_series[0]->clear();
                 else
                     qDebug() << "Create a series first";
             }
             void MainWidget::clearBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::clearBox";
                 if (nSeries > 0) {
                     QList<QBoxSet *> sets = m_series[0]->boxSets();
                     sets.at(1)->clear();
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::setBrush()
             {
                 qDebug() << "BoxPlotTester::MainWidget::setBrush";
                 if (nSeries > 0) {
                     QList<QBoxSet *> sets = m_series[0]->boxSets();
                     sets.at(1)->setBrush(QBrush(QColor(Qt::yellow)));
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::animationToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Animation toggled to " << enabled;
                 if (enabled)
                     m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 else
                     m_chart->setAnimationOptions(QChart::NoAnimation);
             }
             void MainWidget::legendToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Legend toggled to " << enabled;
                 m_chart->legend()->setVisible(enabled);
                 if (enabled)
                     m_chart->legend()->setAlignment(Qt::AlignBottom);
             }
             void MainWidget::titleToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Title toggled to " << enabled;
                 if (enabled)
                     m_chart->setTitle("Simple boxplotchart example");
                 else
                     m_chart->setTitle("");
             }
             void MainWidget::modelMapperToggled(bool enabled)
             {
                 if (enabled) {
                     m_series[nSeries] = new QBoxPlotSeries();
                     int first = 0;
                     int count = 5;
                     QVBoxPlotModelMapper *mapper = new QVBoxPlotModelMapper(this);
                     mapper->setFirstBoxSetColumn(0);
                     mapper->setLastBoxSetColumn(5);
                     mapper->setFirstRow(first);
                     mapper->setRowCount(count);
                     mapper->setSeries(m_series[nSeries]);
                     mapper->setModel(m_model);
                     m_chart->addSeries(m_series[nSeries]);
                     nSeries++;
                 } else {
                     removeSeries();
                 }
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "BoxPlotTester::changeChartTheme: " << themeIndex;
                 if (themeIndex == 0)
                     m_chart->setTheme(QChart::ChartThemeLight);
                 else
                     m_chart->setTheme((QChart::ChartTheme) (themeIndex - 1));
             }
             void MainWidget::boxClicked(QBoxSet *set)
             {
                 qDebug() << "boxClicked, median = " << set->at(QBoxSet::Median);
             }
             void MainWidget::boxHovered(bool state, QBoxSet *set)
             {
                 if (state)
                     qDebug() << "box median " << set->at(QBoxSet::Median) << " hover started";
                 else
                     qDebug() << "box median " << set->at(QBoxSet::Median) << " hover ended";
             }
             void MainWidget::singleBoxClicked()
             {
                 qDebug() << "singleBoxClicked";
             }
             void MainWidget::singleBoxHovered(bool state)
             {
                 if (state)
                     qDebug() << "single box hover started";
                 else
                     qDebug() << "single box hover ended";
             }

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