HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1354:ab531266047d

Removed categories support from BarModelMapper

Marek Rosa -

r1354:ab531266047d

parent child

Context file:

r1354:ab531266047d

Collapse all files

src/barchart/qbarmodelmapper.cpp +4 -52

             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "qchart.h"
             #include "qaxis.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \property QBarModelMapper::series
                 \brief Defines the QPieSeries object that is used by the mapper.
                 All the data in the series in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \property QBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \property QBarModelMapper::first
                 \brief Defines which item of the model's row/column should be mapped as the value of the first QBarSet in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \property QBarModelMapper::count
                 \brief Defines the number of rows/columns of the model that are mapped as the data for QBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             /*!
                 \class QBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 The instance of this class cannot be created directly. QHBarModelMapper of QVBarModelMapper should be used instead. This class is used to create a connection between QBarSeries and QAbstractItemModel derived model object.
                 Curently it is NOT possible to use both QAbstractItemModel and QXYSeries model API.
                 When the series is set to the mapper the QBarSeries and QBarSet API that affect the data (append, setValue, remove) should not be used.
                 The model and the QBarSeries won't be kept in sync. Model API should be used to insert,remove,modify BarSets.
                 NOTE: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 //    connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 //    connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 //    connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = firstBarSetSection;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = lastBarSetSection;
                 d->initializeBarFromModel();
             }
             /*!
-                Returns which section of the model is used as the data source for the x axis categories.
-            */
-            int QBarModelMapper::categoriesSection() const
-                Q_D(const QBarModelMapper);
-                return d->m_categoriesSection;
-            /*!
-                Sets the model section that is used as the data source for the x axis categories.
-                Parameter \a categoriesSection specifies the section of the model.
-            */
-            void QBarModelMapper::setCategoriesSection(int categoriesSection)
-                Q_D(QBarModelMapper);
-                d->m_categoriesSection = categoriesSection;
-                d->initializeBarFromModel();
-            /*!
                 Resets the QBarModelMapper to the default state.
                 first: 0; count: -1; firstBarSetSection: -1; lastBarSetSection: -1; categoriesSection: -1
             */
             void QBarModelMapper::reset()
             {
                 Q_D(QBarModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_firstBarSetSection = -1;
                 d->m_lastBarSetSection = -1;
-                d->m_categoriesSection = -1;
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-1),
-                m_categoriesSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSetSection && index.column() <= m_lastBarSetSection) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
             //            if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                             return m_series->barSets().at(index.column() - m_firstBarSetSection);
             //            else
             //                return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSetSection || barSection > m_lastBarSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
-            QModelIndex QBarModelMapperPrivate::categoriesModelIndex(int posInCategories)
-                if (m_count != -1 && posInCategories >= m_count)
-                    return QModelIndex(); // invalid
-                if (m_orientation == Qt::Vertical)
-                    return m_model->index(posInCategories + m_first, m_categoriesSection);
-                else
-                    return m_model->index(m_categoriesSection, posInCategories + m_first);
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
-                //    QPointF oldPoint;
-                //    QPointF newPoint;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet* bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        insertData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int k = 0; k < m_series->barSets().count(); k++) {
                         for (int i = first; i <= last; i++) {
                             QBar point;
                             point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             m_series->insert(i - m_first, point);
                         }
             >>>>>>> Stashed changes
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->points().size() > m_count)
                         for (int i = m_series->points().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->points().at(i));
                         }
                 }*/
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 //    int removedCount = end - start + 1;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int toRemove = qMin(m_series->count(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->count() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->points().at(i - m_first));
                     }
                     if (m_count != -1) {
                         int itemsAvailable;     // check how many are available to be added
                         if (m_orientation == Qt::Vertical)
                             itemsAvailable = m_model->rowCount() - m_first - m_series->count();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->count();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->count());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->count();
                         if (toBeAdded > 0)
                             for (int i = m_series->count(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 point.setX(m_model->data(xModelIndex(i), Qt::DisplayRole).toDouble());
                                 point.setY(m_model->data(yModelIndex(i), Qt::DisplayRole).toDouble());
                                 m_series->insert(i, point);
                             }
                     }
                 }*/
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     QBarSet *barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal).toString());
-                    //    QModelIndex yIndex = yModelIndex(pointPos);
                     while (barIndex.isValid()) {
                         barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                         posInBar++;
                         barIndex = barModelIndex(i, posInBar);
                     }
                     m_series->append(barSet);
                 }
-                if (m_series->chart() && m_categoriesSection != -1) {
-                    int posInCategories = 0;
-                    QStringList categories;
-                    QModelIndex categoriesIndex = categoriesModelIndex(posInCategories);
-                    while (categoriesIndex.isValid()) {
-                        categories.append(m_model->data(categoriesIndex, Qt::DisplayRole).toString());
-                        posInCategories++;
-                        categoriesIndex = categoriesModelIndex(posInCategories);
-                    m_series->chart()->axisX()->categories()->insert(categories);
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarmodelmapper.h 0 -3

             #ifndef QBARMODELMAPPER_H
             #define QBARMODELMAPPER_H
             #include "qchartglobal.h"
             #include <QObject>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapperPrivate;
             class QBarSeries;
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QBarModelMapper : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QBarSeries *series READ series WRITE setSeries)
                 Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel)
                 Q_PROPERTY(int first READ first WRITE setFirst)
                 Q_PROPERTY(int count READ count WRITE setCount)
                 Q_ENUMS(Qt::Orientation)
             protected:
                 explicit QBarModelMapper(QObject *parent = 0);
             public:
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
                 QBarSeries* series() const;
                 void setSeries(QBarSeries *series);
                 int first() const;
                 void setFirst(int first);
                 int count() const;
                 void setCount(int count);
                 void reset();
             protected:
                 int firstBarSetSection() const;
                 void setFirstBarSetSection(int firstBarSetSection);
                 int lastBarSetSection() const;
                 void setLastBarSetSection(int lastBarSetSection);
-                int categoriesSection() const;
-                void setCategoriesSection(int categoriesSection);
                 Qt::Orientation orientation() const;
                 void setOrientation(Qt::Orientation orientation);
             protected:
                 QBarModelMapperPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_H

src/barchart/qbarmodelmapper_p.h 0 -2

             #ifndef QBARMODELMAPPER_P_H
             #define QBARMODELMAPPER_P_H
             #include "qchartglobal.h"
             #include <QObject>
             #include "qbarmodelmapper.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class QBarModelMapperPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QBarModelMapperPrivate(QBarModelMapper *q);
             public Q_SLOTS:
                 // for the model
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 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);
             //    // for the series
             //    void handlePointAdded(int pointPos);
             //    void handlePointRemoved(int pointPos);
             //    void handlePointReplaced(int pointPos);
                 void initializeBarFromModel();
             private:
                 QBarSet* barSet(QModelIndex index);
                 QModelIndex barModelIndex(int barSection, int posInBar);
-                QModelIndex categoriesModelIndex(int posInCategories);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
                 void blockModelSignals(bool block = true);
                 void blockSeriesSignals(bool block = true);
             private:
                 QBarSeries *m_series;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;
                 Qt::Orientation m_orientation;
                 int m_firstBarSetSection;
                 int m_lastBarSetSection;
-                int m_categoriesSection;
                 bool m_seriesSignalsBlock;
                 bool m_modelSignalsBlock;
             private:
                 QBarModelMapper *q_ptr;
                 Q_DECLARE_PUBLIC(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_P_H

src/barchart/qhbarmodelmapper.cpp 0 -17

             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QHBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
             /*!
                 \property QHBarModelMapper::firstBarSetRow
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QHBarModelMapper::lastBarSetRow
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
-                \property QHBarModelMapper::categoriesRow
-                \brief Defines which row of the model is used as the data source for the x axis categories
-                Default value is: -1 (invalid mapping)
-            */
-            /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetRow);
             }
-            int QHBarModelMapper::categoriesRow() const
-                return QBarModelMapper::categoriesSection();
-            void QHBarModelMapper::setCategoriesRow(int categoriesRow)
-                return QBarModelMapper::setCategoriesSection(categoriesRow);
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qhbarmodelmapper.h 0 -5

             #ifndef QHBARMODELMAPPER_H
             #define QHBARMODELMAPPER_H
             #include <QBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QHBarModelMapper : public QBarModelMapper
             {
                 Q_OBJECT
                 Q_PROPERTY(int firstBarSetRow READ firstBarSetRow WRITE setFirstBarSetRow)
                 Q_PROPERTY(int lastBarSetRow READ lastBarSetRow WRITE setLastBarSetRow)
-                Q_PROPERTY(int categoriesRow READ categoriesRow WRITE setCategoriesRow)
             public:
                 explicit QHBarModelMapper(QObject *parent = 0);
                 int firstBarSetRow() const;
                 void setFirstBarSetRow(int firstBarSetRow);
                 int lastBarSetRow() const;
                 void setLastBarSetRow(int lastBarSetRow);
-                int categoriesRow() const;
-                void setCategoriesRow(int categoriesRow);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QHBARMODELMAPPER_H

src/barchart/qvbarmodelmapper.cpp 0 -17

             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \brief part of QtCommercial chart API.
                 \mainclass
                 Nothing here yet
             */
             /*!
                 \property QVBarModelMapper::firstBarSetColumn
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \property QVBarModelMapper::lastBarSetColumn
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
-                \property QVBarModelMapper::categoriesColumn
-                \brief Defines which column of the model is used as the data source for the x axis categories
-                Default value is: -1 (invalid mapping)
-            */
-            /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
             }
-            int QVBarModelMapper::categoriesColumn() const
-                return QBarModelMapper::categoriesSection();
-            void QVBarModelMapper::setCategoriesColumn(int categoriesColumn)
-                return QBarModelMapper::setCategoriesSection(categoriesColumn);
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qvbarmodelmapper.h 0 -5

             #ifndef QVBARMODELMAPPER_H
             #define QVBARMODELMAPPER_H
             #include <QBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QVBarModelMapper : public QBarModelMapper
             {
                 Q_OBJECT
                 Q_PROPERTY(int firstBarSetColumn READ firstBarSetColumn WRITE setFirstBarSetColumn)
                 Q_PROPERTY(int lastBarSetColumn READ lastBarSetColumn WRITE setLastBarSetColumn)
-                Q_PROPERTY(int categoriesColumn READ categoriesColumn WRITE setCategoriesColumn)
             public:
                 explicit QVBarModelMapper(QObject *parent = 0);
                 int firstBarSetColumn() const;
                 void setFirstBarSetColumn(int firstBarSetColumn);
                 int lastBarSetColumn() const;
                 void setLastBarSetColumn(int lastBarSetColumn);
-                int categoriesColumn() const;
-                void setCategoriesColumn(int categoriesColumn);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVBARMODELMAPPER_H

tests/tablemodelchart/tablewidget.cpp +5 -6

             /****************************************************************************
             **
             ** 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 "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QVXYModelMapper>
             #include <QHXYModelMapper>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QVPieModelMapper>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             #include <QHeaderView>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent),
                   m_series(0),
                   m_mapper(0),
                   m_model(0),
                   m_pieMapper(0),
                   m_pieMapper2(0)
                 //      specialPie(0)
             {
                 setGeometry(1900, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 //    m_tableView->setMinimumHeight(300);
                 m_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 QPushButton* addColumnRightButton = new QPushButton("Add column to 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("Add slices using series API");
                 connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 QPushButton* specialPieButton2 = new QPushButton("Remove slices using series API");
                 connect(specialPieButton2, SIGNAL(clicked()), this, SLOT(testPie2()));
                 QPushButton* specialPieButton3 = new QPushButton("Modify slices using series API");
                 connect(specialPieButton3, SIGNAL(clicked()), this, SLOT(testPie3()));
                 QPushButton* xyTestButton = new QPushButton("Append XY point");
                 connect(xyTestButton, SIGNAL(clicked()), this, SLOT(testXY()));
                 QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(spinBoxLabel);
                 buttonsLayout->addWidget(m_linesCountSpinBox);
                 //    buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 //    buttonsLayout->addWidget(addColumnRightButton);
                 //    buttonsLayout->addWidget(removeColumnButton);
                 buttonsLayout->addWidget(specialPieButton);
                 buttonsLayout->addWidget(specialPieButton2);
                 buttonsLayout->addWidget(specialPieButton3);
                 buttonsLayout->addWidget(xyTestButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 m_barRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                 radioLayout->addWidget(m_splineRadioButton);
                 radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 //    radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 2, 0);
                 mainLayout->addLayout(radioLayout, 3, 0);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 1, 1, 2, 1);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 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.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     //        specialPie = 0;
                     m_chart->removeAllSeries();
                     m_series = 0;
                     //        m_chart->axisX()->setNiceNumbersEnabled(false);
                     //        m_chart->axisY()->setNiceNumbersEnabled(false);
                     if (m_mapper) {
                         m_mapper->deleteLater();
                         m_mapper = 0;
                     }
                     if (m_pieMapper) {
                         m_pieMapper->deleteLater();
                         m_pieMapper = 0;
                     }
                     if (m_pieMapper2) {
                         m_pieMapper2->deleteLater();
                         m_pieMapper2 = 0;
                     }
                     //        if (m_series) {
                     //            delete m_series;
                     //            m_series = 0;
                     //        }
                     // renable axes of the chart (pie hides them)
                     // x axis
                     QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     //        QPen pen;
                     //        pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
             //            m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QLineSeries;
             //            m_mapper = new QHXYModelMapper;
             //            m_mapper->setModel(m_model);
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setXRow(0);
             //            m_mapper->setYRow(1);
             //            m_mapper->setFirst(3);
             //            m_mapper->setCount(4);
                         m_mapper = new QVXYModelMapper;
                         m_mapper->setModel(m_model);
                         m_mapper->setSeries(m_series);
                         m_mapper->setXColumn(0);
                         m_mapper->setYColumn(1);
                         m_mapper->setFirst(3);
             //            m_mapper->setCount(4);
                         //            m_series->setModelMapping(0,1, Qt::Vertical);
                         //            m_series->setModelMappingRange(3, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 3, 2, 4));
                         //            // series 2
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(3);
                         //            mapper->setMapY(4);
                         //            //            mapper->setFirst(3);
                         //            //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(3, 0, 2, 1000));
                         //            // series 3
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(5);
                         //            mapper->setMapY(6);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(2, -1);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(5, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
             //            m_mapper = new QVXYModelMapper;
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setModel(m_model);
             //            m_mapper->setXColumn(0);
             //            m_mapper->setYColumn(1);
             //            m_mapper->setFirst(0);
             //            m_mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 2, 1000));
                         //            // series 2
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(2);
                         //            mapper->setMapY(3);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 2, 2, 4));
                         //            // series 3
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(4);
                         //            mapper->setMapY(5);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }        else if (m_scatterRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QScatterSeries;
             //            m_mapper = new QVXYModelMapper;
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setModel(m_model);
             //            m_mapper->setXColumn(0);
             //            m_mapper->setYColumn(1);
             //            m_mapper->setFirst(0);
             //            m_mapper->setCount(-1);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                         //            // series 2
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(1, 6);
                         //            //        series->setModelMapping(2,3, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                         //            // series 3
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //        series->setModelMapping(4,5, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     } else if (m_pieRadioButton->isChecked()) {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         // pie 1
                         m_pieSeries = new QPieSeries;
                         m_pieMapper = new QVPieModelMapper;
                         m_pieMapper->setValuesColumn(1);
                         m_pieMapper->setLabelsColumn(7);
                         m_pieMapper->setSeries(m_pieSeries);
                         m_pieMapper->setModel(m_model);
                         m_pieMapper->setFirst(2);
                         //                        m_pieMapper->setCount(5);
                         //                    pieSeries->setModelMapper(mapper);
                         m_pieSeries->setLabelsVisible(true);
                         m_pieSeries->setPieSize(0.35);
                         m_pieSeries->setHorizontalPosition(0.25);
                         m_pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(m_pieSeries);
                         seriesColorHex = "#" + QString::number(m_pieSeries->slices().at(m_pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 2, 1, 50));
                         //                            pieSeries->slices().at(0)->setValue(400);
                         //                            pieSeries->slices().at(0)->setLabel(QString("36"));
                         // pie 2
                         m_pieSeries2 = new QPieSeries;
                         m_pieMapper2 = new QVPieModelMapper;
                         m_pieMapper2->setValuesColumn(0);
                         m_pieMapper2->setLabelsColumn(7);
                         m_pieMapper2->setModel(m_model);
                         m_pieMapper2->setSeries(m_pieSeries2);
                         m_pieMapper2->setFirst(2);
                         m_pieSeries2->setLabelsVisible(true);
                         m_pieSeries2->setPieSize(0.35);
                         m_pieSeries2->setHorizontalPosition(0.75);
                         m_pieSeries2->setVerticalPosition(0.65);
                         m_chart->addSeries(m_pieSeries2);
                         seriesColorHex = "#" + QString::number(m_pieSeries2->slices().at(m_pieSeries2->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 1, 1000));
                         //            // pie 3
                         //            pieSeries = new QPieSeries;
                         //            pieSeries->setModel(m_model);
                         //            pieSeries->setModelMapping(2,2, Qt::Vertical);
                         //            pieSeries->setLabelsVisible(true);
                         //            pieSeries->setPieSize(0.35);
                         //            pieSeries->setHorizontalPosition(0.5);
                         //            pieSeries->setVerticalPosition(0.75);
                         //            m_chart->addSeries(pieSeries);
                         //            seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                         //            // special pie
                         //            specialPie = new QPieSeries;
                         //            specialPie->append(17, "1");
                         //            specialPie->append(45, "2");
                         //            specialPie->append(77, "3");
                         //            specialPie->append(37, "4");
                         //            specialPie->append(27, "5");
                         //            specialPie->append(47, "6");
                         //            specialPie->setPieSize(0.35);
                         //            specialPie->setHorizontalPosition(0.8);
                         //            specialPie->setVerticalPosition(0.75);
                         //            specialPie->setLabelsVisible(true);
                         //            m_chart->addSeries(specialPie);
                     }
                     //        else if (m_areaRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            QLineSeries* upperLineSeries = new QLineSeries;
                     //            upperLineSeries->setModel(m_model);
                     //            upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
                     //            //            upperLineSeries->setModelMappingRange(1, 5);
                     //            QLineSeries* lowerLineSeries = new QLineSeries;
                     //            lowerLineSeries->setModel(m_model);
                     //            lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                     //            QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                     //            m_chart->addSeries(areaSeries);
                     //            seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                     //            m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     //        }
                     else if (m_barRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         QGroupedBarSeries* barSeries = new QGroupedBarSeries();
-            //            barSeries->setCategories(QStringList());
-            //            barSeries->setModel(m_model);
-                        //            barSeries->setModelMappingRange(2, 5);
-                        //                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         int first = 3;
                         int count = 6;
                         QVBarModelMapper *mapper = new QVBarModelMapper;
-                        mapper->setCategoriesColumn(5);
                         mapper->setFirstBarSetColumn(2);
                         mapper->setLastBarSetColumn(4);
                         mapper->setFirst(first);
                         mapper->setCount(count);
                         mapper->setSeries(barSeries);
                         mapper->setModel(m_model);
             //            barSeries->setModelMapper(mapper);
                         m_chart->addSeries(barSeries);
+                        QStringList categories;
+                        categories << "June" << "July" << "August" << "September" << "October" << "November";
+                        m_chart->axisX()->categories()->insert(categories);
                         QList<QBarSet*> barsets = barSeries->barSets();
                         for (int i = 0; i < barsets.count(); i++) {
                             seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                             m_model->addMapping(seriesColorHex, QRect(2 + i, first, 1, barsets.at(i)->count()));
                         }
                     }
                     if (!m_barRadioButton->isChecked()) {
             //            m_chart->axisX()->setRange(0, 500);
             //            m_chart->axisY()->setRange(0, 220);
                     }
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             void TableWidget::testPie()
             {
                 //    m_pieMapper->setCount(-1);
                 QPieSlice *slice = new QPieSlice("Hehe", 145);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 slice = new QPieSlice("Hoho", 34);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 //    m_series->modelMapper()->setMapX(4);
                 //    m_tableView->setColumnWidth(10, 250);
                 //    if (specialPie) {
                 //        specialPie->remove(specialPie->slices().at(2));
                 //        //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
                 //        specialPie->append(4, "heloo");
                 //    }
             }
             void TableWidget::testPie2()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     m_pieSeries->remove(slice);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     m_pieSeries->remove(slice);
                 }
             }
             void TableWidget::testPie3()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     slice->setLabel("Dalej");
                     slice->setValue(222);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     slice->setLabel("Prawie");
                     slice->setValue(111);
                 }
             }
             void TableWidget::testXY()
             {
                 //    if (m_series->type() != QAbstractSeries::SeriesTypeLine) {
                 //        m_series->append(QPointF(150, 75));
                 //    }
                 if (m_series->count() > 0) {
                     m_series->remove(m_series->points().last());
                 }
             }
             TableWidget::~TableWidget()
             {
             }

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