HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2897:f5164ec8f20d

Update candlestick chart model mappers API...

Alexander Mishin -

r2897:f5164ec8f20d dev

parent child

Context file:

r2897:f5164ec8f20d

Collapse all files

src/charts/candlestickchart/candlestickchartitem.cpp +3 -3

                 setZValue(ChartPresenter::CandlestickSeriesZValue);
-                handleCandlestickSetsAdd(m_series->candlestickSets());
+                handleCandlestickSetsAdd(m_series->sets());
             }
             CandlestickChartItem::~CandlestickChartItem()
                 updateTimePeriod();
                 for (int i = 0; i < m_series->count(); ++i) {
-                    QCandlestickSet *set = m_series->candlestickSets().at(i);
+                    QCandlestickSet *set = m_series->sets().at(i);
                     Candlestick *item = m_candlesticks.value(set);
                     updateCandlestickGeometry(item, i);
             {
                 bool changed = false;
-                QCandlestickSet *set = m_series->candlestickSets().at(index);
+                QCandlestickSet *set = m_series->sets().at(index);
                 CandlestickData &data = item->m_data;
                 if ((data.m_open != set->open())

src/charts/candlestickchart/qcandlestickmodelmapper.cpp +43 -43

             /*!
                 Sets the section of the model that is used as the data source for the first candlestick set.
-                Parameter \a firstCandlestickSetSection specifies the section of the model. Default value is -1.
+                Parameter \a firstSetSection specifies the section of the model. Default value is -1.
             */
-            void QCandlestickModelMapper::setFirstCandlestickSetSection(int firstCandlestickSetSection)
+            void QCandlestickModelMapper::setFirstSetSection(int firstSetSection)
             {
                 Q_D(QCandlestickModelMapper);
-                firstCandlestickSetSection = qMax(firstCandlestickSetSection, -1);
+                firstSetSection = qMax(firstSetSection, -1);
-                if (d->m_firstCandlestickSetSection == firstCandlestickSetSection)
+                if (d->m_firstSetSection == firstSetSection)
                     return;
-                d->m_firstCandlestickSetSection = firstCandlestickSetSection;
+                d->m_firstSetSection = firstSetSection;
-                emit d->firstCandlestickSetSectionChanged();
+                emit d->firstSetSectionChanged();
                 d->initializeCandlestickFromModel();
             }
                 Returns the section of the model that is used as the data source for the first candlestick set.
                 Default value is -1 (invalid mapping).
             */
-            int QCandlestickModelMapper::firstCandlestickSetSection() const
+            int QCandlestickModelMapper::firstSetSection() const
             {
                 Q_D(const QCandlestickModelMapper);
-                return d->m_firstCandlestickSetSection;
+                return d->m_firstSetSection;
             }
             /*!
                 Sets the section of the model that is used as the data source for the last candlestick set.
-                Parameter \a lastCandlestickSetSection specifies the section of the model. Default value is -1.
+                Parameter \a lastSetSection specifies the section of the model. Default value is -1.
             */
-            void QCandlestickModelMapper::setLastCandlestickSetSection(int lastCandlestickSetSection)
+            void QCandlestickModelMapper::setLastSetSection(int lastSetSection)
             {
                 Q_D(QCandlestickModelMapper);
-                lastCandlestickSetSection = qMax(lastCandlestickSetSection, -1);
+                lastSetSection = qMax(lastSetSection, -1);
-                if (d->m_lastCandlestickSetSection == lastCandlestickSetSection)
+                if (d->m_lastSetSection == lastSetSection)
                     return;
-                d->m_lastCandlestickSetSection = lastCandlestickSetSection;
+                d->m_lastSetSection = lastSetSection;
-                emit d->lastCandlestickSetSectionChanged();
+                emit d->lastSetSectionChanged();
                 d->initializeCandlestickFromModel();
             }
                 Returns the section of the model that is used as the data source for the last candlestick set.
                 Default value is -1 (invalid mapping).
             */
-            int QCandlestickModelMapper::lastCandlestickSetSection() const
+            int QCandlestickModelMapper::lastSetSection() const
             {
                 Q_D(const QCandlestickModelMapper);
-                return d->m_lastCandlestickSetSection;
+                return d->m_lastSetSection;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////
                   m_high(-1),
                   m_low(-1),
                   m_close(-1),
-                  m_firstCandlestickSetSection(-1),
+                  m_firstSetSection(-1),
-                  m_lastCandlestickSetSection(-1),
+                  m_lastSetSection(-1),
                   m_modelSignalsBlock(false),
                   m_seriesSignalsBlock(false),
                   q_ptr(q)
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
-                m_candlestickSets.clear();
+                m_sets.clear();
                 // create the initial candlestick sets
-                QList<QCandlestickSet *> candlestickSets;
+                QList<QCandlestickSet *> sets;
-                for (int i = m_firstCandlestickSetSection; i <= m_lastCandlestickSetSection; ++i) {
+                for (int i = m_firstSetSection; i <= m_lastSetSection; ++i) {
                     QModelIndex timestampIndex = candlestickModelIndex(i, m_timestamp);
                     QModelIndex openIndex = candlestickModelIndex(i, m_open);
                     QModelIndex highIndex = candlestickModelIndex(i, m_high);
                         connect(set, SIGNAL(lowChanged()), this, SLOT(candlestickSetChanged()));
                         connect(set, SIGNAL(closeChanged()), this, SLOT(candlestickSetChanged()));
-                        candlestickSets.append(set);
+                        sets.append(set);
                     } else {
                         break;
                     }
                 }
-                m_series->append(candlestickSets);
+                m_series->append(sets);
-                m_candlestickSets.append(candlestickSets);
+                m_sets.append(sets);
                 blockSeriesSignals(false);
             }
                 blockSeriesSignals();
                 if (q->orientation() == Qt::Vertical)
                     insertData(start, end);
-                else if (start <= m_firstCandlestickSetSection || start <= m_lastCandlestickSetSection)
+                else if (start <= m_firstSetSection || start <= m_lastSetSection)
                     initializeCandlestickFromModel();  // if the changes affect the map - reinitialize
                 blockSeriesSignals(false);
             }
                 blockSeriesSignals();
                 if (q->orientation() == Qt::Vertical)
                     removeData(start, end);
-                else if (start <= m_firstCandlestickSetSection || start <= m_lastCandlestickSetSection)
+                else if (start <= m_firstSetSection || start <= m_lastSetSection)
                     initializeCandlestickFromModel();  // if the changes affect the map - reinitialize
                 blockSeriesSignals(false);
             }
                 blockSeriesSignals();
                 if (q->orientation() == Qt::Horizontal)
                     insertData(start, end);
-                else if (start <= m_firstCandlestickSetSection || start <= m_lastCandlestickSetSection)
+                else if (start <= m_firstSetSection || start <= m_lastSetSection)
                     initializeCandlestickFromModel();  // if the changes affect the map - reinitialize
                 blockSeriesSignals(false);
             }
                 blockSeriesSignals();
                 if (q->orientation() == Qt::Horizontal)
                     removeData(start, end);
-                else if (start <= m_firstCandlestickSetSection || start <= m_lastCandlestickSetSection)
+                else if (start <= m_firstSetSection || start <= m_lastSetSection)
                     initializeCandlestickFromModel();  // if the changes affect the map - reinitialize
                 blockSeriesSignals(false);
             }
                 if (sets.isEmpty())
                     return;
-                int firstIndex = m_series->candlestickSets().indexOf(sets.at(0));
+                int firstIndex = m_series->sets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
-                m_lastCandlestickSetSection += sets.count();
+                m_lastSetSection += sets.count();
                 blockModelSignals();
                 if (q->orientation() == Qt::Vertical)
-                    m_model->insertColumns(firstIndex + m_firstCandlestickSetSection, sets.count());
+                    m_model->insertColumns(firstIndex + m_firstSetSection, sets.count());
                 else
-                    m_model->insertRows(firstIndex + m_firstCandlestickSetSection, sets.count());
+                    m_model->insertRows(firstIndex + m_firstSetSection, sets.count());
                 for (int i = 0; i < sets.count(); ++i) {
-                    int section = i + firstIndex + m_firstCandlestickSetSection;
+                    int section = i + firstIndex + m_firstSetSection;
                     m_model->setData(candlestickModelIndex(section, m_timestamp), sets.at(i)->timestamp());
                     m_model->setData(candlestickModelIndex(section, m_open), sets.at(i)->open());
                     m_model->setData(candlestickModelIndex(section, m_high), sets.at(i)->high());
                 if (sets.isEmpty())
                     return;
-                int firstIndex = m_candlestickSets.indexOf(sets.at(0));
+                int firstIndex = m_sets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
-                m_lastCandlestickSetSection -= sets.count();
+                m_lastSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; --i)
-                    m_candlestickSets.removeAt(i);
+                    m_sets.removeAt(i);
                 blockModelSignals();
                 if (q->orientation() == Qt::Vertical)
-                    m_model->removeColumns(firstIndex + m_firstCandlestickSetSection, sets.count());
+                    m_model->removeColumns(firstIndex + m_firstSetSection, sets.count());
                 else
-                    m_model->removeRows(firstIndex + m_firstCandlestickSetSection, sets.count());
+                    m_model->removeRows(firstIndex + m_firstSetSection, sets.count());
                 blockModelSignals(false);
                 initializeCandlestickFromModel();
             }
                 if (!set)
                     return;
-                int section = m_series->candlestickSets().indexOf(set);
+                int section = m_series->sets().indexOf(set);
                 if (section < 0)
                     return;
-                section += m_firstCandlestickSetSection;
+                section += m_firstSetSection;
                 blockModelSignals();
                 m_model->setData(candlestickModelIndex(section, m_timestamp), set->timestamp());
                 int section = (q->orientation() == Qt::Vertical) ? index.column() : index.row();
                 int pos = (q->orientation() == Qt::Vertical) ? index.row() : index.column();
-                if (section < m_firstCandlestickSetSection || section > m_lastCandlestickSetSection)
+                if (section < m_firstSetSection || section > m_lastSetSection)
                     return 0; // This part of model has not been mapped to any candlestick set.
                 if (pos != m_timestamp && pos != m_open && pos != m_high && pos != m_low && pos != m_close)
                     return 0; // This part of model has not been mapped to any candlestick set.
-                return m_series->candlestickSets().at(section - m_firstCandlestickSetSection);
+                return m_series->sets().at(section - m_firstSetSection);
             }
             QModelIndex QCandlestickModelMapperPrivate::candlestickModelIndex(int section, int pos)
             {
                 Q_Q(QCandlestickModelMapper);
-                if (section < m_firstCandlestickSetSection || section > m_lastCandlestickSetSection)
+                if (section < m_firstSetSection || section > m_lastSetSection)
                     return QModelIndex(); // invalid
                 if (pos != m_timestamp && pos != m_open && pos != m_high && pos != m_low && pos != m_close)

src/charts/candlestickchart/qcandlestickmodelmapper.h +4 -4

                 void setClose(int close);
                 int close() const;
-                void setFirstCandlestickSetSection(int firstCandlestickSetSection);
+                void setFirstSetSection(int firstSetSection);
-                int firstCandlestickSetSection() const;
+                int firstSetSection() const;
-                void setLastCandlestickSetSection(int lastCandlestickSetSection);
+                void setLastSetSection(int lastSetSection);
-                int lastCandlestickSetSection() const;
+                int lastSetSection() const;
             protected:
                 QCandlestickModelMapperPrivate * const d_ptr;

src/charts/candlestickchart/qcandlestickmodelmapper_p.h +5 -5

                 void highChanged();
                 void lowChanged();
                 void closeChanged();
-                void firstCandlestickSetSectionChanged();
+                void firstSetSectionChanged();
-                void lastCandlestickSetSectionChanged();
+                void lastSetSectionChanged();
             private Q_SLOTS:
                 void initializeCandlestickFromModel();
                 int m_high;
                 int m_low;
                 int m_close;
-                int m_firstCandlestickSetSection;
+                int m_firstSetSection;
-                int m_lastCandlestickSetSection;
+                int m_lastSetSection;
-                QList<QCandlestickSet *> m_candlestickSets;
+                QList<QCandlestickSet *> m_sets;
                 bool m_modelSignalsBlock;
                 bool m_seriesSignalsBlock;

src/charts/candlestickchart/qcandlestickseries.cpp +17 -17

             {
                 Q_D(QCandlestickSeries);
-                QList<QCandlestickSet *> sets = candlestickSets();
+                QList<QCandlestickSet *> sets = this->sets();
                 bool success = d->remove(sets);
                 if (success) {
             /*!
                 Returns the list of sets in the series. Ownership of the sets is unchanged.
              */
-            QList<QCandlestickSet *> QCandlestickSeries::candlestickSets() const
+            QList<QCandlestickSet *> QCandlestickSeries::sets() const
             {
                 Q_D(const QCandlestickSeries);
-                return d->m_candlestickSets;
+                return d->m_sets;
             }
             /*!
             */
             int QCandlestickSeries::count() const
             {
-                return candlestickSets().count();
+                return sets().count();
             }
             /*!
                 qreal minY(domain()->minY());
                 qreal maxY(domain()->maxY());
-                if (m_candlestickSets.count()) {
+                if (m_sets.count()) {
-                    QCandlestickSet *set = m_candlestickSets.first();
+                    QCandlestickSet *set = m_sets.first();
                     minX = set->timestamp();
                     maxX = set->timestamp();
                     minY = set->low();
                     maxY = set->high();
-                    for (int i = 1; i < m_candlestickSets.count(); ++i) {
+                    for (int i = 1; i < m_sets.count(); ++i) {
-                        set = m_candlestickSets.at(i);
+                        set = m_sets.at(i);
                         minX = qMin(minX, qreal(set->timestamp()));
                         maxX = qMax(maxX, qreal(set->timestamp()));
                         minY = qMin(minY, set->low());
                         maxY = qMax(maxY, set->high());
                     }
-                    qreal extra = (maxX - minX) / m_candlestickSets.count() / 2;
+                    qreal extra = (maxX - minX) / m_sets.count() / 2;
                     minX = minX - extra;
                     maxX = maxX + extra;
                 }
             bool QCandlestickSeriesPrivate::append(const QList<QCandlestickSet *> &sets)
             {
                 foreach (QCandlestickSet *set, sets) {
-                    if ((set == 0) || m_candlestickSets.contains(set) || set->d_ptr->m_series)
+                    if ((set == 0) || m_sets.contains(set) || set->d_ptr->m_series)
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if the same set occurs more than once in the given list.
                 }
                 foreach (QCandlestickSet *set, sets) {
-                    m_candlestickSets.append(set);
+                    m_sets.append(set);
                     connect(set->d_func(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     connect(set->d_func(), SIGNAL(updatedCandlestick()), this, SIGNAL(updatedCandlesticks()));
                     set->d_ptr->m_series = this;
                     return false;
                 foreach (QCandlestickSet *set, sets) {
-                    if ((set == 0) || (!m_candlestickSets.contains(set)))
+                    if ((set == 0) || (!m_sets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series.
                     if (sets.count(set) != 1)
                         return false; // Also fail if the same set occurs more than once in the given list.
                 foreach (QCandlestickSet *set, sets) {
                     set->d_ptr->m_series = nullptr;
-                    m_candlestickSets.removeOne(set);
+                    m_sets.removeOne(set);
                     disconnect(set->d_func(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     disconnect(set->d_func(), SIGNAL(updatedCandlestick()),this, SIGNAL(updatedCandlesticks()));
                 }
             bool QCandlestickSeriesPrivate::insert(int index, QCandlestickSet *set)
             {
-                if ((m_candlestickSets.contains(set)) || (set == 0) || set->d_ptr->m_series)
+                if ((m_sets.contains(set)) || (set == 0) || set->d_ptr->m_series)
                     return false; // Fail if set is already in list or set is null.
-                m_candlestickSets.insert(index, set);
+                m_sets.insert(index, set);
                 connect(set->d_func(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 connect(set->d_func(), SIGNAL(updatedCandlestick()), this, SIGNAL(updatedCandlesticks()));
                 set->d_ptr->m_series = this;
             {
                 if (axis->categories().isEmpty()) {
                     QStringList categories;
-                    for (int i = 0; i < m_candlestickSets.count(); ++i) {
+                    for (int i = 0; i < m_sets.count(); ++i) {
-                        const qint64 timestamp = qRound64(m_candlestickSets.at(i)->timestamp());
+                        const qint64 timestamp = qRound64(m_sets.at(i)->timestamp());
                         const QString timestampFormat = m_chart->locale().dateTimeFormat(QLocale::ShortFormat);
                         categories << QDateTime::fromMSecsSinceEpoch(timestamp).toString(timestampFormat);
                     }

src/charts/candlestickchart/qcandlestickseries.h +1 -1

                 bool take(QCandlestickSet *set);
                 void clear();
-                QList<QCandlestickSet *> candlestickSets() const;
+                QList<QCandlestickSet *> sets() const;
                 int count() const;
                 QAbstractSeries::SeriesType type() const;

src/charts/candlestickchart/qcandlestickseries_p.h +1 -1

                 void populateBarCategories(QBarCategoryAxis *axis);
             protected:
-                QList<QCandlestickSet *> m_candlestickSets;
+                QList<QCandlestickSet *> m_sets;
                 qreal m_maximumColumnWidth;
                 qreal m_minimumColumnWidth;
                 qreal m_bodyWidth;

src/charts/candlestickchart/qhcandlestickmodelmapper.cpp +20 -22

                             highColumn: 3
                             lowColumn: 4
                             closeColumn: 5
-                            firstCandlestickSetRow: 1
+                            firstSetRow: 1
-                            lastCandlestickSetRow: 3
+                            lastSetRow: 3
                         }
                     }
                 \endqml
             */
             /*!
-                \property QHCandlestickModelMapper::firstCandlestickSetRow
+                \property QHCandlestickModelMapper::firstSetRow
                 \brief Defines the row of the model that is used as the data source for the first set. Default
                 value is -1 (invalid mapping).
             */
             /*!
-                \qmlproperty int HCandlestickModelMapper::firstCandlestickSetRow
+                \qmlproperty int HCandlestickModelMapper::firstSetRow
                 \brief Defines the row of the model that is used as the data source for the first set. Default
                 value is -1 (invalid mapping).
             */
             /*!
-                \property QHCandlestickModelMapper::lastCandlestickSetRow
+                \property QHCandlestickModelMapper::lastSetRow
                 \brief Defines the row of the model that is used as the data source for the last set. Default
                 value is -1 (invalid mapping).
             */
             /*!
-                \qmlproperty int HCandlestickModelMapper::lastCandlestickSetRow
+                \qmlproperty int HCandlestickModelMapper::lastSetRow
                 \brief Defines the row of the model that is used as the data source for the last set. Default
                 value is -1 (invalid mapping).
             */
             */
             /*!
-                \fn void QHCandlestickModelMapper::firstCandlestickSetRowChanged()
+                \fn void QHCandlestickModelMapper::firstSetRowChanged()
                 \brief Emitted when the row of the model that contains the data of the first set is changed.
-                \sa firstCandlestickSetRow
+                \sa firstSetRow
             */
             /*!
-                \fn void QHCandlestickModelMapper::lastCandlestickSetRowChanged()
+                \fn void QHCandlestickModelMapper::lastSetRowChanged()
                 \brief Emitted when the row of the model that contains the data of the last set is changed.
-                \sa lastCandlestickSetRow
+                \sa lastSetRow
             */
             /*!
                 connect(d_ptr, SIGNAL(highChanged()), this, SIGNAL(highColumnChanged()));
                 connect(d_ptr, SIGNAL(lowChanged()), this, SIGNAL(lowColumnChanged()));
                 connect(d_ptr, SIGNAL(closeChanged()), this, SIGNAL(closeColumnChanged()));
-                connect(d_ptr, SIGNAL(firstCandlestickSetSectionChanged()),
+                connect(d_ptr, SIGNAL(firstSetSectionChanged()), this, SIGNAL(firstSetRowChanged()));
-                        this, SIGNAL(firstCandlestickSetRowChanged()));
+                connect(d_ptr, SIGNAL(lastSetSectionChanged()), this, SIGNAL(lastSetRowChanged()));
-                connect(d_ptr, SIGNAL(lastCandlestickSetSectionChanged()),
-                        this, SIGNAL(lastCandlestickSetRowChanged()));
             }
             /*!
                 return QCandlestickModelMapper::close();
             }
-            void QHCandlestickModelMapper::setFirstCandlestickSetRow(int firstCandlestickSetRow)
+            void QHCandlestickModelMapper::setFirstSetRow(int firstSetRow)
             {
-                QCandlestickModelMapper::setFirstCandlestickSetSection(firstCandlestickSetRow);
+                QCandlestickModelMapper::setFirstSetSection(firstSetRow);
             }
-            int QHCandlestickModelMapper::firstCandlestickSetRow() const
+            int QHCandlestickModelMapper::firstSetRow() const
             {
-                return QCandlestickModelMapper::firstCandlestickSetSection();
+                return QCandlestickModelMapper::firstSetSection();
             }
-            void QHCandlestickModelMapper::setLastCandlestickSetRow(int lastCandlestickSetRow)
+            void QHCandlestickModelMapper::setLastSetRow(int lastSetRow)
             {
-                QCandlestickModelMapper::setLastCandlestickSetSection(lastCandlestickSetRow);
+                QCandlestickModelMapper::setLastSetSection(lastSetRow);
             }
-            int QHCandlestickModelMapper::lastCandlestickSetRow() const
+            int QHCandlestickModelMapper::lastSetRow() const
             {
-                return QCandlestickModelMapper::lastCandlestickSetSection();
+                return QCandlestickModelMapper::lastSetSection();
             }
             #include "moc_qhcandlestickmodelmapper.cpp"

src/charts/candlestickchart/qhcandlestickmodelmapper.h +8 -8

                 Q_PROPERTY(int highColumn READ highColumn WRITE setHighColumn NOTIFY highColumnChanged)
                 Q_PROPERTY(int lowColumn READ lowColumn WRITE setLowColumn NOTIFY lowColumnChanged)
                 Q_PROPERTY(int closeColumn READ closeColumn WRITE setCloseColumn NOTIFY closeColumnChanged)
-                Q_PROPERTY(int firstCandlestickSetRow READ firstCandlestickSetRow WRITE setFirstCandlestickSetRow NOTIFY firstCandlestickSetRowChanged)
+                Q_PROPERTY(int firstSetRow READ firstSetRow WRITE setFirstSetRow NOTIFY firstSetRowChanged)
-                Q_PROPERTY(int lastCandlestickSetRow READ lastCandlestickSetRow WRITE setLastCandlestickSetRow NOTIFY lastCandlestickSetRowChanged)
+                Q_PROPERTY(int lastSetRow READ lastSetRow WRITE setLastSetRow NOTIFY lastSetRowChanged)
             public:
                 explicit QHCandlestickModelMapper(QObject *parent = nullptr);
                 void setCloseColumn(int closeColumn);
                 int closeColumn() const;
-                void setFirstCandlestickSetRow(int firstCandlestickSetRow);
+                void setFirstSetRow(int firstSetRow);
-                int firstCandlestickSetRow() const;
+                int firstSetRow() const;
-                void setLastCandlestickSetRow(int lastCandlestickSetRow);
+                void setLastSetRow(int lastSetRow);
-                int lastCandlestickSetRow() const;
+                int lastSetRow() const;
             Q_SIGNALS:
                 void timestampColumnChanged();
                 void highColumnChanged();
                 void lowColumnChanged();
                 void closeColumnChanged();
-                void firstCandlestickSetRowChanged();
+                void firstSetRowChanged();
-                void lastCandlestickSetRowChanged();
+                void lastSetRowChanged();
             };
             QT_CHARTS_END_NAMESPACE

src/charts/candlestickchart/qvcandlestickmodelmapper.cpp +20 -22

                             highRow: 3
                             lowRow: 4
                             closeRow: 5
-                            firstCandlestickSetColumn: 1
+                            firstSetColumn: 1
-                            lastCandlestickSetColumn: 3
+                            lastSetColumn: 3
                         }
                     }
                 \endqml
             */
             /*!
-                \property QVCandlestickModelMapper::firstCandlestickSetColumn
+                \property QVCandlestickModelMapper::firstSetColumn
                 \brief Defines the column of the model that is used as the data source for the first set.
                 Default value is -1 (invalid mapping).
             */
             /*!
-                \qmlproperty int VCandlestickModelMapper::firstCandlestickSetColumn
+                \qmlproperty int VCandlestickModelMapper::firstSetColumn
                 \brief Defines the column of the model that is used as the data source for the first set.
                 Default value is -1 (invalid mapping).
             */
             /*!
-                \property QVCandlestickModelMapper::lastCandlestickSetColumn
+                \property QVCandlestickModelMapper::lastSetColumn
                 \brief Defines the column of the model that is used as the data source for the last set. Default
                 value is -1 (invalid mapping).
             */
             /*!
-                \qmlproperty int VCandlestickModelMapper::lastCandlestickSetColumn
+                \qmlproperty int VCandlestickModelMapper::lastSetColumn
                 \brief Defines the column of the model that is used as the data source for the last set. Default
                 value is -1 (invalid mapping).
             */
             */
             /*!
-                \fn void QVCandlestickModelMapper::firstCandlestickSetColumnChanged()
+                \fn void QVCandlestickModelMapper::firstSetColumnChanged()
                 \brief Emitted when the column of the model that contains the data of the first set is changed.
-                \sa firstCandlestickSetColumn
+                \sa firstSetColumn
             */
             /*!
-                \fn void QVCandlestickModelMapper::lastCandlestickSetColumnChanged()
+                \fn void QVCandlestickModelMapper::lastSetColumnChanged()
                 \brief Emitted when the column of the model that contains the data of the last set is changed.
-                \sa lastCandlestickSetColumn
+                \sa lastSetColumn
             */
             /*!
                 connect(d_ptr, SIGNAL(highChanged()), this, SIGNAL(highRowChanged()));
                 connect(d_ptr, SIGNAL(lowChanged()), this, SIGNAL(lowRowChanged()));
                 connect(d_ptr, SIGNAL(closeChanged()), this, SIGNAL(closeRowChanged()));
-                connect(d_ptr, SIGNAL(firstCandlestickSetSectionChanged()),
+                connect(d_ptr, SIGNAL(firstSetSectionChanged()), this, SIGNAL(firstSetColumnChanged()));
-                        this, SIGNAL(firstCandlestickSetColumnChanged()));
+                connect(d_ptr, SIGNAL(lastSetSectionChanged()), this, SIGNAL(lastSetColumnChanged()));
-                connect(d_ptr, SIGNAL(lastCandlestickSetSectionChanged()),
-                        this, SIGNAL(lastCandlestickSetColumnChanged()));
             }
             /*!
                 return QCandlestickModelMapper::close();
             }
-            void QVCandlestickModelMapper::setFirstCandlestickSetColumn(int firstCandlestickSetColumn)
+            void QVCandlestickModelMapper::setFirstSetColumn(int firstSetColumn)
             {
-                QCandlestickModelMapper::setFirstCandlestickSetSection(firstCandlestickSetColumn);
+                QCandlestickModelMapper::setFirstSetSection(firstSetColumn);
             }
-            int QVCandlestickModelMapper::firstCandlestickSetColumn() const
+            int QVCandlestickModelMapper::firstSetColumn() const
             {
-                return QCandlestickModelMapper::firstCandlestickSetSection();
+                return QCandlestickModelMapper::firstSetSection();
             }
-            void QVCandlestickModelMapper::setLastCandlestickSetColumn(int lastCandlestickSetColumn)
+            void QVCandlestickModelMapper::setLastSetColumn(int lastSetColumn)
             {
-                QCandlestickModelMapper::setLastCandlestickSetSection(lastCandlestickSetColumn);
+                QCandlestickModelMapper::setLastSetSection(lastSetColumn);
             }
-            int QVCandlestickModelMapper::lastCandlestickSetColumn() const
+            int QVCandlestickModelMapper::lastSetColumn() const
             {
-                return QCandlestickModelMapper::lastCandlestickSetSection();
+                return QCandlestickModelMapper::lastSetSection();
             }
             #include "moc_qvcandlestickmodelmapper.cpp"

src/charts/candlestickchart/qvcandlestickmodelmapper.h +8 -8

                 Q_PROPERTY(int highRow READ highRow WRITE setHighRow NOTIFY highRowChanged)
                 Q_PROPERTY(int lowRow READ lowRow WRITE setLowRow NOTIFY lowRowChanged)
                 Q_PROPERTY(int closeRow READ closeRow WRITE setCloseRow NOTIFY closeRowChanged)
-                Q_PROPERTY(int firstCandlestickSetColumn READ firstCandlestickSetColumn WRITE setFirstCandlestickSetColumn NOTIFY firstCandlestickSetColumnChanged)
+                Q_PROPERTY(int firstSetColumn READ firstSetColumn WRITE setFirstSetColumn NOTIFY firstSetColumnChanged)
-                Q_PROPERTY(int lastCandlestickSetColumn READ lastCandlestickSetColumn WRITE setLastCandlestickSetColumn NOTIFY lastCandlestickSetColumnChanged)
+                Q_PROPERTY(int lastSetColumn READ lastSetColumn WRITE setLastSetColumn NOTIFY lastSetColumnChanged)
             public:
                 explicit QVCandlestickModelMapper(QObject *parent = nullptr);
                 void setCloseRow(int closeRow);
                 int closeRow() const;
-                void setFirstCandlestickSetColumn(int firstCandlestickSetColumn);
+                void setFirstSetColumn(int firstSetColumn);
-                int firstCandlestickSetColumn() const;
+                int firstSetColumn() const;
-                void setLastCandlestickSetColumn(int lastCandlestickSetColumn);
+                void setLastSetColumn(int lastSetColumn);
-                int lastCandlestickSetColumn() const;
+                int lastSetColumn() const;
             Q_SIGNALS:
                 void timestampRowChanged();
                 void highRowChanged();
                 void lowRowChanged();
                 void closeRowChanged();
-                void firstCandlestickSetColumnChanged();
+                void firstSetColumnChanged();
-                void lastCandlestickSetColumnChanged();
+                void lastSetColumnChanged();
             };
             QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativecandlestickseries.cpp +2 -2

             DeclarativeCandlestickSet *DeclarativeCandlestickSeries::at(int index)
             {
-                QList<QCandlestickSet *> sets = candlestickSets();
+                QList<QCandlestickSet *> sets = this->sets();
                 if (index >= 0 && index < sets.count())
                     return qobject_cast<DeclarativeCandlestickSet *>(sets[index]);
             bool DeclarativeCandlestickSeries::remove(qreal timestamp)
             {
                 for (int i = 0; i < count(); ++i) {
-                    QCandlestickSet *set = candlestickSets().at(i);
+                    QCandlestickSet *set = sets().at(i);
                     if (set->timestamp() == timestamp)
                         return QCandlestickSeries::remove(set);
                 }

tests/auto/qcandlestickmodelmapper/tst_qcandlestickmodelmapper.cpp +52 -52

                 m_hMapper->setHighColumn(3);
                 m_hMapper->setLowColumn(5);
                 m_hMapper->setCloseColumn(6);
-                m_hMapper->setFirstCandlestickSetRow(0);
+                m_hMapper->setFirstSetRow(0);
-                m_hMapper->setLastCandlestickSetRow(4);
+                m_hMapper->setLastSetRow(4);
                 m_hMapper->setModel(m_model);
                 m_hMapper->setSeries(m_series);
             }
                 m_vMapper->setHighRow(3);
                 m_vMapper->setLowRow(5);
                 m_vMapper->setCloseRow(6);
-                m_vMapper->setFirstCandlestickSetColumn(0);
+                m_vMapper->setFirstSetColumn(0);
-                m_vMapper->setLastCandlestickSetColumn(4);
+                m_vMapper->setLastSetColumn(4);
                 m_vMapper->setModel(m_model);
                 m_vMapper->setSeries(m_series);
             }
             void tst_qcandlestickmodelmapper::verticalMapper_data()
             {
-                QTest::addColumn<int>("firstCandlestickSetColumn");
+                QTest::addColumn<int>("firstSetColumn");
-                QTest::addColumn<int>("lastCandlestickSetColumn");
+                QTest::addColumn<int>("lastSetColumn");
-                QTest::addColumn<int>("expectedCandlestickSetCount");
+                QTest::addColumn<int>("expectedSetCount");
                 QTest::newRow("last column greater than first column") << 0 << 1 << 2;
                 QTest::newRow("last column equal to first column") << 1 << 1 << 1;
             void tst_qcandlestickmodelmapper::verticalMapper()
             {
-                QFETCH(int, firstCandlestickSetColumn);
+                QFETCH(int, firstSetColumn);
-                QFETCH(int, lastCandlestickSetColumn);
+                QFETCH(int, lastSetColumn);
-                QFETCH(int, expectedCandlestickSetCount);
+                QFETCH(int, expectedSetCount);
                 QCandlestickSeries *series = new QCandlestickSeries();
                 m_chart->addSeries(series);
                 createVerticalMapper();
-                m_vMapper->setFirstCandlestickSetColumn(firstCandlestickSetColumn);
+                m_vMapper->setFirstSetColumn(firstSetColumn);
-                m_vMapper->setLastCandlestickSetColumn(lastCandlestickSetColumn);
+                m_vMapper->setLastSetColumn(lastSetColumn);
                 m_vMapper->setSeries(series);
-                QCOMPARE(m_vMapper->firstCandlestickSetColumn(), qMax(firstCandlestickSetColumn, -1));
+                QCOMPARE(m_vMapper->firstSetColumn(), qMax(firstSetColumn, -1));
-                QCOMPARE(m_vMapper->lastCandlestickSetColumn(), qMax(lastCandlestickSetColumn, -1));
+                QCOMPARE(m_vMapper->lastSetColumn(), qMax(lastSetColumn, -1));
-                QCOMPARE(series->count(), expectedCandlestickSetCount);
+                QCOMPARE(series->count(), expectedSetCount);
                 m_chart->removeSeries(series);
                 delete series;
                     && (m_vMapper->highRow() >= 0 && m_vMapper->highRow() < m_modelRowCount)
                     && (m_vMapper->lowRow() >= 0 && m_vMapper->lowRow() < m_modelRowCount)
                     && (m_vMapper->closeRow() >= 0 && m_vMapper->closeRow() < m_modelRowCount))
-                    count = m_vMapper->lastCandlestickSetColumn() - m_vMapper->firstCandlestickSetColumn() + 1;
+                    count = m_vMapper->lastSetColumn() - m_vMapper->firstSetColumn() + 1;
                 else
                     count = 0;
                 QCOMPARE(series->count(), count);
                 // change values column mapping to invalid
-                m_vMapper->setFirstCandlestickSetColumn(-1);
+                m_vMapper->setFirstSetColumn(-1);
-                m_vMapper->setLastCandlestickSetColumn(1);
+                m_vMapper->setLastSetColumn(1);
                 QCOMPARE(series->count(), 0);
                 m_chart->removeSeries(series);
             void tst_qcandlestickmodelmapper::horizontalMapper_data()
             {
-                QTest::addColumn<int>("firstCandlestickSetRow");
+                QTest::addColumn<int>("firstSetRow");
-                QTest::addColumn<int>("lastCandlestickSetRow");
+                QTest::addColumn<int>("lastSetRow");
-                QTest::addColumn<int>("expectedCandlestickSetCount");
+                QTest::addColumn<int>("expectedSetCount");
                 QTest::newRow("last row greater than first row") << 0 << 1 << 2;
                 QTest::newRow("last row equal to first row") << 1 << 1 << 1;
             void tst_qcandlestickmodelmapper::horizontalMapper()
             {
-                QFETCH(int, firstCandlestickSetRow);
+                QFETCH(int, firstSetRow);
-                QFETCH(int, lastCandlestickSetRow);
+                QFETCH(int, lastSetRow);
-                QFETCH(int, expectedCandlestickSetCount);
+                QFETCH(int, expectedSetCount);
                 QCandlestickSeries *series = new QCandlestickSeries();
                 m_chart->addSeries(series);
                 createHorizontalMapper();
-                m_hMapper->setFirstCandlestickSetRow(firstCandlestickSetRow);
+                m_hMapper->setFirstSetRow(firstSetRow);
-                m_hMapper->setLastCandlestickSetRow(lastCandlestickSetRow);
+                m_hMapper->setLastSetRow(lastSetRow);
                 m_hMapper->setSeries(series);
-                QCOMPARE(m_hMapper->firstCandlestickSetRow(), qMax(firstCandlestickSetRow, -1));
+                QCOMPARE(m_hMapper->firstSetRow(), qMax(firstSetRow, -1));
-                QCOMPARE(m_hMapper->lastCandlestickSetRow(), qMax(lastCandlestickSetRow, -1));
+                QCOMPARE(m_hMapper->lastSetRow(), qMax(lastSetRow, -1));
-                QCOMPARE(series->count(), expectedCandlestickSetCount);
+                QCOMPARE(series->count(), expectedSetCount);
                 m_chart->removeSeries(series);
                 delete series;
                     && (m_hMapper->highColumn() >= 0 && m_hMapper->highColumn() < m_modelColumnCount)
                     && (m_hMapper->lowColumn() >= 0 && m_hMapper->lowColumn() < m_modelColumnCount)
                     && (m_hMapper->closeColumn() >= 0 && m_hMapper->closeColumn() < m_modelColumnCount))
-                    count = m_hMapper->lastCandlestickSetRow() - m_hMapper->firstCandlestickSetRow() + 1;
+                    count = m_hMapper->lastSetRow() - m_hMapper->firstSetRow() + 1;
                 else
                     count = 0;
                 QCOMPARE(series->count(), count);
                 // change values row mapping to invalid
-                m_hMapper->setFirstCandlestickSetRow(-1);
+                m_hMapper->setFirstSetRow(-1);
-                m_hMapper->setLastCandlestickSetRow(1);
+                m_hMapper->setLastSetRow(1);
                 QCOMPARE(series->count(), 0);
                 m_chart->removeSeries(series);
                 createVerticalMapper();
                 QVERIFY(m_vMapper->model() != nullptr);
-                QCandlestickSet *set = m_series->candlestickSets().value(0, 0);
+                QCandlestickSet *set = m_series->sets().value(0, 0);
                 QVERIFY(set != nullptr);
                 // update values
                 // remove sets
                 newCandlestickSets.clear();
-                newCandlestickSets << m_series->candlestickSets().at(m_series->count() - 1);
+                newCandlestickSets << m_series->sets().at(m_series->count() - 1);
-                newCandlestickSets << m_series->candlestickSets().at(m_series->count() - 2);
+                newCandlestickSets << m_series->sets().at(m_series->count() - 2);
                 m_series->remove(newCandlestickSets);
                 QCOMPARE(m_model->columnCount(), m_modelColumnCount);
             }
             void tst_qcandlestickmodelmapper::verticalModelInsertRows()
             {
                 createVerticalMapper();
-                int count = m_vMapper->lastCandlestickSetColumn() - m_vMapper->firstCandlestickSetColumn() + 1;
+                int count = m_vMapper->lastSetColumn() - m_vMapper->firstSetColumn() + 1;
                 QVERIFY(m_vMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::verticalModelRemoveRows()
             {
                 createVerticalMapper();
-                int count = m_vMapper->lastCandlestickSetColumn() - m_vMapper->firstCandlestickSetColumn() + 1;
+                int count = m_vMapper->lastSetColumn() - m_vMapper->firstSetColumn() + 1;
                 QVERIFY(m_vMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::verticalModelInsertColumns()
             {
                 createVerticalMapper();
-                int count = m_vMapper->lastCandlestickSetColumn() - m_vMapper->firstCandlestickSetColumn() + 1;
+                int count = m_vMapper->lastSetColumn() - m_vMapper->firstSetColumn() + 1;
                 QVERIFY(m_vMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::verticalModelRemoveColumns()
             {
                 createVerticalMapper();
-                int count = m_vMapper->lastCandlestickSetColumn() - m_vMapper->firstCandlestickSetColumn() + 1;
+                int count = m_vMapper->lastSetColumn() - m_vMapper->firstSetColumn() + 1;
                 QVERIFY(m_vMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::horizontalModelInsertRows()
             {
                 createHorizontalMapper();
-                int count = m_hMapper->lastCandlestickSetRow() - m_hMapper->firstCandlestickSetRow() + 1;
+                int count = m_hMapper->lastSetRow() - m_hMapper->firstSetRow() + 1;
                 QVERIFY(m_hMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::horizontalModelRemoveRows()
             {
                 createHorizontalMapper();
-                int count = m_hMapper->lastCandlestickSetRow() - m_hMapper->firstCandlestickSetRow() + 1;
+                int count = m_hMapper->lastSetRow() - m_hMapper->firstSetRow() + 1;
                 QVERIFY(m_hMapper->model() != 0);
                 QCOMPARE(m_series->count(), qMin(m_model->rowCount(), count));
             void tst_qcandlestickmodelmapper::horizontalModelInsertColumns()
             {
                 createHorizontalMapper();
-                int count = m_hMapper->lastCandlestickSetRow() - m_hMapper->firstCandlestickSetRow() + 1;
+                int count = m_hMapper->lastSetRow() - m_hMapper->firstSetRow() + 1;
                 QVERIFY(m_hMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
             void tst_qcandlestickmodelmapper::horizontalModelRemoveColumns()
             {
                 createHorizontalMapper();
-                int count = m_hMapper->lastCandlestickSetRow() - m_hMapper->firstCandlestickSetRow() + 1;
+                int count = m_hMapper->lastSetRow() - m_hMapper->firstSetRow() + 1;
                 QVERIFY(m_hMapper->model() != 0);
                 QCOMPARE(m_series->count(), count);
                 qreal newValue = 44.0;
                 QVERIFY(m_model->setData(index, newValue));
                 QCOMPARE(m_model->data(index).toReal(), newValue);
-                QCOMPARE(m_series->candlestickSets().at(index.row())->timestamp(), newValue);
+                QCOMPARE(m_series->sets().at(index.row())->timestamp(), newValue);
             }
             void tst_qcandlestickmodelmapper::verticalMapperSignals()
                 QSignalSpy spy4(mapper, SIGNAL(highRowChanged()));
                 QSignalSpy spy5(mapper, SIGNAL(lowRowChanged()));
                 QSignalSpy spy6(mapper, SIGNAL(closeRowChanged()));
-                QSignalSpy spy7(mapper, SIGNAL(firstCandlestickSetColumnChanged()));
+                QSignalSpy spy7(mapper, SIGNAL(firstSetColumnChanged()));
-                QSignalSpy spy8(mapper, SIGNAL(lastCandlestickSetColumnChanged()));
+                QSignalSpy spy8(mapper, SIGNAL(lastSetColumnChanged()));
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
                 mapper->setHighRow(3);
                 mapper->setLowRow(4);
                 mapper->setCloseRow(5);
-                mapper->setFirstCandlestickSetColumn(0);
+                mapper->setFirstSetColumn(0);
-                mapper->setLastCandlestickSetColumn(1);
+                mapper->setLastSetColumn(1);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QSignalSpy spy4(mapper, SIGNAL(highColumnChanged()));
                 QSignalSpy spy5(mapper, SIGNAL(lowColumnChanged()));
                 QSignalSpy spy6(mapper, SIGNAL(closeColumnChanged()));
-                QSignalSpy spy7(mapper, SIGNAL(firstCandlestickSetRowChanged()));
+                QSignalSpy spy7(mapper, SIGNAL(firstSetRowChanged()));
-                QSignalSpy spy8(mapper, SIGNAL(lastCandlestickSetRowChanged()));
+                QSignalSpy spy8(mapper, SIGNAL(lastSetRowChanged()));
                 mapper->setModel(m_model);
                 mapper->setSeries(m_series);
                 mapper->setHighColumn(3);
                 mapper->setLowColumn(4);
                 mapper->setCloseColumn(5);
-                mapper->setFirstCandlestickSetRow(0);
+                mapper->setFirstSetRow(0);
-                mapper->setLastCandlestickSetRow(1);
+                mapper->setLastSetRow(1);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);

tests/auto/qcandlestickseries/tst_qcandlestickseries.cpp +17 -17

                 void insert();
                 void take();
                 void clear();
-                void candlestickSets();
+                void sets();
                 void count();
                 void type();
                 void maximumColumnWidth_data();
                 QCOMPARE(m_series->count(), m_sets.count() - removeCount);
                 for (int i = removeCount; i < m_sets.count(); ++i)
-                    QCOMPARE(m_series->candlestickSets().at(i - removeCount), m_sets.at(i));
+                    QCOMPARE(m_series->sets().at(i - removeCount), m_sets.at(i));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 for (int i = 0; i < m_sets.count(); ++i)
                 QCOMPARE(m_series->count(), 0);
             }
-            void tst_QCandlestickSeries::candlestickSets()
+            void tst_QCandlestickSeries::sets()
             {
                 m_series->append(m_sets);
-                QCOMPARE(m_series->candlestickSets(), m_sets);
+                QCOMPARE(m_series->sets(), m_sets);
                 for (int i = 0; i < m_sets.count(); ++i)
-                    QCOMPARE(m_series->candlestickSets().at(i), m_sets.at(i));
+                    QCOMPARE(m_series->sets().at(i), m_sets.at(i));
                 m_series->clear();
-                QCOMPARE(m_series->candlestickSets(), QList<QCandlestickSet *>());
+                QCOMPARE(m_series->sets(), QList<QCandlestickSet *>());
             }
             void tst_QCandlestickSeries::count()
             {
                 m_series->append(m_sets);
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCOMPARE(m_series->count(), m_series->candlestickSets().count());
+                QCOMPARE(m_series->count(), m_series->sets().count());
             }
             void tst_QCandlestickSeries::type()
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCandlestickSet *set1 = m_series->candlestickSets().at(1);
+                QCandlestickSet *set1 = m_series->sets().at(1);
-                QCandlestickSet *set2 = m_series->candlestickSets().at(2);
+                QCandlestickSet *set2 = m_series->sets().at(2);
                 QSignalSpy seriesSpy(m_series, SIGNAL(clicked(QCandlestickSet *)));
                 QSignalSpy setSpy1(set1, SIGNAL(clicked()));
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCandlestickSet *set1 = m_series->candlestickSets().at(1);
+                QCandlestickSet *set1 = m_series->sets().at(1);
-                QCandlestickSet *set2 = m_series->candlestickSets().at(2);
+                QCandlestickSet *set2 = m_series->sets().at(2);
                 QSignalSpy seriesSpy(m_series, SIGNAL(hovered(bool, QCandlestickSet *)));
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCandlestickSet *set1 = m_series->candlestickSets().at(1);
+                QCandlestickSet *set1 = m_series->sets().at(1);
-                QCandlestickSet *set2 = m_series->candlestickSets().at(2);
+                QCandlestickSet *set2 = m_series->sets().at(2);
                 QSignalSpy seriesSpy(m_series, SIGNAL(pressed(QCandlestickSet *)));
                 QSignalSpy setSpy1(set1, SIGNAL(pressed()));
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCandlestickSet *set1 = m_series->candlestickSets().at(1);
+                QCandlestickSet *set1 = m_series->sets().at(1);
-                QCandlestickSet *set2 = m_series->candlestickSets().at(2);
+                QCandlestickSet *set2 = m_series->sets().at(2);
                 QSignalSpy seriesSpy(m_series, SIGNAL(released(QCandlestickSet *)));
                 QSignalSpy setSpy1(set1, SIGNAL(released()));
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_sets.count());
-                QCandlestickSet *set1 = m_series->candlestickSets().at(1);
+                QCandlestickSet *set1 = m_series->sets().at(1);
-                QCandlestickSet *set2 = m_series->candlestickSets().at(2);
+                QCandlestickSet *set2 = m_series->sets().at(2);
                 QSignalSpy seriesSpy(m_series, SIGNAL(doubleClicked(QCandlestickSet *)));
                 QSignalSpy setSpy1(set1, SIGNAL(doubleClicked()));

tests/manual/candlesticktester/mainwidget.cpp +16 -16

                     series = nullptr;
                 m_axisX = m_chart->axes(Qt::Horizontal).first();
-                if (series && !series->candlestickSets().isEmpty()) {
+                if (series && !series->sets().isEmpty()) {
                     if (m_axisX->type() == QAbstractAxis::AxisTypeBarCategory) {
                         QBarCategoryAxis *axisX = qobject_cast<QBarCategoryAxis *>(m_axisX);
                         QStringList categories;
-                        for (int i = 0; i < series->candlestickSets().count(); ++i)
+                        for (int i = 0; i < series->sets().count(); ++i)
                             categories.append(QString::number(i));
                         axisX->setCategories(categories);
                     } else { // QAbstractAxis::AxisTypeDateTime || QAbstractAxis::AxisTypeValue
                         qreal msInMonth = 31.0 * 24.0 * 60.0 * 60.0 * 1000.0;
-                        qreal min = series->candlestickSets().first()->timestamp() - msInMonth;
+                        qreal min = series->sets().first()->timestamp() - msInMonth;
-                        qreal max = series->candlestickSets().last()->timestamp() + msInMonth;
+                        qreal max = series->sets().last()->timestamp() + msInMonth;
                         QDateTime minDateTime = QDateTime::fromMSecsSinceEpoch(min);
                         QDateTime maxDateTime = QDateTime::fromMSecsSinceEpoch(max);
                     }
                 } else {
                     QCandlestickSeries *s = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
-                    for (int i = 0; i < s->candlestickSets().count(); ++i) {
+                    for (int i = 0; i < s->sets().count(); ++i) {
-                        QCandlestickSet *set = randomSet(s->candlestickSets().at(i)->timestamp());
+                        QCandlestickSet *set = randomSet(s->sets().at(i)->timestamp());
                         series->append(set);
                     }
                 }
                     QDateTime dateTime;
                     if (series->count()) {
-                        dateTime.setMSecsSinceEpoch(series->candlestickSets().last()->timestamp());
+                        dateTime.setMSecsSinceEpoch(series->sets().last()->timestamp());
                         dateTime = dateTime.addMonths(1);
                     } else {
                         dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), 1, 1));
                     QDateTime dateTime;
                     if (series->count()) {
-                        dateTime.setMSecsSinceEpoch(series->candlestickSets().first()->timestamp());
+                        dateTime.setMSecsSinceEpoch(series->sets().first()->timestamp());
                         dateTime = dateTime.addMonths(-1);
                     } else {
                         dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), 1, 1));
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
-                    if (series->candlestickSets().isEmpty())
+                    if (series->sets().isEmpty())
                         qDebug() << "Create a set first";
                     else
-                        series->remove(series->candlestickSets().last());
+                        series->remove(series->sets().last());
                 }
                 updateAxes();
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
-                    if (series->candlestickSets().isEmpty())
+                    if (series->sets().isEmpty())
                         qDebug() << "Create a set first";
                     else
                         series->clear();
                 series->setName(QStringLiteral("SWMM")); // Series With Model Mapper
                 CustomTableModel *model = qobject_cast<CustomTableModel *>(m_hModelMapper->model());
-                foreach (QCandlestickSet *set, series->candlestickSets())
+                foreach (QCandlestickSet *set, series->sets())
                     model->addRow(set);
-                m_hModelMapper->setFirstCandlestickSetRow(0);
+                m_hModelMapper->setFirstSetRow(0);
-                m_hModelMapper->setLastCandlestickSetRow(model->rowCount() - 1);
+                m_hModelMapper->setLastSetRow(model->rowCount() - 1);
                 m_hModelMapper->setSeries(series);
             }
                 series->setName(QStringLiteral("S1"));
                 m_hModelMapper->setSeries(nullptr);
-                m_hModelMapper->setFirstCandlestickSetRow(-1);
+                m_hModelMapper->setFirstSetRow(-1);
-                m_hModelMapper->setLastCandlestickSetRow(-1);
+                m_hModelMapper->setLastSetRow(-1);
                 CustomTableModel *model = qobject_cast<CustomTableModel *>(m_hModelMapper->model());
                 model->clearRows();

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