HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1312:0b557819e7a2

Replaced 'Bar' with 'BarSet' in BarModelMapper functions and member variables

Marek Rosa -

r1312:0b557819e7a2

parent child

Context file:

r1312:0b557819e7a2

Collapse all files

src/barchart/qbarmodelmapper.cpp +22 -22

             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 //    connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 //    connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 //    connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
-            int QBarModelMapper::firstBarSection() const
+            int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
-                return d->m_firstBarSection;
+                return d->m_firstBarSetSection;
             }
-            void QBarModelMapper::setFirstBarSection(int firstBarSection)
+            void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
-                d->m_firstBarSection = firstBarSection;
+                d->m_firstBarSetSection = firstBarSetSection;
                 d->initializeBarFromModel();
             }
-            int QBarModelMapper::lastBarSection() const
+            int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
-                return d->m_lastBarSection;
+                return d->m_lastBarSetSection;
             }
-            void QBarModelMapper::setLastBarSection(int lastBarSection)
+            void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
-                d->m_lastBarSection = lastBarSection;
+                d->m_lastBarSetSection = lastBarSetSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::categoriesSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_categoriesSection;
             }
             void QBarModelMapper::setCategoriesSection(int categoriesSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_categoriesSection = categoriesSection;
                 d->initializeBarFromModel();
             }
             void QBarModelMapper::reset()
             {
                 Q_D(QBarModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
                 d->m_orientation = Qt::Vertical;
-                d->m_firstBarSection = -1;
+                d->m_firstBarSetSection = -1;
-                d->m_lastBarSection = -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_firstBarSection(-1),
+                m_firstBarSetSection(-1),
-                m_lastBarSection(-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_firstBarSection && index.column() <= m_lastBarSection) {
+                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))
-                        return m_series->barSets().at(index.column() - m_firstBarSection);
+                        return m_series->barSets().at(index.column() - m_firstBarSetSection);
-                } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSection && index.row() <= m_lastBarSection) {
+                } 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_firstBarSection);
+                        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_firstBarSection || barSection > m_lastBarSection)
+                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_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
-                else if (start <= m_firstBarSection || start <= m_lastBarSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
+                else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int k = 0; k < m_series->barSets().count(); k++) {
                         for (int i = first; i <= last; i++) {
                             QBar point;
                             point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             m_series->insert(i - m_first, point);
                         }
                     }
                     // 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_firstBarSection; i <= m_lastBarSection; i++) {
+                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_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->setCategories(categories);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarmodelmapper.h +4 -4

             #ifndef QBARMODELMAPPER_H
             #define QBARMODELMAPPER_H
             #include "qchartglobal.h"
             #include <QObject>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapperPrivate;
             class QBarSeries;
             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);
-                int firstBarSection() const;
+                int firstBarSetSection() const;
-                void setFirstBarSection(int firstBarSection);
+                void setFirstBarSetSection(int firstBarSetSection);
-                int lastBarSection() const;
+                int lastBarSetSection() const;
-                void setLastBarSection(int lastBarSection);
+                void setLastBarSetSection(int lastBarSetSection);
                 int categoriesSection() const;
                 void setCategoriesSection(int categoriesSection);
             protected:
                 Qt::Orientation orientation() const;
                 void setOrientation(Qt::Orientation orientation);
                 void reset();
             Q_SIGNALS:
                 void updated();
             protected:
                 QBarModelMapperPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_H

src/barchart/qbarmodelmapper_p.h +2 -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_firstBarSection;
+                int m_firstBarSetSection;
-                int m_lastBarSection;
+                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 +8 -8

             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
-            int QHBarModelMapper::firstBarRow() const
+            int QHBarModelMapper::firstBarSetRow() const
             {
-                return QBarModelMapper::firstBarSection();
+                return QBarModelMapper::firstBarSetSection();
             }
-            void QHBarModelMapper::setFirstBarRow(int firstBarRow)
+            void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
-                return QBarModelMapper::setFirstBarSection(firstBarRow);
+                return QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
             }
-            int QHBarModelMapper::lastBarRow() const
+            int QHBarModelMapper::lastBarSetRow() const
             {
-                return QBarModelMapper::lastBarSection();
+                return QBarModelMapper::lastBarSetSection();
             }
-            void QHBarModelMapper::setLastBarRow(int lastBarRow)
+            void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
-                return QBarModelMapper::setLastBarSection(lastBarRow);
+                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 +6 -6

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

src/barchart/qvbarmodelmapper.cpp +8 -8

             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
-            int QVBarModelMapper::firstBarColumn() const
+            int QVBarModelMapper::firstBarSetColumn() const
             {
-                return QBarModelMapper::firstBarSection();
+                return QBarModelMapper::firstBarSetSection();
             }
-            void QVBarModelMapper::setFirstBarColumn(int firstBarColumn)
+            void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
-                return QBarModelMapper::setFirstBarSection(firstBarColumn);
+                return QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
             }
-            int QVBarModelMapper::lastBarColumn() const
+            int QVBarModelMapper::lastBarSetColumn() const
             {
-                return QBarModelMapper::lastBarSection();
+                return QBarModelMapper::lastBarSetSection();
             }
-            void QVBarModelMapper::setLastBarColumn(int lastBarColumn)
+            void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
-                return QBarModelMapper::setLastBarSection(lastBarColumn);
+                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 +6 -6

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

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