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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <private/candlestickchartitem_p.h>
             #include <private/candlestick_p.h>
             #include <private/candlestickdata_p.h>
             #include <private/qcandlestickseries_p.h>
             #include <private/candlestickanimation_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             CandlestickChartItem::CandlestickChartItem(QCandlestickSeries *series, QGraphicsItem *item)
                 : ChartItem(series->d_func(), item),
                   m_series(series),
                   m_seriesIndex(0),
                   m_seriesCount(0),
                   m_timePeriod(0.0),
                   m_animation(nullptr)
             {
                 connect(series, SIGNAL(candlestickSetsAdded(QList<QCandlestickSet *>)),
                         this, SLOT(handleCandlestickSetsAdd(QList<QCandlestickSet *>)));
                 connect(series, SIGNAL(candlestickSetsRemoved(QList<QCandlestickSet *>)),
                         this, SLOT(handleCandlestickSetsRemove(QList<QCandlestickSet *>)));
                 connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleCandlesticksUpdated()));
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutUpdated()));
                 connect(series->d_func(), SIGNAL(updatedCandlesticks()),
                         this, SLOT(handleCandlesticksUpdated()));
                 setZValue(ChartPresenter::CandlestickSeriesZValue);
-                handleCandlestickSetsAdd(m_series->candlestickSets());
+                handleCandlestickSetsAdd(m_series->sets());
             }
             CandlestickChartItem::~CandlestickChartItem()
             {
             }
             void CandlestickChartItem::setAnimation(CandlestickAnimation *animation)
             {
                 m_animation = animation;
                 if (m_animation) {
                     foreach (Candlestick *item, m_candlesticks.values())
                         m_animation->addCandlestick(item);
                     handleDomainUpdated();
                 }
             }
             QRectF CandlestickChartItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void CandlestickChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
                                              QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             void CandlestickChartItem::handleDomainUpdated()
             {
                 if ((domain()->size().width() <= 0) || (domain()->size().height() <= 0))
                     return;
                 // Set bounding rectangle to same as domain size. Add one pixel at the top (-1.0) and the bottom
                 // as 0.0 would snip a bit off from the wick at the grid line.
                 m_boundingRect.setRect(0.0, -1.0, domain()->size().width(), domain()->size().height() + 1.0);
                 foreach (Candlestick *item, m_candlesticks.values()) {
                     item->updateGeometry(domain());
                     if (m_animation)
                         presenter()->startAnimation(m_animation->candlestickAnimation(item));
                 }
             }
             void CandlestickChartItem::handleLayoutUpdated()
             {
                 bool timestampChanged = false;
                 foreach (QCandlestickSet *set, m_candlesticks.keys()) {
                     qreal oldTimestamp = m_candlesticks.value(set)->m_data.m_timestamp;
                     qreal newTimestamp = set->timestamp();
                     if (Q_UNLIKELY(oldTimestamp != newTimestamp)) {
                         removeTimestamp(oldTimestamp);
                         addTimestamp(newTimestamp);
                         timestampChanged = true;
                     }
                 }
                 if (timestampChanged)
                     updateTimePeriod();
                 foreach (Candlestick *item, m_candlesticks.values()) {
                     if (m_animation)
                         m_animation->setAnimationStart(item);
                     item->setTimePeriod(m_timePeriod);
                     item->setMaximumColumnWidth(m_series->maximumColumnWidth());
                     item->setMinimumColumnWidth(m_series->minimumColumnWidth());
                     item->setBodyWidth(m_series->bodyWidth());
                     item->setCapsWidth(m_series->capsWidth());
                     bool dirty = updateCandlestickGeometry(item, item->m_data.m_index);
                     if (dirty && m_animation)
                         presenter()->startAnimation(m_animation->candlestickChangeAnimation(item));
                     else
                         item->updateGeometry(domain());
                 }
             }
             void CandlestickChartItem::handleCandlesticksUpdated()
             {
                 foreach (QCandlestickSet *set, m_candlesticks.keys())
                     updateCandlestickAppearance(m_candlesticks.value(set), set);
             }
             void CandlestickChartItem::handleCandlestickSeriesChange()
             {
                 int seriesIndex = 0;
                 int seriesCount = 0;
                 int index = 0;
                 foreach (QAbstractSeries *series, m_series->chart()->series()) {
                     if (series->type() == QAbstractSeries::SeriesTypeCandlestick) {
                         if (m_series == static_cast<QCandlestickSeries *>(series))
                             seriesIndex = index;
                         index++;
                     }
                 }
                 seriesCount = index;
                 bool changed;
                 if ((m_seriesIndex != seriesIndex) || (m_seriesCount != seriesCount))
                     changed = true;
                 else
                     changed = false;
                 if (changed) {
                     m_seriesIndex = seriesIndex;
                     m_seriesCount = seriesCount;
                     handleDataStructureChanged();
                 }
             }
             void CandlestickChartItem::handleCandlestickSetsAdd(const QList<QCandlestickSet *> &sets)
             {
                 foreach (QCandlestickSet *set, sets) {
                     Candlestick *item = m_candlesticks.value(set, 0);
                     if (item) {
                         qWarning() << "There is already a candlestick for this set in the hash";
                         continue;
                     }
                     item = new Candlestick(set, domain(), this);
                     m_candlesticks.insert(set, item);
                     addTimestamp(set->timestamp());
                     connect(item, SIGNAL(clicked(QCandlestickSet *)),
                             m_series, SIGNAL(clicked(QCandlestickSet *)));
                     connect(item, SIGNAL(hovered(bool, QCandlestickSet *)),
                             m_series, SIGNAL(hovered(bool, QCandlestickSet *)));
                     connect(item, SIGNAL(pressed(QCandlestickSet *)),
                             m_series, SIGNAL(pressed(QCandlestickSet *)));
                     connect(item, SIGNAL(released(QCandlestickSet *)),
                             m_series, SIGNAL(released(QCandlestickSet *)));
                     connect(item, SIGNAL(doubleClicked(QCandlestickSet *)),
                             m_series, SIGNAL(doubleClicked(QCandlestickSet *)));
                     connect(item, SIGNAL(clicked(QCandlestickSet *)), set, SIGNAL(clicked()));
                     connect(item, SIGNAL(hovered(bool, QCandlestickSet *)), set, SIGNAL(hovered(bool)));
                     connect(item, SIGNAL(pressed(QCandlestickSet *)), set, SIGNAL(pressed()));
                     connect(item, SIGNAL(released(QCandlestickSet *)), set, SIGNAL(released()));
                     connect(item, SIGNAL(doubleClicked(QCandlestickSet *)), set, SIGNAL(doubleClicked()));
                 }
                 handleDataStructureChanged();
             }
             void CandlestickChartItem::handleCandlestickSetsRemove(const QList<QCandlestickSet *> &sets)
             {
                 foreach (QCandlestickSet *set, sets) {
                     Candlestick *item = m_candlesticks.value(set);
                     m_candlesticks.remove(set);
                     removeTimestamp(set->timestamp());
                     if (m_animation) {
                         ChartAnimation *animation = m_animation->candlestickAnimation(item);
                         if (animation) {
                             animation->stop();
                             delete animation;
                         }
                     }
                     delete item;
                 }
                 handleDataStructureChanged();
             }
             void CandlestickChartItem::handleDataStructureChanged()
             {
                 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);
                     updateCandlestickAppearance(item, set);
                     item->updateGeometry(domain());
                     if (m_animation)
                         m_animation->addCandlestick(item);
                 }
                 handleDomainUpdated();
             }
             bool CandlestickChartItem::updateCandlestickGeometry(Candlestick *item, int index)
             {
                 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())
                     || (data.m_high != set->high())
                     || (data.m_low != set->low())
                     || (data.m_close != set->close())) {
                     changed = true;
                 }
                 data.m_timestamp = set->timestamp();
                 data.m_open = set->open();
                 data.m_high = set->high();
                 data.m_low = set->low();
                 data.m_close = set->close();
                 data.m_index = index;
                 data.m_maxX = domain()->maxX();
                 data.m_minX = domain()->minX();
                 data.m_maxY = domain()->maxY();
                 data.m_minY = domain()->minY();
                 data.m_series = m_series;
                 data.m_seriesIndex = m_seriesIndex;
                 data.m_seriesCount = m_seriesCount;
                 return changed;
             }
             void CandlestickChartItem::updateCandlestickAppearance(Candlestick *item, QCandlestickSet *set)
             {
                 item->setTimePeriod(m_timePeriod);
                 item->setMaximumColumnWidth(m_series->maximumColumnWidth());
                 item->setMinimumColumnWidth(m_series->minimumColumnWidth());
                 item->setBodyWidth(m_series->bodyWidth());
                 item->setBodyOutlineVisible(m_series->bodyOutlineVisible());
                 item->setCapsWidth(m_series->capsWidth());
                 item->setCapsVisible(m_series->capsVisible());
                 item->setIncreasingColor(m_series->increasingColor());
                 item->setDecreasingColor(m_series->decreasingColor());
                 // Set the decorative issues for the candlestick so that
                 // the brush and pen already defined for the set are kept.
                 if (set->brush() == Qt::NoBrush)
                     item->setBrush(m_series->brush());
                 else
                     item->setBrush(set->brush());
                 if (set->pen() == Qt::NoPen)
                     item->setPen(m_series->pen());
                 else
                     item->setPen(set->pen());
             }
             void CandlestickChartItem::addTimestamp(qreal timestamp)
             {
                 int index = 0;
                 for (int i = m_timestamps.count() - 1; i >= 0; --i) {
                     if (timestamp > m_timestamps.at(i)) {
                         index = i + 1;
                         break;
                     }
                 }
                 m_timestamps.insert(index, timestamp);
             }
             void CandlestickChartItem::removeTimestamp(qreal timestamp)
             {
                 m_timestamps.removeOne(timestamp);
             }
             void CandlestickChartItem::updateTimePeriod()
             {
                 if (m_timestamps.count() == 0) {
                     m_timePeriod = 0;
                     return;
                 }
                 if (m_timestamps.count() == 1) {
                     m_timePeriod = qAbs(domain()->maxX() - domain()->minX());
                     return;
                 }
                 qreal timePeriod = qAbs(m_timestamps.at(1) - m_timestamps.at(0));
                 for (int i = 1; i < m_timestamps.count(); ++i) {
                     timePeriod = qMin(timePeriod, qAbs(m_timestamps.at(i) - m_timestamps.at(i - 1)));
                 }
                 m_timePeriod = timePeriod;
             }
             #include "moc_candlestickchartitem_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QCandlestickModelMapper>
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <QtCore/QAbstractItemModel>
             #include <private/qcandlestickmodelmapper_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QCandlestickModelMapper
                 \since 5.8
                 \inmodule Qt Charts
                 \brief Abstract model mapper class for candlestick series.
                 Model mappers allow the use of a QAbstractItemModel-derived model as a data source for a chart
                 series, creating a connection between a QCandlestickSeries and the model object. A model mapper
                 maintains an equal size across all \l {QCandlestickSet} {QCandlestickSets}.
                 \note The model used must support adding and removing rows/columns and modifying the data of the
                 cells.
             */
             /*!
                 \property QCandlestickModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \property QCandlestickModelMapper::series
                 \brief Defines the QCandlestickSeries object that is used by the mapper.
                 \note All data in the series is discarded when it is set to the mapper. When a new series is
                 specified, the old series is disconnected (preserving its data).
             */
             /*!
                 \fn Qt::Orientation QCandlestickModelMapper::orientation() const
                 Returns the orientation that is used when QCandlestickModelMapper accesses the model. This
                 determines whether the consecutive values of the set are read from rows (Qt::Horizontal) or from
                 columns (Qt::Vertical).
             */
             /*!
                 \fn void QCandlestickModelMapper::modelReplaced()
                 \brief Emitted when the model, to which the mapper is connected, has changed.
                 \sa model
             */
             /*!
                 \fn void QCandlestickModelMapper::seriesReplaced()
                 \brief Emitted when the series to which mapper is connected to has changed.
                 \sa series
             */
             /*!
                 Constructs a model mapper object as a child of \a parent.
             */
             QCandlestickModelMapper::QCandlestickModelMapper(QObject *parent)
                 : QObject(parent),
                   d_ptr(new QCandlestickModelMapperPrivate(this))
             {
             }
             void QCandlestickModelMapper::setModel(QAbstractItemModel *model)
             {
                 Q_D(QCandlestickModelMapper);
                 if (d->m_model == model)
                     return;
                 if (d->m_model)
                     disconnect(d->m_model, 0, d, 0);
                 d->m_model = model;
                 emit modelReplaced();
                 if (!d->m_model)
                     return;
                 d->initializeCandlestickFromModel();
                 // connect signals from the model
                 connect(d->m_model, SIGNAL(modelReset()), d, SLOT(initializeCandlestickFromModel()));
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex, QModelIndex)),
                         d, SLOT(modelDataUpdated(QModelIndex, QModelIndex)));
                 connect(d->m_model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
                         d, SLOT(modelHeaderDataUpdated(Qt::Orientation, int, int)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex, int, int)),
                         d, SLOT(modelRowsInserted(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(modelColumnsInserted(QModelIndex, int, int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),
                         d, SLOT(modelColumnsRemoved(QModelIndex, int, int)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(modelDestroyed()));
             }
             QAbstractItemModel *QCandlestickModelMapper::model() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_model;
             }
             void QCandlestickModelMapper::setSeries(QCandlestickSeries *series)
             {
                 Q_D(QCandlestickModelMapper);
                 if (d->m_series == series)
                     return;
                 if (d->m_series)
                     disconnect(d->m_series, 0, d, 0);
                 d->m_series = series;
                 emit seriesReplaced();
                 if (!d->m_series)
                     return;
                 d->initializeCandlestickFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(candlestickSetsAdded(QList<QCandlestickSet *>)),
                         d, SLOT(candlestickSetsAdded(QList<QCandlestickSet *>)));
                 connect(d->m_series, SIGNAL(candlestickSetsRemoved(QList<QCandlestickSet*>)),
                         d, SLOT(candlestickSetsRemoved(QList<QCandlestickSet *>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(seriesDestroyed()));
             }
             QCandlestickSeries *QCandlestickModelMapper::series() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_series;
             }
             /*!
                 Sets the row/column of the model that contains the \a timestamp values of the sets in the
                 series. Default value is -1 (invalid mapping).
             */
             void QCandlestickModelMapper::setTimestamp(int timestamp)
             {
                 Q_D(QCandlestickModelMapper);
                 timestamp = qMax(timestamp, -1);
                 if (d->m_timestamp == timestamp)
                     return;
                 d->m_timestamp = timestamp;
                 emit d->timestampChanged();
                 d->initializeCandlestickFromModel();
             }
             /*!
                 Returns the row/column of the model that contains the timestamp values of the sets in the
                 series. Default value is -1 (invalid mapping).
             */
             int QCandlestickModelMapper::timestamp() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_timestamp;
             }
             /*!
                 Sets the row/column of the model that contains the \a open values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             void QCandlestickModelMapper::setOpen(int open)
             {
                 Q_D(QCandlestickModelMapper);
                 open = qMax(open, -1);
                 if (d->m_open == open)
                     return;
                 d->m_open = open;
                 emit d->openChanged();
                 d->initializeCandlestickFromModel();
             }
             /*!
                 Returns the row/column of the model that contains the open values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             int QCandlestickModelMapper::open() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_open;
             }
             /*!
                 Sets the row/column of the model that contains the \a high values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             void QCandlestickModelMapper::setHigh(int high)
             {
                 Q_D(QCandlestickModelMapper);
                 high = qMax(high, -1);
                 if (d->m_high == high)
                     return;
                 d->m_high = high;
                 emit d->highChanged();
                 d->initializeCandlestickFromModel();
             }
             /*!
                 Returns the row/column of the model that contains the high values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             int QCandlestickModelMapper::high() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_high;
             }
             /*!
                 Sets the row/column of the model that contains the \a low values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             void QCandlestickModelMapper::setLow(int low)
             {
                 Q_D(QCandlestickModelMapper);
                 low = qMax(low, -1);
                 if (d->m_low == low)
                     return;
                 d->m_low = low;
                 emit d->lowChanged();
                 d->initializeCandlestickFromModel();
             }
             /*!
                 Returns the row/column of the model that contains the low values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             int QCandlestickModelMapper::low() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_low;
             }
             /*!
                 Sets the row/column of the model that contains the \a close values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             void QCandlestickModelMapper::setClose(int close)
             {
                 Q_D(QCandlestickModelMapper);
                 close = qMax(close, -1);
                 if (d->m_close == close)
                     return;
                 d->m_close = close;
                 emit d->closeChanged();
                 d->initializeCandlestickFromModel();
             }
             /*!
                 Returns the row/column of the model that contains the close values of the sets in the series.
                 Default value is -1 (invalid mapping).
             */
             int QCandlestickModelMapper::close() const
             {
                 Q_D(const QCandlestickModelMapper);
                 return d->m_close;
             }
             /*!
                 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;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             QCandlestickModelMapperPrivate::QCandlestickModelMapperPrivate(QCandlestickModelMapper *q)
                 : QObject(q),
                   m_model(nullptr),
                   m_series(nullptr),
                   m_timestamp(-1),
                   m_open(-1),
                   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)
             {
             }
             void QCandlestickModelMapperPrivate::initializeCandlestickFromModel()
             {
                 if (!m_model || !m_series)
                     return;
                 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);
                     QModelIndex lowIndex = candlestickModelIndex(i, m_low);
                     QModelIndex closeIndex = candlestickModelIndex(i, m_close);
                     if (timestampIndex.isValid()
                         && openIndex.isValid()
                         && highIndex.isValid()
                         && lowIndex.isValid()
                         && closeIndex.isValid()) {
                         QCandlestickSet *set = new QCandlestickSet();
                         set->setTimestamp(m_model->data(timestampIndex, Qt::DisplayRole).toReal());
                         set->setOpen(m_model->data(openIndex, Qt::DisplayRole).toReal());
                         set->setHigh(m_model->data(highIndex, Qt::DisplayRole).toReal());
                         set->setLow(m_model->data(lowIndex, Qt::DisplayRole).toReal());
                         set->setClose(m_model->data(closeIndex, Qt::DisplayRole).toReal());
                         connect(set, SIGNAL(timestampChanged()), this, SLOT(candlestickSetChanged()));
                         connect(set, SIGNAL(openChanged()), this, SLOT(candlestickSetChanged()));
                         connect(set, SIGNAL(highChanged()), this, SLOT(candlestickSetChanged()));
                         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);
             }
             void QCandlestickModelMapperPrivate::modelDataUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_Q(QCandlestickModelMapper);
                 if (!m_model || !m_series)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 for (int row = topLeft.row(); row <= bottomRight.row(); ++row) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); ++column) {
                         index = topLeft.sibling(row, column);
                         QCandlestickSet *set = candlestickSet(index);
                         if (set) {
                             int pos = (q->orientation() == Qt::Vertical) ? row : column;
                             if (pos == m_timestamp)
                                 set->setTimestamp(m_model->data(index).toReal());
                             else if (pos == m_open)
                                 set->setOpen(m_model->data(index).toReal());
                             else if (pos == m_high)
                                 set->setHigh(m_model->data(index).toReal());
                             else if (pos == m_low)
                                 set->setLow(m_model->data(index).toReal());
                             else if (pos == m_close)
                                 set->setClose(m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QCandlestickModelMapperPrivate::modelHeaderDataUpdated(Qt::Orientation orientation, int first,
                                                                         int last)
             {
                 Q_UNUSED(orientation);
                 Q_UNUSED(first);
                 Q_UNUSED(last);
             }
             void QCandlestickModelMapperPrivate::modelRowsInserted(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_Q(QCandlestickModelMapper);
                 if (m_modelSignalsBlock)
                     return;
                 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);
             }
             void QCandlestickModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_Q(QCandlestickModelMapper);
                 if (m_modelSignalsBlock)
                     return;
                 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);
             }
             void QCandlestickModelMapperPrivate::modelColumnsInserted(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_Q(QCandlestickModelMapper);
                 if (m_modelSignalsBlock)
                     return;
                 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);
             }
             void QCandlestickModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_Q(QCandlestickModelMapper);
                 if (m_modelSignalsBlock)
                     return;
                 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);
             }
             void QCandlestickModelMapperPrivate::modelDestroyed()
             {
                 m_model = 0;
             }
             void QCandlestickModelMapperPrivate::candlestickSetsAdded(const QList<QCandlestickSet *> &sets)
             {
                 Q_Q(QCandlestickModelMapper);
                 if (m_seriesSignalsBlock)
                     return;
                 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());
                     m_model->setData(candlestickModelIndex(section, m_low), sets.at(i)->low());
                     m_model->setData(candlestickModelIndex(section, m_close), sets.at(i)->close());
                 }
                 blockModelSignals(false);
                 initializeCandlestickFromModel();
             }
             void QCandlestickModelMapperPrivate::candlestickSetsRemoved(const QList<QCandlestickSet *> &sets)
             {
                 Q_Q(QCandlestickModelMapper);
                 if (m_seriesSignalsBlock)
                     return;
                 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();
             }
             void QCandlestickModelMapperPrivate::candlestickSetChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 QCandlestickSet *set = qobject_cast<QCandlestickSet *>(QObject::sender());
                 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());
                 m_model->setData(candlestickModelIndex(section, m_open), set->open());
                 m_model->setData(candlestickModelIndex(section, m_high), set->high());
                 m_model->setData(candlestickModelIndex(section, m_low), set->low());
                 m_model->setData(candlestickModelIndex(section, m_close), set->close());
                 blockModelSignals(false);
             }
             void QCandlestickModelMapperPrivate::seriesDestroyed()
             {
                 m_series = 0;
             }
             QCandlestickSet *QCandlestickModelMapperPrivate::candlestickSet(QModelIndex index)
             {
                 Q_Q(QCandlestickModelMapper);
                 if (!index.isValid())
                     return 0;
                 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)
                     return QModelIndex(); // invalid
                 if (q->orientation() == Qt::Vertical)
                     return m_model->index(pos, section);
                 else
                     return m_model->index(section, pos);
             }
             void QCandlestickModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently candlestickchart needs to be fully recalculated when change is made.
                 initializeCandlestickFromModel();
             }
             void QCandlestickModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // Currently candlestickchart needs to be fully recalculated when change is made.
                 initializeCandlestickFromModel();
             }
             void QCandlestickModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QCandlestickModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             #include "moc_qcandlestickmodelmapper.cpp"
             #include "moc_qcandlestickmodelmapper_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCANDLESTICKMODELMAPPER_H
             #define QCANDLESTICKMODELMAPPER_H
             #include <QtCharts/QChartGlobal>
             #include <QtCore/QObject>
             QT_BEGIN_NAMESPACE
             class QAbstractItemModel;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class QCandlestickModelMapperPrivate;
             class QCandlestickSeries;
             class QT_CHARTS_EXPORT QCandlestickModelMapper : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelReplaced)
                 Q_PROPERTY(QCandlestickSeries *series READ series WRITE setSeries NOTIFY seriesReplaced)
             public:
                 explicit QCandlestickModelMapper(QObject *parent = nullptr);
                 void setModel(QAbstractItemModel *model);
                 QAbstractItemModel *model() const;
                 void setSeries(QCandlestickSeries *series);
                 QCandlestickSeries *series() const;
                 virtual Qt::Orientation orientation() const = 0;
             Q_SIGNALS:
                 void modelReplaced();
                 void seriesReplaced();
             protected:
                 void setTimestamp(int timestamp);
                 int timestamp() const;
                 void setOpen(int open);
                 int open() const;
                 void setHigh(int high);
                 int high() const;
                 void setLow(int low);
                 int low() const;
                 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;
                 Q_DECLARE_PRIVATE(QCandlestickModelMapper)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCANDLESTICKMODELMAPPER_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QCANDLESTICKMODELMAPPER_P_H
             #define QCANDLESTICKMODELMAPPER_P_H
             #include <QtCharts/QCandlestickModelMapper>
             #include <QtCore/QObject>
             QT_BEGIN_NAMESPACE
             class QModelIndex;
             QT_END_NAMESPACE
             QT_CHARTS_BEGIN_NAMESPACE
             class QCandlestickSet;
             class QCandlestickModelMapperPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QCandlestickModelMapperPrivate(QCandlestickModelMapper *q);
             Q_SIGNALS:
                 void timestampChanged();
                 void openChanged();
                 void highChanged();
                 void lowChanged();
                 void closeChanged();
-                void firstCandlestickSetSectionChanged();
+                void firstSetSectionChanged();
-                void lastCandlestickSetSectionChanged();
+                void lastSetSectionChanged();
             private Q_SLOTS:
                 void initializeCandlestickFromModel();
                 // for the model
                 void modelDataUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last);
                 void modelRowsInserted(QModelIndex parent, int start, int end);
                 void modelRowsRemoved(QModelIndex parent, int start, int end);
                 void modelColumnsInserted(QModelIndex parent, int start, int end);
                 void modelColumnsRemoved(QModelIndex parent, int start, int end);
                 void modelDestroyed();
                 // for the series
                 void candlestickSetsAdded(const QList<QCandlestickSet *> &sets);
                 void candlestickSetsRemoved(const QList<QCandlestickSet *> &sets);
                 void candlestickSetChanged();
                 void seriesDestroyed();
             private:
                 QCandlestickSet *candlestickSet(QModelIndex index);
                 QModelIndex candlestickModelIndex(int section, int pos);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
                 void blockModelSignals(bool block = true);
                 void blockSeriesSignals(bool block = true);
             private:
                 QAbstractItemModel *m_model;
                 QCandlestickSeries *m_series;
                 int m_timestamp;
                 int m_open;
                 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;
             private:
                 QCandlestickModelMapper *q_ptr;
                 Q_DECLARE_PUBLIC(QCandlestickModelMapper)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCANDLESTICKMODELMAPPER_P_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QCandlestickLegendMarker>
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <QtCharts/QValueAxis>
             #include <QtCore/QDateTime>
             #include <private/candlestickanimation_p.h>
             #include <private/candlestickchartitem_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/qcandlestickseries_p.h>
             #include <private/qcandlestickset_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QCandlestickSeries
                 \since 5.8
                 \inmodule Qt Charts
                 \brief Series for creating a candlestick chart.
                 QCandlestickSeries represents a series of data shown as candlesticks. The purpose of this class
                 is to act as a container for single candlestick items. Each item is drawn to its own category
                 when using QBarCategoryAxis. QDateTimeAxis and QValueAxis can be used as alternatives to
                 QBarCategoryAxis. In this case, each candlestick item is drawn according to its timestamp value.
                 \note The timestamps must be unique within a QCandlestickSeries. When using QBarCategoryAxis,
                 only the first one of the candlestick items sharing a timestamp is drawn. If the chart includes
                 multiple instances of QCandlestickSeries, items from different series sharing a timestamp are
                 drawn to the same category. When using QValueAxis or QDateTimeAxis, candlestick items sharing a
                 timestamp will overlap each other.
                 See the \l {Candlestick Chart Example} {candlestick chart example} to learn how to create
                 a candlestick chart.
                 \image examples_candlestickchart.png
                 \sa QCandlestickSet, QBarCategoryAxis, QDateTimeAxis, QValueAxis
             */
             /*!
                 \qmltype CandlestickSeries
                 \since 2.2
                 \instantiates QCandlestickSeries
                 \inqmlmodule QtCharts
                 \inherits AbstractSeries
                 \brief Series for creating a candlestick chart.
                 CandlestickSeries represents a series of data shown as candlesticks. The purpose of this class
                 is to act as a container for single candlestick items. Each item is drawn to its own category
                 when using BarCategoryAxis. DateTimeAxis and ValueAxis can be used as an alternative to
                 BarCategoryAxis. In this case each candlestick item is drawn according to its timestamp value.
                 \note The timestamps must be unique within a CandlestickSeries. When using BarCategoryAxis, only
                 the first one of the candlestick items sharing a timestamp is drawn. If the chart includes
                 multiple instances of CandlestickSeries, items from different series sharing a timestamp are
                 drawn to the same category. When using ValueAxis or DateTimeAxis, candlestick items sharing a
                 timestamp will overlap each other.
                 The following QML shows how to create a simple candlestick chart:
                 \code
                 import QtQuick 2.5
                 import QtCharts 2.2
                 ChartView {
                     title: "Candlestick Series"
                     width: 400
                     height: 300
                     CandlestickSeries {
                         name: "Acme Ltd."
                         increasingColor: "green"
                         decreasingColor: "red"
                         CandlestickSet { timestamp: 1435708800000; open: 690; high: 694; low: 599; close: 660 }
                         CandlestickSet { timestamp: 1435795200000; open: 669; high: 669; low: 669; close: 669 }
                         CandlestickSet { timestamp: 1436140800000; open: 485; high: 623; low: 485; close: 600 }
                         CandlestickSet { timestamp: 1436227200000; open: 589; high: 615; low: 377; close: 569 }
                         CandlestickSet { timestamp: 1436313600000; open: 464; high: 464; low: 254; close: 254 }
                     }
                 }
                 \endcode
                 \beginfloatleft
                 \image examples_qmlcandlestick.png
                 \endfloat
                 \clearfloat
                 \sa CandlestickSet, BarCategoryAxis, DateTimeAxis, ValueAxis
             */
             /*!
                 \property QCandlestickSeries::count
                 \brief The count of sets in series.
             */
             /*!
                 \qmlproperty int CandlestickSeries::count
                 The count of sets in series.
             */
             /*!
                 \property QCandlestickSeries::maximumColumnWidth
                 \brief The maximum width of the candlestick items in pixels. Setting a negative value means
                 there is no maximum width. All negative values are converted to -1.0.
             */
             /*!
                 \qmlproperty qreal CandlestickSeries::maximumColumnWidth
                 \brief The maximum width of the candlestick items in pixels. Setting a negative value means
                 there is no maximum width. All negative values are converted to -1.0.
             */
             /*!
                 \property QCandlestickSeries::minimumColumnWidth
                 \brief The minimum width of the candlestick items in pixels. Setting a negative value means
                 there is no minimum width. All negative values are converted to -1.0.
             */
             /*!
                 \qmlproperty qreal CandlestickSeries::minimumColumnWidth
                 \brief The minimum width of the candlestick items in pixels. Setting a negative value means
                 there is no minimum width. All negative values are converted to -1.0.
             */
             /*!
                 \property QCandlestickSeries::bodyWidth
                 \brief The width of the candlestick items.
                 The value signifies the relative width of the candlestick item inside its own slot, in the range
 .0 to 1.0. Values outside this range are clamped to 0.0 or 1.0.
             */
             /*!
                 \qmlproperty qreal CandlestickSeries::bodyWidth
                 \brief The width of the candlestick items.
                 The value signifies the relative width of the candlestick item inside its own slot, in the range
 .0 to 1.0. Values outside this range are clamped to 0.0 or 1.0.
             */
             /*!
                 \property QCandlestickSeries::bodyOutlineVisible
                 \brief The visibility of the candlestick body outlines.
             */
             /*!
                 \qmlproperty bool CandlestickSeries::bodyOutlineVisible
                 \brief The visibility of the candlestick body outlines.
             */
             /*!
                 \property QCandlestickSeries::capsWidth
                 \brief The width of the caps.
                 The value signifies the relative width of the caps inside its own candlestick, in the range 0.0
                 to 1.0. Values outside this range are clamped to 0.0 or 1.0.
             */
             /*!
                 \qmlproperty qreal CandlestickSeries::capsWidth
                 \brief The width of the caps.
                 The value signifies the relative width of the caps inside its own candlestick, in the range 0.0
                 to 1.0. Values outside this range are clamped to 0.0 or 1.0.
             */
             /*!
                 \property QCandlestickSeries::capsVisible
                 \brief The visibility of the caps.
             */
             /*!
                 \qmlproperty bool CandlestickSeries::capsVisible
                 \brief The visibility of the caps.
             */
             /*!
                 \property QCandlestickSeries::increasingColor
                 \brief The color of the increasing candlestick item body. Candlestick is \e increasing when its
                 close value is higher than the open value. By default this property is set to brush color.
                 Default color is used also when the property is set to an invalid color value.
             */
             /*!
                 \qmlproperty QColor CandlestickSeries::increasingColor
                 \brief The color of the increasing candlestick item body. Candlestick is \e increasing when its
                 close value is higher than the open value. By default this property is set to brush color.
                 Default color is used also when the property is set to an invalid color value.
             */
             /*!
                 \property QCandlestickSeries::decreasingColor
                 \brief The color of the decreasing candlestick item body. Candlestick is \e decreasing when its
                 open value is higher than the close value. By default this property is set to brush color with
                 alpha channel set to 128. Default color is used also when the property is set to an invalid
                 color value.
             */
             /*!
                 \qmlproperty QColor CandlestickSeries::decreasingColor
                 \brief The color of the decreasing candlestick item body. Candlestick is \e decreasing when its
                 open value is higher than the close value. By default this property is set to brush color with
                 alpha channel set to 128. Default color is used also when the property is set to an invalid
                 color value.
             */
             /*!
                 \property QCandlestickSeries::brush
                 \brief The brush of the candlestick items.
             */
             /*!
                 \property QCandlestickSeries::pen
                 \brief The pen of the candlestick items.
             */
             /*!
                 \qmlproperty QString CandlestickSeries::brushFilename
                 \brief The name of the file used as a brush for the series.
             */
             /*!
                 \fn void QCandlestickSeries::clicked(QCandlestickSet *set)
                 \brief Emitted when a \a set is clicked (pressed and released) on the chart.
             */
             /*!
                 \qmlsignal CandlestickSeries::clicked(CandlestickSet set)
                 \brief Emitted when a \a set is clicked (pressed and released) on the chart.
                 The corresponding signal handler is \c {onClicked}.
             */
             /*!
                 \fn void QCandlestickSeries::hovered(bool status, QCandlestickSet *set)
                 \brief Emitted when there is change in hover \a status over the \a set.
             */
             /*!
                 \qmlsignal CandlestickSeries::hovered(bool status, CandlestickSet set)
                 \brief Emitted when there is change in hover \a status over the \a set.
                 The corresponding signal handler is \c {onHovered}.
             */
             /*!
                 \fn void QCandlestickSeries::pressed(QCandlestickSet *set)
                 \brief Emitted when a \a set is pressed on the chart.
             */
             /*!
                 \qmlsignal CandlestickSeries::pressed(CandlestickSet set)
                 \brief Emitted when a \a set is pressed on the chart.
                 The corresponding signal handler is \c {onPressed}.
             */
             /*!
                 \fn void QCandlestickSeries::released(QCandlestickSet *set)
                 \brief Emitted when a \a set is released on the chart.
             */
             /*!
                 \qmlsignal CandlestickSeries::released(CandlestickSet set)
                 \brief Emitted when a \a set is released on the chart.
                 The corresponding signal handler is \c {onReleased}.
             */
             /*!
                 \fn void QCandlestickSeries::doubleClicked(QCandlestickSet *set)
                 \brief Emitted when a \a set is double-clicked on the chart.
             */
             /*!
                 \qmlsignal CandlestickSeries::doubleClicked(CandlestickSet set)
                 \brief Emitted when a \a set is double-clicked on the chart.
                 The corresponding signal handler is \c {onDoubleClicked}.
             */
             /*!
                 \fn void QCandlestickSeries::candlestickSetsAdded(const QList<QCandlestickSet *> &sets)
                 \brief Emitted when new \a sets are added to the series.
             */
             /*!
                 \qmlsignal CandlestickSeries::candlestickSetsAdded(list<CandlestickSet> sets)
                 \brief Emitted when new \a sets are added to the series.
                 The corresponding signal handler is \c {onCandlestickSetsAdded}.
             */
             /*!
                 \fn void QCandlestickSeries::candlestickSetsRemoved(const QList<QCandlestickSet *> &sets)
                 \brief Emitted when \a sets are removed from the series.
             */
             /*!
                 \qmlsignal CandlestickSeries::candlestickSetsRemoved(list<CandlestickSet> sets)
                 \brief Emitted when \a sets are removed from the series.
                 The corresponding signal handler is \c {onCandlestickSetsRemoved}.
             */
             /*!
                 \fn void QCandlestickSeries::countChanged()
                 \brief Emitted when there is a change in the count of candlestick items in the series.
                 \sa count
             */
             /*!
                 \qmlsignal CandlestickSeries::countChanged()
                 \brief Emitted when there is a change in the count of candlestick items in the series.
                 \sa count
                 The corresponding signal handler is \c {onCountChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::maximumColumnWidthChanged()
                 \brief Emitted when there is a change in the maximum column width of candlestick items.
                 \sa maximumColumnWidth
             */
             /*!
                 \qmlsignal CandlestickSeries::maximumColumnWidthChanged()
                 \brief Emitted when there is a change in the maximum column width of candlestick items.
                 \sa maximumColumnWidth
                 The corresponding signal handler is \c {onMaximumColumnWidthChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::minimumColumnWidthChanged()
                 \brief Emitted when there is a change in the minimum column width of candlestick items.
                 \sa minimumColumnWidth
             */
             /*!
                 \qmlsignal CandlestickSeries::minimumColumnWidthChanged()
                 \brief Emitted when there is a change in the minimum column width of candlestick items.
                 \sa minimumColumnWidth
                 The corresponding signal handler is \c {onMinimumColumnWidthChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::bodyWidthChanged()
                 \brief Emitted when the candlestick item width is changed.
                 \sa bodyWidth
             */
             /*!
                 \qmlsignal CandlestickSeries::bodyWidthChanged()
                 \brief Emitted when the candlestick item width is changed.
                 \sa bodyWidth
                 The corresponding signal handler is \c {onBodyWidthChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::bodyOutlineVisibilityChanged()
                 \brief Emitted when the visibility of the candlestick item body outline is changed.
                 \sa bodyOutlineVisible
             */
             /*!
                 \qmlsignal CandlestickSeries::bodyOutlineVisibilityChanged()
                 \brief Emitted when the visibility of the candlestick item body outline is changed.
                 \sa bodyOutlineVisible
                 The corresponding signal handler is \c {onBodyOutlineVisibilityChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::capsWidthChanged()
                 \brief Emitted when the candlestick item caps width is changed.
                 \sa capsWidth
             */
             /*!
                 \qmlsignal CandlestickSeries::capsWidthChanged()
                 \brief Emitted when the candlestick item caps width is changed.
                 \sa capsWidth
                 The corresponding signal handler is \c {onCapsWidthChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::capsVisibilityChanged()
                 \brief Emitted when the visibility of the candlestick item caps is changed.
                 \sa capsVisible
             */
             /*!
                 \qmlsignal CandlestickSeries::capsVisibilityChanged()
                 \brief Emitted when the visibility of the candlestick item caps is changed.
                 \sa capsVisible
                 The corresponding signal handler is \c {onCapsVisibilityChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::increasingColorChanged()
                 \brief Emitted when the candlestick item increasing color is changed.
                 \sa increasingColor
             */
             /*!
                 \qmlsignal CandlestickSeries::increasingColorChanged()
                 \brief Emitted when the candlestick item increasing color is changed.
                 \sa increasingColor
                 The corresponding signal handler is \c {onIncreasingColorChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::decreasingColorChanged()
                 \brief Emitted when the candlestick item decreasing color is changed.
                 \sa decreasingColor
             */
             /*!
                 \qmlsignal CandlestickSeries::decreasingColorChanged()
                 \brief Emitted when the candlestick item decreasing color is changed.
                 \sa decreasingColor
                 The corresponding signal handler is \c {onDecreasingColorChanged}.
             */
             /*!
                 \fn void QCandlestickSeries::brushChanged()
                 \brief Emitted when the candlestick item brush is changed.
                 \sa brush
             */
             /*!
                 \fn void QCandlestickSeries::penChanged()
                 \brief Emitted when the candlestick item pen is changed.
                 \sa pen
             */
             /*!
                 Constructs an empty QCandlestickSeries. The \a parent is optional.
             */
             QCandlestickSeries::QCandlestickSeries(QObject *parent)
                 : QAbstractSeries(*new QCandlestickSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destroys the series. Removes the series from the chart.
             */
             QCandlestickSeries::~QCandlestickSeries()
             {
                 Q_D(QCandlestickSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Adds a single set to the series. Takes ownership of the \a set. If the set is \e null or is
                 already in the series, it won't be appended.
                 Returns \c true if appending succeeded, \c false otherwise.
             */
             bool QCandlestickSeries::append(QCandlestickSet *set)
             {
                 QList<QCandlestickSet *> sets;
                 sets.append(set);
                 return append(sets);
             }
             /*!
                 Removes a single set from the series.
                 Returns \c true if the \a set is successfully deleted, \c false otherwise.
             */
             bool QCandlestickSeries::remove(QCandlestickSet *set)
             {
                 QList<QCandlestickSet *> sets;
                 sets.append(set);
                 return remove(sets);
             }
             /*!
                 Adds a list of sets to the series. Takes ownership of the \a sets. If any of the sets are
                 \e null, already appended to the series, or the list contains duplicated sets, nothing is
                 appended.
                 Returns \c true if all sets were appended successfully, \c false otherwise.
             */
             bool QCandlestickSeries::append(const QList<QCandlestickSet *> &sets)
             {
                 Q_D(QCandlestickSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit candlestickSetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes a list of sets from the series. If any of the \a sets are \e null, already removed from
                 the series, or the list contains duplicated sets, nothing is removed.
                 Returns \c true if all sets were removed successfully, \c false otherwise.
             */
             bool QCandlestickSeries::remove(const QList<QCandlestickSet *> &sets)
             {
                 Q_D(QCandlestickSeries);
                 bool success = d->remove(sets);
                 if (success) {
                     emit candlestickSetsRemoved(sets);
                     emit countChanged();
                     foreach (QCandlestickSet *set, sets)
                         set->deleteLater();
                 }
                 return success;
             }
             /*!
                 Inserts a set to the series at \a index position. Takes ownership of the \a set. If the set is
                 \e null or already in the series, it won't be appended.
                 Returns \c true if inserting succeeded, \c false otherwise.
             */
             bool QCandlestickSeries::insert(int index, QCandlestickSet *set)
             {
                 Q_D(QCandlestickSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QCandlestickSet *> sets;
                     sets.append(set);
                     emit candlestickSetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the set object.
                 Returns \c true if take was successful, \c false otherwise.
                 \note The series remains as the set's parent object. You must set the parent object to take full
                 ownership.
             */
             bool QCandlestickSeries::take(QCandlestickSet *set)
             {
                 Q_D(QCandlestickSeries);
                 QList<QCandlestickSet *> sets;
                 sets.append(set);
                 bool success = d->remove(sets);
                 if (success) {
                     emit candlestickSetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all sets from the series, and deletes them.
             */
             void QCandlestickSeries::clear()
             {
                 Q_D(QCandlestickSeries);
-                QList<QCandlestickSet *> sets = candlestickSets();
+                QList<QCandlestickSet *> sets = this->sets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit candlestickSetsRemoved(sets);
                     emit countChanged();
                     foreach (QCandlestickSet *set, sets)
                         set->deleteLater();
                 }
             }
             /*!
                 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;
             }
             /*!
                 Returns the number of the sets in the series.
             */
             int QCandlestickSeries::count() const
             {
-                return candlestickSets().count();
+                return sets().count();
             }
             /*!
                 Returns the type of the series (QAbstractSeries::SeriesTypeCandlestick).
             */
             QAbstractSeries::SeriesType QCandlestickSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeCandlestick;
             }
             void QCandlestickSeries::setMaximumColumnWidth(qreal maximumColumnWidth)
             {
                 Q_D(QCandlestickSeries);
                 if (maximumColumnWidth < 0.0 && maximumColumnWidth != -1.0)
                     maximumColumnWidth = -1.0;
                 if (d->m_maximumColumnWidth == maximumColumnWidth)
                     return;
                 d->m_maximumColumnWidth = maximumColumnWidth;
                 emit d->updatedLayout();
                 emit maximumColumnWidthChanged();
             }
             qreal QCandlestickSeries::maximumColumnWidth() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_maximumColumnWidth;
             }
             void QCandlestickSeries::setMinimumColumnWidth(qreal minimumColumnWidth)
             {
                 Q_D(QCandlestickSeries);
                 if (minimumColumnWidth < 0.0 && minimumColumnWidth != -1.0)
                     minimumColumnWidth = -1.0;
                 if (d->m_minimumColumnWidth == minimumColumnWidth)
                     return;
                 d->m_minimumColumnWidth = minimumColumnWidth;
                 d->updatedLayout();
                 emit minimumColumnWidthChanged();
             }
             qreal QCandlestickSeries::minimumColumnWidth() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_minimumColumnWidth;
             }
             void QCandlestickSeries::setBodyWidth(qreal bodyWidth)
             {
                 Q_D(QCandlestickSeries);
                 if (bodyWidth < 0.0)
                     bodyWidth = 0.0;
                 else if (bodyWidth > 1.0)
                     bodyWidth = 1.0;
                 if (d->m_bodyWidth == bodyWidth)
                     return;
                 d->m_bodyWidth = bodyWidth;
                 emit d->updatedLayout();
                 emit bodyWidthChanged();
             }
             qreal QCandlestickSeries::bodyWidth() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_bodyWidth;
             }
             void QCandlestickSeries::setBodyOutlineVisible(bool bodyOutlineVisible)
             {
                 Q_D(QCandlestickSeries);
                 if (d->m_bodyOutlineVisible == bodyOutlineVisible)
                     return;
                 d->m_bodyOutlineVisible = bodyOutlineVisible;
                 emit d->updated();
                 emit bodyOutlineVisibilityChanged();
             }
             bool QCandlestickSeries::bodyOutlineVisible() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_bodyOutlineVisible;
             }
             void QCandlestickSeries::setCapsWidth(qreal capsWidth)
             {
                 Q_D(QCandlestickSeries);
                 if (capsWidth < 0.0)
                     capsWidth = 0.0;
                 else if (capsWidth > 1.0)
                     capsWidth = 1.0;
                 if (d->m_capsWidth == capsWidth)
                     return;
                 d->m_capsWidth = capsWidth;
                 emit d->updatedLayout();
                 emit capsWidthChanged();
             }
             qreal QCandlestickSeries::capsWidth() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_capsWidth;
             }
             void QCandlestickSeries::setCapsVisible(bool capsVisible)
             {
                 Q_D(QCandlestickSeries);
                 if (d->m_capsVisible == capsVisible)
                     return;
                 d->m_capsVisible = capsVisible;
                 emit d->updated();
                 emit capsVisibilityChanged();
             }
             bool QCandlestickSeries::capsVisible() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_capsVisible;
             }
             void QCandlestickSeries::setIncreasingColor(const QColor &increasingColor)
             {
                 Q_D(QCandlestickSeries);
                 QColor color;
                 if (increasingColor.isValid()) {
                     color = increasingColor;
                     d->m_customIncreasingColor = true;
                 } else {
                     color = d->m_brush.color();
                     color.setAlpha(128);
                     d->m_customIncreasingColor = false;
                 }
                 if (d->m_increasingColor == color)
                     return;
                 d->m_increasingColor = color;
                 emit d->updated();
                 emit increasingColorChanged();
             }
             QColor QCandlestickSeries::increasingColor() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_increasingColor;
             }
             void QCandlestickSeries::setDecreasingColor(const QColor &decreasingColor)
             {
                 Q_D(QCandlestickSeries);
                 QColor color;
                 if (decreasingColor.isValid()) {
                     color = decreasingColor;
                     d->m_customDecreasingColor = true;
                 } else {
                     color = d->m_brush.color();
                     d->m_customDecreasingColor = false;
                 }
                 if (d->m_decreasingColor == color)
                     return;
                 d->m_decreasingColor = color;
                 emit d->updated();
                 emit decreasingColorChanged();
             }
             QColor QCandlestickSeries::decreasingColor() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_decreasingColor;
             }
             void QCandlestickSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QCandlestickSeries);
                 if (d->m_brush == brush)
                     return;
                 d->m_brush = brush;
                 if (!d->m_customIncreasingColor) {
                     QColor color = d->m_brush.color();
                     color.setAlpha(128);
                     if (d->m_increasingColor != color) {
                         d->m_increasingColor = color;
                         emit increasingColorChanged();
                     }
                 }
                 if (!d->m_customDecreasingColor && d->m_decreasingColor != d->m_brush.color()) {
                     d->m_decreasingColor = d->m_brush.color();
                     emit decreasingColorChanged();
                 }
                 emit d->updated();
                 emit brushChanged();
             }
             QBrush QCandlestickSeries::brush() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_brush;
             }
             void QCandlestickSeries::setPen(const QPen &pen)
             {
                 Q_D(QCandlestickSeries);
                 if (d->m_pen == pen)
                     return;
                 d->m_pen = pen;
                 emit d->updated();
                 emit penChanged();
             }
             QPen QCandlestickSeries::pen() const
             {
                 Q_D(const QCandlestickSeries);
                 return d->m_pen;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             QCandlestickSeriesPrivate::QCandlestickSeriesPrivate(QCandlestickSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_maximumColumnWidth(-1.0),
                   m_minimumColumnWidth(5.0),
                   m_bodyWidth(0.5),
                   m_bodyOutlineVisible(true),
                   m_capsWidth(0.5),
                   m_capsVisible(false),
                   m_increasingColor(QColor(Qt::transparent)),
                   m_decreasingColor(QChartPrivate::defaultBrush().color()),
                   m_customIncreasingColor(false),
                   m_customDecreasingColor(false),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pen(QChartPrivate::defaultPen()),
                   m_animation(nullptr)
             {
             }
             QCandlestickSeriesPrivate::~QCandlestickSeriesPrivate()
             {
                 disconnect(this, 0, 0, 0);
             }
             void QCandlestickSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal maxX(domain()->maxX());
                 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;
                 }
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QCandlestickSeriesPrivate::initializeAxes()
             {
                 foreach (QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         if (axis->orientation() == Qt::Horizontal)
                             populateBarCategories(qobject_cast<QBarCategoryAxis *>(axis));
                     }
                 }
             }
             void QCandlestickSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QCandlestickSeries);
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     const QList<QGradient> gradients = theme->seriesGradients();
                     const QGradient gradient = gradients.at(index % gradients.size());
                     const QBrush brush(ChartThemeManager::colorAt(gradient, 0.5));
                     q->setBrush(brush);
                 }
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen = theme->outlinePen();
                     pen.setCosmetic(true);
                     q->setPen(pen);
                 }
             }
             void QCandlestickSeriesPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QCandlestickSeries);
                 CandlestickChartItem *item = new CandlestickChartItem(q, parent);
                 m_item.reset(item);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
                 if (m_chart) {
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries *)),
                             this, SLOT(handleSeriesChange(QAbstractSeries *)));
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)),
                             this, SLOT(handleSeriesRemove(QAbstractSeries *)));
                     item->handleCandlestickSeriesChange();
                 }
             }
             void QCandlestickSeriesPrivate::initializeAnimations(QChart::AnimationOptions options, int duration,
                                                                  QEasingCurve &curve)
             {
                 CandlestickChartItem *item = static_cast<CandlestickChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (item->animation())
                     item->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::SeriesAnimations))
                     m_animation = new CandlestickAnimation(item, duration, curve);
                 else
                     m_animation = nullptr;
                 item->setAnimation(m_animation);
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             QList<QLegendMarker *> QCandlestickSeriesPrivate::createLegendMarkers(QLegend *legend)
             {
                 Q_Q(QCandlestickSeries);
                 QList<QLegendMarker *> list;
                 return list << new QCandlestickLegendMarker(q, legend);
             }
             QAbstractAxis::AxisType QCandlestickSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 if (orientation == Qt::Horizontal)
                     return QAbstractAxis::AxisTypeBarCategory;
                 if (orientation == Qt::Vertical)
                     return QAbstractAxis::AxisTypeValue;
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             QAbstractAxis* QCandlestickSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 const QAbstractAxis::AxisType axisType = defaultAxisType(orientation);
                 if (axisType == QAbstractAxis::AxisTypeBarCategory)
                     return new QBarCategoryAxis;
                 if (axisType == QAbstractAxis::AxisTypeValue)
                     return new QValueAxis;
                 return 0; // axisType == QAbstractAxis::AxisTypeNoAxis
             }
             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 true;
             }
             bool QCandlestickSeriesPrivate::remove(const QList<QCandlestickSet *> &sets)
             {
                 if (sets.count() == 0)
                     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()));
                 }
                 return true;
             }
             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;
                 return true;
             }
             void QCandlestickSeriesPrivate::handleSeriesChange(QAbstractSeries *series)
             {
                 Q_UNUSED(series);
                 if (m_chart) {
                     CandlestickChartItem *item = static_cast<CandlestickChartItem *>(m_item.data());
                     if (item)
                         item->handleCandlestickSeriesChange();
                 }
             }
             void QCandlestickSeriesPrivate::handleSeriesRemove(QAbstractSeries *series)
             {
                 Q_Q(const QCandlestickSeries);
                 QCandlestickSeries *removedSeries = static_cast<QCandlestickSeries *>(series);
                 if (q == removedSeries && m_animation) {
                     m_animation->stopAll();
                     disconnect(m_chart->d_ptr->m_dataset, 0, removedSeries->d_func(), 0);
                 }
                 if (q != removedSeries) {
                     CandlestickChartItem *item = static_cast<CandlestickChartItem *>(m_item.data());
                     if (item)
                         item->handleCandlestickSeriesChange();
                 }
             }
             void QCandlestickSeriesPrivate::populateBarCategories(QBarCategoryAxis *axis)
             {
                 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);
                     }
                     axis->append(categories);
                 }
             }
             #include "moc_qcandlestickseries.cpp"
             #include "moc_qcandlestickseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCANDLESTICKSERIES_H
             #define QCANDLESTICKSERIES_H
             #include <QtCharts/QAbstractSeries>
             QT_CHARTS_BEGIN_NAMESPACE
             class QCandlestickSeriesPrivate;
             class QCandlestickSet;
             class QT_CHARTS_EXPORT QCandlestickSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(qreal maximumColumnWidth READ maximumColumnWidth WRITE setMaximumColumnWidth NOTIFY maximumColumnWidthChanged)
                 Q_PROPERTY(qreal minimumColumnWidth READ minimumColumnWidth WRITE setMinimumColumnWidth NOTIFY minimumColumnWidthChanged)
                 Q_PROPERTY(qreal bodyWidth READ bodyWidth WRITE setBodyWidth NOTIFY bodyWidthChanged)
                 Q_PROPERTY(bool bodyOutlineVisible READ bodyOutlineVisible WRITE setBodyOutlineVisible NOTIFY bodyOutlineVisibilityChanged)
                 Q_PROPERTY(qreal capsWidth READ capsWidth WRITE setCapsWidth NOTIFY capsWidthChanged)
                 Q_PROPERTY(bool capsVisible READ capsVisible WRITE setCapsVisible NOTIFY capsVisibilityChanged)
                 Q_PROPERTY(QColor increasingColor READ increasingColor WRITE setIncreasingColor NOTIFY increasingColorChanged)
                 Q_PROPERTY(QColor decreasingColor READ decreasingColor WRITE setDecreasingColor NOTIFY decreasingColorChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
             public:
                 explicit QCandlestickSeries(QObject *parent = nullptr);
                 ~QCandlestickSeries();
                 bool append(QCandlestickSet *set);
                 bool remove(QCandlestickSet *set);
                 bool append(const QList<QCandlestickSet *> &sets);
                 bool remove(const QList<QCandlestickSet *> &sets);
                 bool insert(int index, QCandlestickSet *set);
                 bool take(QCandlestickSet *set);
                 void clear();
-                QList<QCandlestickSet *> candlestickSets() const;
+                QList<QCandlestickSet *> sets() const;
                 int count() const;
                 QAbstractSeries::SeriesType type() const;
                 void setMaximumColumnWidth(qreal maximumColumnWidth);
                 qreal maximumColumnWidth() const;
                 void setMinimumColumnWidth(qreal minimumColumnWidth);
                 qreal minimumColumnWidth() const;
                 void setBodyWidth(qreal bodyWidth);
                 qreal bodyWidth() const;
                 void setBodyOutlineVisible(bool bodyOutlineVisible);
                 bool bodyOutlineVisible() const;
                 void setCapsWidth(qreal capsWidth);
                 qreal capsWidth() const;
                 void setCapsVisible(bool capsVisible);
                 bool capsVisible() const;
                 void setIncreasingColor(const QColor &increasingColor);
                 QColor increasingColor() const;
                 void setDecreasingColor(const QColor &decreasingColor);
                 QColor decreasingColor() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
             Q_SIGNALS:
                 void clicked(QCandlestickSet *set);
                 void hovered(bool status, QCandlestickSet *set);
                 void pressed(QCandlestickSet *set);
                 void released(QCandlestickSet *set);
                 void doubleClicked(QCandlestickSet *set);
                 void candlestickSetsAdded(const QList<QCandlestickSet *> &sets);
                 void candlestickSetsRemoved(const QList<QCandlestickSet *> &sets);
                 void countChanged();
                 void maximumColumnWidthChanged();
                 void minimumColumnWidthChanged();
                 void bodyWidthChanged();
                 void bodyOutlineVisibilityChanged();
                 void capsWidthChanged();
                 void capsVisibilityChanged();
                 void increasingColorChanged();
                 void decreasingColorChanged();
                 void brushChanged();
                 void penChanged();
             private:
                 Q_DISABLE_COPY(QCandlestickSeries)
                 Q_DECLARE_PRIVATE(QCandlestickSeries)
                 friend class CandlestickChartItem;
                 friend class QCandlestickLegendMarkerPrivate;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCANDLESTICKSERIES_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QCANDLESTICKSERIES_P_H
             #define QCANDLESTICKSERIES_P_H
             #include <private/qabstractseries_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             class CandlestickAnimation;
             class QBarCategoryAxis;
             class QCandlestickSeries;
             class QCandlestickSet;
             class QDateTimeAxis;
             class QCandlestickSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QCandlestickSeriesPrivate(QCandlestickSeries *q);
                 ~QCandlestickSeriesPrivate();
                 void initializeDomain();
                 void initializeAxes();
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeAnimations(QChart::AnimationOptions options, int duration, QEasingCurve &curve);
                 QList<QLegendMarker *> createLegendMarkers(QLegend *legend);
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                 QAbstractAxis *createDefaultAxis(Qt::Orientation orientation) const;
                 bool append(const QList<QCandlestickSet *> &sets);
                 bool remove(const QList<QCandlestickSet *> &sets);
                 bool insert(int index, QCandlestickSet *set);
             Q_SIGNALS:
                 void clicked(int index, QCandlestickSet *set);
                 void pressed(int index, QCandlestickSet *set);
                 void released(int index, QCandlestickSet *set);
                 void doubleClicked(int index, QCandlestickSet *set);
                 void updated();
                 void updatedLayout();
                 void updatedCandlesticks();
             private Q_SLOTS:
                 void handleSeriesChange(QAbstractSeries *series);
                 void handleSeriesRemove(QAbstractSeries *series);
             private:
                 void populateBarCategories(QBarCategoryAxis *axis);
             protected:
-                QList<QCandlestickSet *> m_candlestickSets;
+                QList<QCandlestickSet *> m_sets;
                 qreal m_maximumColumnWidth;
                 qreal m_minimumColumnWidth;
                 qreal m_bodyWidth;
                 bool m_bodyOutlineVisible;
                 qreal m_capsWidth;
                 bool m_capsVisible;
                 QColor m_increasingColor;
                 QColor m_decreasingColor;
                 bool m_customIncreasingColor;
                 bool m_customDecreasingColor;
                 QBrush m_brush;
                 QPen m_pen;
                 CandlestickAnimation *m_animation;
             private:
                 Q_DECLARE_PUBLIC(QCandlestickSeries)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCANDLESTICKSERIES_P_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QHCandlestickModelMapper>
             #include <private/qcandlestickmodelmapper_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QHCandlestickModelMapper
                 \since 5.8
                 \inmodule Qt Charts
                 \brief Horizontal model mapper for a candlestick series.
                 Model mappers allow the use of a QAbstractItemModel-derived model as a data source for a chart
                 series, creating a connection between a QCandlestickSeries and the model object. A horizontal
                 model mapper maintains an equal size across all \l {QCandlestickSet} {QCandlestickSets}, and
                 reads the values of the set from the model's rows.
                 \note The model used must support adding and removing rows/columns and modifying the data of the
                 cells.
             */
             /*!
                 \qmltype HCandlestickModelMapper
                 \since 2.2
                 \instantiates QHCandlestickModelMapper
                 \inqmlmodule QtCharts
                 \brief Horizontal model mapper for a candlestick series.
                 HCandlestickModelMapper allows the use of a QAbstractItemModel-derived model with data in rows
                 as a data source for a candlestick series. It's possible to manipulate the data either through
                 QAbstractItemModel or QCandlestickSeries.
                 The following QML example creates a candlestick series with three candlestick sets (assuming the
                 model has at least four rows). Each candlestick set would contain data defined by timestamp,
                 open, high, low and close columns. The name of a set would be defined by the vertical header of
                 the row.
                 \qml
                     CandlestickSeries {
                         HCandlestickModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             timestampColumn: 1
                             openColumn: 2
                             highColumn: 3
                             lowColumn: 4
                             closeColumn: 5
-                            firstCandlestickSetRow: 1
+                            firstSetRow: 1
-                            lastCandlestickSetRow: 3
+                            lastSetRow: 3
                         }
                     }
                 \endqml
                 \note HCandlestickModelMapper keeps the series and the model in sync.
             */
             /*!
                 \qmlproperty QAbstractItemModel HCandlestickModelMapper::model
                 \brief The QAbstractItemModel-based model that is used by the mapper. The model must be
                 implemented and exposed to QML.
                 \note The model used must support adding and removing rows/columns and modifying the data of the
                 cells.
             */
             /*!
                 \qmlproperty CandlestickSeries HCandlestickModelMapper::series
                 \brief Defines the CandlestickSeries based object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper. When a new series is
                 specified, the old series is disconnected (preserving its data).
             */
             /*!
                 \property QHCandlestickModelMapper::timestampColumn
                 \brief Defines the column of the model that contains the timestamp values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int HCandlestickModelMapper::timestampColumn
                 \brief Defines the column of the model that contains the timestamp values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QHCandlestickModelMapper::openColumn
                 \brief Defines the column of the model that contains the open values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int HCandlestickModelMapper::openColumn
                 \brief Defines the column of the model that contains the open values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QHCandlestickModelMapper::highColumn
                 \brief Defines the column of the model that contains the high values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int HCandlestickModelMapper::highColumn
                 \brief Defines the column of the model that contains the high values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QHCandlestickModelMapper::lowColumn
                 \brief Defines the column of the model that contains the low values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int HCandlestickModelMapper::lowColumn
                 \brief Defines the column of the model that contains the low values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QHCandlestickModelMapper::closeColumn
                 \brief Defines the column of the model that contains the close values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int HCandlestickModelMapper::closeColumn
                 \brief Defines the column of the model that contains the close values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
-                \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::timestampColumnChanged()
                 \brief Emitted when the column of the model that contains timestamp values is changed
                 \sa timestampColumn
             */
             /*!
                 \fn void QHCandlestickModelMapper::openColumnChanged()
                 \brief Emitted when the column of the model that contains open values is changed.
                 \sa openColumn
             */
             /*!
                 \fn void QHCandlestickModelMapper::highColumnChanged()
                 \brief Emitted when the column of the model that contains high values is changed.
                 \sa highColumn
             */
             /*!
                 \fn void QHCandlestickModelMapper::lowColumnChanged()
                 \brief Emitted when the column of the model that contains low values is changed.
                 \sa lowColumn
             */
             /*!
                 \fn void QHCandlestickModelMapper::closeColumnChanged()
                 \brief Emitted when the column of the model that contains close values is changed.
                 \sa closeColumn
             */
             /*!
-                \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
             */
             /*!
                 Constructs a horizontal model mapper object which is a child of \a parent.
             */
             QHCandlestickModelMapper::QHCandlestickModelMapper(QObject *parent)
                 : QCandlestickModelMapper(parent)
             {
                 connect(d_ptr, SIGNAL(timestampChanged()), this, SIGNAL(timestampColumnChanged()));
                 connect(d_ptr, SIGNAL(openChanged()), this, SIGNAL(openColumnChanged()));
                 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()));
             }
             /*!
                 Returns Qt::Horizontal. This means that values of the set are read from rows.
             */
             Qt::Orientation QHCandlestickModelMapper::orientation() const
             {
                 return Qt::Horizontal;
             }
             void QHCandlestickModelMapper::setTimestampColumn(int timestampColumn)
             {
                 QCandlestickModelMapper::setTimestamp(timestampColumn);
             }
             int QHCandlestickModelMapper::timestampColumn() const
             {
                 return QCandlestickModelMapper::timestamp();
             }
             void QHCandlestickModelMapper::setOpenColumn(int openColumn)
             {
                 QCandlestickModelMapper::setOpen(openColumn);
             }
             int QHCandlestickModelMapper::openColumn() const
             {
                 return QCandlestickModelMapper::open();
             }
             void QHCandlestickModelMapper::setHighColumn(int highColumn)
             {
                 QCandlestickModelMapper::setHigh(highColumn);
             }
             int QHCandlestickModelMapper::highColumn() const
             {
                 return QCandlestickModelMapper::high();
             }
             void QHCandlestickModelMapper::setLowColumn(int lowColumn)
             {
                 QCandlestickModelMapper::setLow(lowColumn);
             }
             int QHCandlestickModelMapper::lowColumn() const
             {
                 return QCandlestickModelMapper::low();
             }
             void QHCandlestickModelMapper::setCloseColumn(int closeColumn)
             {
                 QCandlestickModelMapper::setClose(closeColumn);
             }
             int QHCandlestickModelMapper::closeColumn() const
             {
                 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"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QHCANDLESTICKMODELMAPPER_H
             #define QHCANDLESTICKMODELMAPPER_H
             #include <QtCharts/QCandlestickModelMapper>
             QT_CHARTS_BEGIN_NAMESPACE
             /* Comment line for syncqt to generate the fwd-include correctly, due to QTBUG-22432 */
             class QT_CHARTS_EXPORT QHCandlestickModelMapper : public QCandlestickModelMapper
             {
                 Q_OBJECT
                 Q_PROPERTY(int timestampColumn READ timestampColumn WRITE setTimestampColumn NOTIFY timestampColumnChanged)
                 Q_PROPERTY(int openColumn READ openColumn WRITE setOpenColumn NOTIFY openColumnChanged)
                 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);
                 Qt::Orientation orientation() const;
                 void setTimestampColumn(int timestampColumn);
                 int timestampColumn() const;
                 void setOpenColumn(int openColumn);
                 int openColumn() const;
                 void setHighColumn(int highColumn);
                 int highColumn() const;
                 void setLowColumn(int lowColumn);
                 int lowColumn() const;
                 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 openColumnChanged();
                 void highColumnChanged();
                 void lowColumnChanged();
                 void closeColumnChanged();
-                void firstCandlestickSetRowChanged();
+                void firstSetRowChanged();
-                void lastCandlestickSetRowChanged();
+                void lastSetRowChanged();
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QHCANDLESTICKMODELMAPPER_H

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QVCandlestickModelMapper>
             #include <private/qcandlestickmodelmapper_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QVCandlestickModelMapper
                 \since 5.8
                 \inmodule Qt Charts
                 \brief Vertical model mapper for a candlestick series.
                 Model mappers allow the use of a QAbstractItemModel-derived model as a data source for a chart
                 series, creating a connection between a QCandlestickSeries and the model object. A vertical
                 model mapper maintains an equal size across all \l {QCandlestickSet} {QCandlestickSets}, and
                 reads the values of the set from the model's columns.
                 \note The model used must support adding and removing rows/columns and modifying the data of the
                 cells.
             */
             /*!
                 \qmltype VCandlestickModelMapper
                 \since 2.2
                 \instantiates QVCandlestickModelMapper
                 \inqmlmodule QtCharts
                 \brief Vertical model mapper for a candlestick series.
                 VCandlestickModelMapper allows the use of a QAbstractItemModel-derived model with data in
                 columns as a data source for a candlestick series. It's possible to manipulate the data either
                 through QAbstractItemModel or QCandlestickSeries.
                 The following QML example creates a candlestick series with three candlestick sets (assuming the
                 model has at least four columns). Each candlestick set would contain data defined by timestamp,
                 open, high, low and close rows. The name of a set would be defined by the horizontal header of
                 the column.
                 \qml
                     CandlestickSeries {
                         VCandlestickModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             timestampRow: 1
                             openRow: 2
                             highRow: 3
                             lowRow: 4
                             closeRow: 5
-                            firstCandlestickSetColumn: 1
+                            firstSetColumn: 1
-                            lastCandlestickSetColumn: 3
+                            lastSetColumn: 3
                         }
                     }
                 \endqml
                 \note VCandlestickModelMapper keeps the series and the model in sync.
             */
             /*!
                 \qmlproperty QAbstractItemModel VCandlestickModelMapper::model
                 \brief The QAbstractItemModel-based model that is used by the mapper. The model must be
                 implemented and exposed to QML.
                 \note The model used must support adding and removing rows/columns and modifying the data of the
                 cells.
             */
             /*!
                 \qmlproperty CandlestickSeries VCandlestickModelMapper::series
                 \brief Defines the CandlestickSeries based object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper. When a new series is
                 specified, the old series is disconnected (preserving its data).
             */
             /*!
                 \property QVCandlestickModelMapper::timestampRow
                 \brief Defines the row of the model that contains the timestamp values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int VCandlestickModelMapper::timestampRow
                 \brief Defines the row of the model that contains the timestamp values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QVCandlestickModelMapper::openRow
                 \brief Defines the row of the model that contains the open values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int VCandlestickModelMapper::openRow
                 \brief Defines the row of the model that contains the open values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QVCandlestickModelMapper::highRow
                 \brief Defines the row of the model that contains the high values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int VCandlestickModelMapper::highRow
                 \brief Defines the row of the model that contains the high values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QVCandlestickModelMapper::lowRow
                 \brief Defines the row of the model that contains the low values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int VCandlestickModelMapper::lowRow
                 \brief Defines the row of the model that contains the low values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \property QVCandlestickModelMapper::closeRow
                 \brief Defines the row of the model that contains the close values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
                 \qmlproperty int VCandlestickModelMapper::closeRow
                 \brief Defines the row of the model that contains the close values of the
                 \l {QCandlestickSet} {QCandlestickSets} in the series. Default value is -1 (invalid mapping).
             */
             /*!
-                \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::timestampRowChanged()
                 \brief Emitted when the row of the model that contains timestamp values is changed.
                 \sa timestampRow
             */
             /*!
                 \fn void QVCandlestickModelMapper::openRowChanged()
                 \brief Emitted when the row of the model that contains open values is changed.
                 \sa openRow
             */
             /*!
                 \fn void QVCandlestickModelMapper::highRowChanged()
                 \brief Emitted when the row of the model that contains high values is changed.
                 \sa highRow
             */
             /*!
                 \fn void QVCandlestickModelMapper::lowRowChanged()
                 \brief Emitted when the row of the model that contains low values is changed.
                 \sa lowRow
             */
             /*!
                 \fn void QVCandlestickModelMapper::closeRowChanged()
                 \brief Emitted when the row of the model that contains close values is changed.
                 \sa closeRow
             */
             /*!
-                \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
             */
             /*!
                 Constructs a vertical model mapper object which is a child of \a parent.
             */
             QVCandlestickModelMapper::QVCandlestickModelMapper(QObject *parent)
                 : QCandlestickModelMapper(parent)
             {
                 connect(d_ptr, SIGNAL(timestampChanged()), this, SIGNAL(timestampRowChanged()));
                 connect(d_ptr, SIGNAL(openChanged()), this, SIGNAL(openRowChanged()));
                 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()));
             }
             /*!
                 Returns Qt::Vertical. This means that values of the set are read from columns.
             */
             Qt::Orientation QVCandlestickModelMapper::orientation() const
             {
                 return Qt::Vertical;
             }
             void QVCandlestickModelMapper::setTimestampRow(int timestampRow)
             {
                 QCandlestickModelMapper::setTimestamp(timestampRow);
             }
             int QVCandlestickModelMapper::timestampRow() const
             {
                 return QCandlestickModelMapper::timestamp();
             }
             void QVCandlestickModelMapper::setOpenRow(int openRow)
             {
                 QCandlestickModelMapper::setOpen(openRow);
             }
             int QVCandlestickModelMapper::openRow() const
             {
                 return QCandlestickModelMapper::open();
             }
             void QVCandlestickModelMapper::setHighRow(int highRow)
             {
                 QCandlestickModelMapper::setHigh(highRow);
             }
             int QVCandlestickModelMapper::highRow() const
             {
                 return QCandlestickModelMapper::high();
             }
             void QVCandlestickModelMapper::setLowRow(int lowRow)
             {
                 QCandlestickModelMapper::setLow(lowRow);
             }
             int QVCandlestickModelMapper::lowRow() const
             {
                 return QCandlestickModelMapper::low();
             }
             void QVCandlestickModelMapper::setCloseRow(int closeRow)
             {
                 QCandlestickModelMapper::setClose(closeRow);
             }
             int QVCandlestickModelMapper::closeRow() const
             {
                 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"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QVCANDLESTICKMODELMAPPER_H
             #define QVCANDLESTICKMODELMAPPER_H
             #include <QtCharts/QCandlestickModelMapper>
             QT_CHARTS_BEGIN_NAMESPACE
             /* Comment line for syncqt to generate the fwd-include correctly, due to QTBUG-22432 */
             class QT_CHARTS_EXPORT QVCandlestickModelMapper : public QCandlestickModelMapper
             {
                 Q_OBJECT
                 Q_PROPERTY(int timestampRow READ timestampRow WRITE setTimestampRow NOTIFY timestampRowChanged)
                 Q_PROPERTY(int openRow READ openRow WRITE setOpenRow NOTIFY openRowChanged)
                 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);
                 Qt::Orientation orientation() const;
                 void setTimestampRow(int timestampRow);
                 int timestampRow() const;
                 void setOpenRow(int openRow);
                 int openRow() const;
                 void setHighRow(int highRow);
                 int highRow() const;
                 void setLowRow(int lowRow);
                 int lowRow() const;
                 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 openRowChanged();
                 void highRowChanged();
                 void lowRowChanged();
                 void closeRowChanged();
-                void firstCandlestickSetColumnChanged();
+                void firstSetColumnChanged();
-                void lastCandlestickSetColumnChanged();
+                void lastSetColumnChanged();
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QVCANDLESTICKMODELMAPPER_H

src/chartsqml2/declarativecandlestickseries.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QHCandlestickModelMapper>
             #include <QtCharts/QVCandlestickModelMapper>
             #include "declarativeaxes.h"
             #include "declarativecandlestickseries.h"
             QT_CHARTS_BEGIN_NAMESPACE
             DeclarativeCandlestickSet::DeclarativeCandlestickSet(qreal timestamp, QObject *parent)
                 : QCandlestickSet(timestamp, parent)
             {
                 connect(this, SIGNAL(brushChanged()), this, SLOT(handleBrushChanged()));
             }
             void DeclarativeCandlestickSet::setBrushFilename(const QString &brushFilename)
             {
                 QImage brushImage(brushFilename);
                 if (QCandlestickSet::brush().textureImage() != brushImage) {
                     QBrush brush = QCandlestickSet::brush();
                     brush.setTextureImage(brushImage);
                     QCandlestickSet::setBrush(brush);
                     m_brushFilename = brushFilename;
                     m_brushImage = brushImage;
                     emit brushFilenameChanged(brushFilename);
                 }
             }
             QString DeclarativeCandlestickSet::brushFilename() const
             {
                 return m_brushFilename;
             }
             void DeclarativeCandlestickSet::handleBrushChanged()
             {
                 // If the texture image of the brush has changed along the brush
                 // the brush file name needs to be cleared.
                 if (!m_brushFilename.isEmpty() && QCandlestickSet::brush().textureImage() != m_brushImage) {
                     m_brushFilename.clear();
                     emit brushFilenameChanged(QString());
                 }
             }
             // Declarative candlestick series ==================================================================
             DeclarativeCandlestickSeries::DeclarativeCandlestickSeries(QQuickItem *parent)
                 : QCandlestickSeries(parent),
                   m_axes(new DeclarativeAxes(this))
             {
                 connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)),
                         this, SIGNAL(axisXChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)),
                         this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)),
                         this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)),
                         this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
                 connect(this, SIGNAL(hovered(bool, QCandlestickSet *)),
                         this, SLOT(onHovered(bool, QCandlestickSet *)));
                 connect(this, SIGNAL(clicked(QCandlestickSet *)), this, SLOT(onClicked(QCandlestickSet *)));
                 connect(this, SIGNAL(pressed(QCandlestickSet *)), this, SLOT(onPressed(QCandlestickSet *)));
                 connect(this, SIGNAL(released(QCandlestickSet *)), this, SLOT(onReleased(QCandlestickSet *)));
                 connect(this, SIGNAL(doubleClicked(QCandlestickSet *)),
                         this, SLOT(onDoubleClicked(QCandlestickSet *)));
                 connect(this, SIGNAL(brushChanged()), this, SLOT(handleBrushChanged()));
             }
             QQmlListProperty<QObject> DeclarativeCandlestickSeries::seriesChildren()
             {
                 return QQmlListProperty<QObject>(this, 0, &DeclarativeCandlestickSeries::appendSeriesChildren,
 , 0, 0);
             }
             void DeclarativeCandlestickSeries::setBrushFilename(const QString &brushFilename)
             {
                 QImage brushImage(brushFilename);
                 if (QCandlestickSeries::brush().textureImage() != brushImage) {
                     QBrush brush = QCandlestickSeries::brush();
                     brush.setTextureImage(brushImage);
                     QCandlestickSeries::setBrush(brush);
                     m_brushFilename = brushFilename;
                     m_brushImage = brushImage;
                     emit brushFilenameChanged(brushFilename);
                 }
             }
             QString DeclarativeCandlestickSeries::brushFilename() const
             {
                 return m_brushFilename;
             }
             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]);
                 return 0;
             }
             bool DeclarativeCandlestickSeries::append(DeclarativeCandlestickSet *set)
             {
                 return QCandlestickSeries::append(qobject_cast<QCandlestickSet *>(set));
             }
             bool DeclarativeCandlestickSeries::remove(DeclarativeCandlestickSet *set)
             {
                 return QCandlestickSeries::remove(qobject_cast<QCandlestickSet *>(set));
             }
             bool DeclarativeCandlestickSeries::append(qreal open, qreal high, qreal low, qreal close,
                                                       qreal timestamp)
             {
                 QCandlestickSet *set = new QCandlestickSet(open, high, low, close, timestamp);
                 if (!QCandlestickSeries::append(set)) {
                     delete set;
                     return false;
                 }
                 return true;
             }
             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);
                 }
                 return false;
             }
             bool DeclarativeCandlestickSeries::insert(int index, DeclarativeCandlestickSet *set)
             {
                 return QCandlestickSeries::insert(index, qobject_cast<QCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::clear()
             {
                 QCandlestickSeries::clear();
             }
             void DeclarativeCandlestickSeries::classBegin()
             {
                 // do nothing
             }
             void DeclarativeCandlestickSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeCandlestickSet *>(child)) {
                         QCandlestickSeries::append(qobject_cast<DeclarativeCandlestickSet *>(child));
                     } else if (qobject_cast<QHCandlestickModelMapper *>(child)) {
                         QHCandlestickModelMapper *mapper = qobject_cast<QHCandlestickModelMapper *>(child);
                         mapper->setSeries(this);
                     } else if (qobject_cast<QVCandlestickModelMapper *>(child)) {
                         QVCandlestickModelMapper *mapper = qobject_cast<QVCandlestickModelMapper *>(child);
                         mapper->setSeries(this);
                     } // else: do nothing
                 }
             }
             void DeclarativeCandlestickSeries::appendSeriesChildren(QQmlListProperty<QObject> *list,
                                                                     QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             void DeclarativeCandlestickSeries::onClicked(QCandlestickSet *set)
             {
                 emit clicked(qobject_cast<DeclarativeCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::onHovered(bool status, QCandlestickSet *set)
             {
                 emit hovered(status, qobject_cast<DeclarativeCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::onPressed(QCandlestickSet *set)
             {
                 emit pressed(qobject_cast<DeclarativeCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::onReleased(QCandlestickSet *set)
             {
                 emit released(qobject_cast<DeclarativeCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::onDoubleClicked(QCandlestickSet *set)
             {
                 emit doubleClicked(qobject_cast<DeclarativeCandlestickSet *>(set));
             }
             void DeclarativeCandlestickSeries::handleBrushChanged()
             {
                 // If the texture image of the brush has changed along the brush
                 // the brush file name needs to be cleared.
                 if (!m_brushFilename.isEmpty() && QCandlestickSeries::brush().textureImage() != m_brushImage) {
                     m_brushFilename.clear();
                     emit brushFilenameChanged(QString());
                 }
             }
             #include "moc_declarativecandlestickseries.cpp"
             QT_CHARTS_END_NAMESPACE

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <QtCharts/QChartView>
             #include <QtCharts/QHCandlestickModelMapper>
             #include <QtCharts/QVCandlestickModelMapper>
             #include <QtCore/QString>
             #include <QtGui/QStandardItemModel>
             #include <QtTest/QtTest>
             QT_CHARTS_USE_NAMESPACE
             class tst_qcandlestickmodelmapper : public QObject
             {
                 Q_OBJECT
             public:
                 tst_qcandlestickmodelmapper();
                 void createVerticalMapper();
                 void createHorizontalMapper();
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void verticalMapper_data();
                 void verticalMapper();
                 void verticalMapperCustomMapping_data();
                 void verticalMapperCustomMapping();
                 void horizontalMapper_data();
                 void horizontalMapper();
                 void horizontalMapperCustomMapping_data();
                 void horizontalMapperCustomMapping();
                 void seriesUpdated();
                 void verticalModelInsertRows();
                 void verticalModelRemoveRows();
                 void verticalModelInsertColumns();
                 void verticalModelRemoveColumns();
                 void horizontalModelInsertRows();
                 void horizontalModelRemoveRows();
                 void horizontalModelInsertColumns();
                 void horizontalModelRemoveColumns();
                 void modelUpdateCell();
                 void verticalMapperSignals();
                 void horizontalMapperSignals();
             private:
                 QStandardItemModel *m_model;
                 int m_modelRowCount;
                 int m_modelColumnCount;
                 QCandlestickSeries *m_series;
                 QChart *m_chart;
                 QChartView *m_chartView;
                 QHCandlestickModelMapper *m_hMapper;
                 QVCandlestickModelMapper *m_vMapper;
             };
             tst_qcandlestickmodelmapper::tst_qcandlestickmodelmapper()
                 : m_model(nullptr),
                   m_modelRowCount(10),
                   m_modelColumnCount(8),
                   m_series(nullptr),
                   m_chart(nullptr),
                   m_chartView(nullptr),
                   m_hMapper(nullptr),
                   m_vMapper(nullptr)
             {
             }
             void tst_qcandlestickmodelmapper::createHorizontalMapper()
             {
                 m_hMapper = new QHCandlestickModelMapper;
                 QVERIFY(m_hMapper->model() == nullptr);
                 m_hMapper->setTimestampColumn(0);
                 m_hMapper->setOpenColumn(1);
                 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);
             }
             void tst_qcandlestickmodelmapper::createVerticalMapper()
             {
                 m_vMapper = new QVCandlestickModelMapper;
                 QVERIFY(m_vMapper->model() == nullptr);
                 m_vMapper->setTimestampRow(0);
                 m_vMapper->setOpenRow(1);
                 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::initTestCase()
             {
                 m_chart = new QChart();
                 m_chartView = new QChartView(m_chart);
                 m_chartView->show();
             }
             void tst_qcandlestickmodelmapper::cleanupTestCase()
             {
                 delete m_chartView;
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_qcandlestickmodelmapper::init()
             {
                 m_series = new QCandlestickSeries();
                 m_chart->addSeries(m_series);
                 m_model = new QStandardItemModel(m_modelRowCount, m_modelColumnCount, this);
                 for (int row = 0; row < m_modelRowCount; ++row) {
                     for (int column = 0; column < m_modelColumnCount; ++column)
                         m_model->setData(m_model->index(row, column), row * column);
                 }
             }
             void tst_qcandlestickmodelmapper::cleanup()
             {
                 m_chart->removeSeries(m_series);
                 delete m_series;
                 m_series = nullptr;
                 m_model->clear();
                 m_model->deleteLater();
                 m_model = nullptr;
                 if (m_vMapper) {
                     m_vMapper->deleteLater();
                     m_vMapper = nullptr;
                 }
                 if (m_hMapper) {
                     m_hMapper->deleteLater();
                     m_hMapper = nullptr;
                 }
             }
             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;
                 QTest::newRow("last column lesser than first column") << 1 << 0 << 0;
                 QTest::newRow("invalid first column and correct last column") << -3 << 1 << 0;
                 QTest::newRow("first column beyond the size of model and correct last column") << m_modelColumnCount << 1 << 0;
                 QTest::newRow("first column beyond the size of model and invalid last column") << m_modelColumnCount << -1 << 0;
             }
             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;
             }
             void tst_qcandlestickmodelmapper::verticalMapperCustomMapping_data()
             {
                 QTest::addColumn<int>("timestampRow");
                 QTest::addColumn<int>("openRow");
                 QTest::addColumn<int>("highRow");
                 QTest::addColumn<int>("lowRow");
                 QTest::addColumn<int>("closeRow");
                 QTest::newRow("all rows are correct") << 0 << 1 << 2 << 3 << 4;
                 QTest::newRow("all rows are invalid") << -3 << -3 << -3 << -3 << -3;
                 QTest::newRow("timestamp: -1 (invalid)") << -1 << 1 << 2 << 3 << 4;
                 QTest::newRow("timestamp: -3 (invalid - should default to -1)") << -3 << 1 << 2 << 3 << 4;
                 QTest::newRow("timestamp: +1 greater than the number of rows in the model") << m_modelRowCount + 1 << 1 << 2 << 3 << 4;
                 QTest::newRow("open: -1 (invalid)") << 0 << -1 << 2 << 3 << 4;
                 QTest::newRow("open: -3 (invalid - should default to -1)") << 0 << -3 << 2 << 3 << 4;
                 QTest::newRow("open: +1 greater than the number of rows in the model") << 0 << m_modelRowCount + 1 << 2 << 3 << 4;
                 QTest::newRow("high: -1 (invalid)") << 0 << 1 << -1 << 3 << 4;
                 QTest::newRow("high: -3 (invalid - should default to -1)") << 0 << 1 << -3 << 3 << 4;
                 QTest::newRow("high: +1 greater than the number of rows in the model") << 0 << 1 << m_modelRowCount + 1 << 3 << 4;
                 QTest::newRow("low: -1 (invalid)") << 0 << 1 << 2 << -1 << 4;
                 QTest::newRow("low: -3 (invalid - should default to -1)") << 0 << 1 << 2 << -3 << 4;
                 QTest::newRow("low: +1 greater than the number of rows in the model") << 0 << 1 << 2 << m_modelRowCount + 1 << 4;
                 QTest::newRow("close: -1 (invalid)") << 0 << 1 << 2 << 3 << -1;
                 QTest::newRow("close: -3 (invalid - should default to -1)") << 0 << 1 << 2 << 3 << -3;
                 QTest::newRow("close: +1 greater than the number of rows in the model") << 0 << 1 << 2 << 3 << m_modelRowCount + 1;
             }
             void tst_qcandlestickmodelmapper::verticalMapperCustomMapping()
             {
                 QFETCH(int, timestampRow);
                 QFETCH(int, openRow);
                 QFETCH(int, highRow);
                 QFETCH(int, lowRow);
                 QFETCH(int, closeRow);
                 QCandlestickSeries *series = new QCandlestickSeries();
                 m_chart->addSeries(series);
                 QCOMPARE(series->count(), 0);
                 createVerticalMapper();
                 m_vMapper->setTimestampRow(timestampRow);
                 m_vMapper->setOpenRow(openRow);
                 m_vMapper->setHighRow(highRow);
                 m_vMapper->setLowRow(lowRow);
                 m_vMapper->setCloseRow(closeRow);
                 m_vMapper->setSeries(series);
                 QCOMPARE(m_vMapper->timestampRow(), qMax(timestampRow, -1));
                 QCOMPARE(m_vMapper->openRow(), qMax(openRow, -1));
                 QCOMPARE(m_vMapper->highRow(), qMax(highRow, -1));
                 QCOMPARE(m_vMapper->lowRow(), qMax(lowRow, -1));
                 QCOMPARE(m_vMapper->closeRow(), qMax(closeRow, -1));
                 int count;
                 if ((m_vMapper->timestampRow() >= 0 && m_vMapper->timestampRow() < m_modelRowCount)
                     && (m_vMapper->openRow() >= 0 && m_vMapper->openRow() < m_modelRowCount)
                     && (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);
                 delete 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;
                 QTest::newRow("last row lesser than first row") << 1 << 0 << 0;
                 QTest::newRow("invalid first row and correct last row") << -3 << 1 << 0;
                 QTest::newRow("first row beyond the size of model and correct last row") << m_modelRowCount << 1 << 0;
                 QTest::newRow("first row beyond the size of model and invalid last row") << m_modelRowCount << -1 << 0;
             }
             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;
             }
             void tst_qcandlestickmodelmapper::horizontalMapperCustomMapping_data()
             {
                 QTest::addColumn<int>("timestampColumn");
                 QTest::addColumn<int>("openColumn");
                 QTest::addColumn<int>("highColumn");
                 QTest::addColumn<int>("lowColumn");
                 QTest::addColumn<int>("closeColumn");
                 QTest::newRow("all columns are correct") << 0 << 1 << 2 << 3 << 4;
                 QTest::newRow("all columns are invalid") << -3 << -3 << -3 << -3 << -3;
                 QTest::newRow("timestamp: -1 (invalid)") << -1 << 1 << 2 << 3 << 4;
                 QTest::newRow("timestamp: -3 (invalid - should default to -1)") << -3 << 1 << 2 << 3 << 4;
                 QTest::newRow("timestamp: +1 greater than the number of columns in the model") << m_modelColumnCount + 1 << 1 << 2 << 3 << 4;
                 QTest::newRow("open: -1 (invalid)") << 0 << -1 << 2 << 3 << 4;
                 QTest::newRow("open: -3 (invalid - should default to -1)") << 0 << -3 << 2 << 3 << 4;
                 QTest::newRow("open: +1 greater than the number of columns in the model") << 0 << m_modelColumnCount + 1 << 2 << 3 << 4;
                 QTest::newRow("high: -1 (invalid)") << 0 << 1 << -1 << 3 << 4;
                 QTest::newRow("high: -3 (invalid - should default to -1)") << 0 << 1 << -3 << 3 << 4;
                 QTest::newRow("high: +1 greater than the number of columns in the model") << 0 << 1 << m_modelColumnCount + 1 << 3 << 4;
                 QTest::newRow("low: -1 (invalid)") << 0 << 1 << 2 << -1 << 4;
                 QTest::newRow("low: -3 (invalid - should default to -1)") << 0 << 1 << 2 << -3 << 4;
                 QTest::newRow("low: +1 greater than the number of columns in the model") << 0 << 1 << 2 << m_modelColumnCount + 1 << 4;
                 QTest::newRow("close: -1 (invalid)") << 0 << 1 << 2 << 3 << -1;
                 QTest::newRow("close: -3 (invalid - should default to -1)") << 0 << 1 << 2 << 3 << -3;
                 QTest::newRow("close: +1 greater than the number of columns in the model") << 0 << 1 << 2 << 3 << m_modelColumnCount + 1;
             }
             void tst_qcandlestickmodelmapper::horizontalMapperCustomMapping()
             {
                 QFETCH(int, timestampColumn);
                 QFETCH(int, openColumn);
                 QFETCH(int, highColumn);
                 QFETCH(int, lowColumn);
                 QFETCH(int, closeColumn);
                 QCandlestickSeries *series = new QCandlestickSeries();
                 m_chart->addSeries(series);
                 QCOMPARE(series->count(), 0);
                 createHorizontalMapper();
                 m_hMapper->setTimestampColumn(timestampColumn);
                 m_hMapper->setOpenColumn(openColumn);
                 m_hMapper->setHighColumn(highColumn);
                 m_hMapper->setLowColumn(lowColumn);
                 m_hMapper->setCloseColumn(closeColumn);
                 m_hMapper->setSeries(series);
                 QCOMPARE(m_hMapper->timestampColumn(), qMax(timestampColumn, -1));
                 QCOMPARE(m_hMapper->openColumn(), qMax(openColumn, -1));
                 QCOMPARE(m_hMapper->highColumn(), qMax(highColumn, -1));
                 QCOMPARE(m_hMapper->lowColumn(), qMax(lowColumn, -1));
                 QCOMPARE(m_hMapper->closeColumn(), qMax(closeColumn, -1));
                 int count;
                 if ((m_hMapper->timestampColumn() >= 0 && m_hMapper->timestampColumn() < m_modelColumnCount)
                     && (m_hMapper->openColumn() >= 0 && m_hMapper->openColumn() < m_modelColumnCount)
                     && (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);
                 delete series;
             }
             void tst_qcandlestickmodelmapper::seriesUpdated()
             {
                 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
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->timestampRow(), 0)).toReal(),set->timestamp());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->openRow(), 0)).toReal(), set->open());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->highRow(), 0)).toReal(), set->high());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->lowRow(), 0)).toReal(), set->low());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->closeRow(), 0)).toReal(), set->close());
                 set->setTimestamp(set->timestamp() + 5.0);
                 set->setOpen(set->open() + 6.0);
                 set->setHigh(set->high() + 7.0);
                 set->setLow(set->low() + 8.0);
                 set->setClose(set->close() + 9.0);
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->timestampRow(), 0)).toReal(),set->timestamp());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->openRow(), 0)).toReal(), set->open());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->highRow(), 0)).toReal(), set->high());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->lowRow(), 0)).toReal(), set->low());
                 QCOMPARE(m_model->data(m_model->index(m_vMapper->closeRow(), 0)).toReal(), set->close());
                 // append new sets
                 QList<QCandlestickSet *> newCandlestickSets;
                 newCandlestickSets << new QCandlestickSet(3.0, 5.0, 2.0, 4.0, 1234);
                 newCandlestickSets << new QCandlestickSet(5.0, 7.0, 4.0, 6.0, 5678);
                 m_series->append(newCandlestickSets);
                 QCOMPARE(m_model->columnCount(), m_modelColumnCount + newCandlestickSets.count());
                 // 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);
                 m_model->insertRows(3, 4);
                 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);
                 m_model->removeRows(m_modelRowCount - 1, 1);
                 QCOMPARE(m_series->count(), count);
                 int removeCount = m_model->rowCount() - m_vMapper->closeRow();
                 m_model->removeRows(m_vMapper->closeRow(), removeCount);
                 QCOMPARE(m_series->count(), 0);
             }
             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);
                 m_model->insertColumns(3, 4);
                 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);
                 int removeCount = m_modelColumnCount - 2;
                 m_model->removeColumns(0, removeCount);
                 QCOMPARE(m_series->count(), qMin(m_model->columnCount(), count));
                 // leave all the columns
                 m_model->removeColumns(0, m_modelColumnCount - removeCount);
                 QCOMPARE(m_series->count(), 0);
             }
             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);
                 m_model->insertRows(3, 4);
                 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));
                 int removeCount = m_modelRowCount - 2;
                 m_model->removeRows(0, removeCount);
                 QCOMPARE(m_series->count(), qMin(m_model->rowCount(), count));
                 // leave all the columns
                 m_model->removeRows(0, m_modelRowCount - removeCount);
                 QCOMPARE(m_series->count(), 0);
             }
             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);
                 m_model->insertColumns(3, 4);
                 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);
                 m_model->removeColumns(m_modelColumnCount - 1, 1);
                 QCOMPARE(m_series->count(), count);
                 int removeCount = m_model->columnCount() - m_hMapper->closeColumn();
                 m_model->removeColumns(m_hMapper->closeColumn(), removeCount);
                 QCOMPARE(m_series->count(), 0);
             }
             void tst_qcandlestickmodelmapper::modelUpdateCell()
             {
                 createVerticalMapper();
                 QVERIFY(m_vMapper->model() != 0);
                 QModelIndex index = m_model->index(m_vMapper->timestampRow(), 0);
                 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()
             {
                 QVCandlestickModelMapper *mapper = new QVCandlestickModelMapper();
                 QSignalSpy spy0(mapper, SIGNAL(modelReplaced()));
                 QSignalSpy spy1(mapper, SIGNAL(seriesReplaced()));
                 QSignalSpy spy2(mapper, SIGNAL(timestampRowChanged()));
                 QSignalSpy spy3(mapper, SIGNAL(openRowChanged()));
                 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->setTimestampRow(1);
                 mapper->setOpenRow(2);
                 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);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
                 QCOMPARE(spy4.count(), 1);
                 QCOMPARE(spy5.count(), 1);
                 QCOMPARE(spy6.count(), 1);
                 QCOMPARE(spy7.count(), 1);
                 QCOMPARE(spy8.count(), 1);
                 delete mapper;
             }
             void tst_qcandlestickmodelmapper::horizontalMapperSignals()
             {
                 QHCandlestickModelMapper *mapper = new QHCandlestickModelMapper();
                 QSignalSpy spy0(mapper, SIGNAL(modelReplaced()));
                 QSignalSpy spy1(mapper, SIGNAL(seriesReplaced()));
                 QSignalSpy spy2(mapper, SIGNAL(timestampColumnChanged()));
                 QSignalSpy spy3(mapper, SIGNAL(openColumnChanged()));
                 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->setTimestampColumn(1);
                 mapper->setOpenColumn(2);
                 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);
                 QCOMPARE(spy2.count(), 1);
                 QCOMPARE(spy3.count(), 1);
                 QCOMPARE(spy4.count(), 1);
                 QCOMPARE(spy5.count(), 1);
                 QCOMPARE(spy6.count(), 1);
                 QCOMPARE(spy7.count(), 1);
                 QCOMPARE(spy8.count(), 1);
                 delete mapper;
             }
             QTEST_MAIN(tst_qcandlestickmodelmapper)
             #include "tst_qcandlestickmodelmapper.moc"

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <QtCharts/QChartView>
             #include <QtTest/QtTest>
             #include "tst_definitions.h"
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(QCandlestickSet *)
             Q_DECLARE_METATYPE(QList<QCandlestickSet *>)
             class tst_QCandlestickSeries : public QObject
             {
                 Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void qCandlestickSeries();
                 void append();
                 void remove();
                 void appendList();
                 void removeList();
                 void insert();
                 void take();
                 void clear();
-                void candlestickSets();
+                void sets();
                 void count();
                 void type();
                 void maximumColumnWidth_data();
                 void maximumColumnWidth();
                 void minimumColumnWidth_data();
                 void minimumColumnWidth();
                 void bodyWidth_data();
                 void bodyWidth();
                 void bodyOutlineVisible();
                 void capsWidth_data();
                 void capsWidth();
                 void capsVisible();
                 void increasingColor();
                 void decreasingColor();
                 void brush();
                 void pen();
                 void mouseClicked();
                 void mouseHovered();
                 void mousePressed();
                 void mouseReleased();
                 void mouseDoubleClicked();
             private:
                 QCandlestickSeries *m_series;
                 QList<QCandlestickSet *> m_sets;
             };
             void tst_QCandlestickSeries::initTestCase()
             {
                 qRegisterMetaType<QCandlestickSet *>("QCandlestickSet *");
                 qRegisterMetaType<QList<QCandlestickSet *>>("QList<QCandlestickSet *>");
             }
             void tst_QCandlestickSeries::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_QCandlestickSeries::init()
             {
                 m_series = new QCandlestickSeries();
                 m_series->setMaximumColumnWidth(5432.1);
                 m_series->setMinimumColumnWidth(2.0);
                 m_series->setBodyWidth(0.99);
                 m_series->setCapsWidth(0.99);
                 for (int i = 0; i < 5; ++i) {
                     qreal timestamp = QDateTime::currentMSecsSinceEpoch() + i * 1000000;
                     QCandlestickSet *set = new QCandlestickSet(timestamp);
                     set->setOpen(4);
                     set->setHigh(4);
                     set->setLow(1);
                     set->setClose(1);
                     m_sets.append(set);
                 }
             }
             void tst_QCandlestickSeries::cleanup()
             {
                 foreach (QCandlestickSet *set, m_sets) {
                     m_series->remove(set);
                     m_sets.removeAll(set);
                     delete set;
                 }
                 delete m_series;
                 m_series = nullptr;
             }
             void tst_QCandlestickSeries::qCandlestickSeries()
             {
                 QCandlestickSeries *series = new QCandlestickSeries();
                 QVERIFY(series != nullptr);
                 delete series;
                 series = nullptr;
             }
             void tst_QCandlestickSeries::append()
             {
                 QCOMPARE(m_series->count(), 0);
                 // Try adding set
                 QCandlestickSet *set1 = new QCandlestickSet(1234.0);
                 QVERIFY(m_series->append(set1));
                 QCOMPARE(m_series->count(), 1);
                 // Try adding another set
                 QCandlestickSet *set2 = new QCandlestickSet(2345.0);
                 QVERIFY(m_series->append(set2));
                 QCOMPARE(m_series->count(), 2);
                 // Try adding same set again
                 QVERIFY(!m_series->append(set2));
                 QCOMPARE(m_series->count(), 2);
                 // Try adding null set
                 QVERIFY(!m_series->append(nullptr));
                 QCOMPARE(m_series->count(), 2);
             }
             void tst_QCandlestickSeries::remove()
             {
                 m_series->append(m_sets);
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Try to remove null pointer (should not remove, should not crash)
                 QVERIFY(!m_series->remove(nullptr));
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Try to remove invalid pointer (should not remove, should not crash)
                 QVERIFY(!m_series->remove((QCandlestickSet *)(m_sets.at(0) + 1)));
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Remove some sets
                 const int removeCount = 3;
                 for (int i = 0; i < removeCount; ++i)
                     QVERIFY(m_series->remove(m_sets.at(i)));
                 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)
                     m_series->remove(m_sets.at(i));
                 QCOMPARE(m_series->count(), 0);
             }
             void tst_QCandlestickSeries::appendList()
             {
                 QCOMPARE(m_series->count(), 0);
                 // Append new sets (should succeed, count should match the count of sets)
                 QVERIFY(m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_series->count());
                 // Append same sets again (should fail, count should remain same)
                 QVERIFY(!m_series->append(m_sets));
                 QCOMPARE(m_series->count(), m_series->count());
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QCandlestickSet *> invalidList;
                 QVERIFY(m_series->append(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QCandlestickSet());
                 invalidList.append(m_sets.at(0));
                 QVERIFY(!m_series->append(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
                 delete invalidList.at(0);
                 invalidList.clear();
                 // Try append list with null pointers (should fail, count remains same)
                 QVERIFY(invalidList.isEmpty());
                 invalidList.append(nullptr);
                 invalidList.append(nullptr);
                 invalidList.append(nullptr);
                 QVERIFY(!m_series->append(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
             }
             void tst_QCandlestickSeries::removeList()
             {
                 m_series->append(m_sets);
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Try remove empty list (should fail, but count should remain same)
                 QList<QCandlestickSet *> invalidList;
                 QVERIFY(!m_series->remove(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Try remove list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QCandlestickSet());
                 invalidList.append(m_sets.at(0));
                 QVERIFY(!m_series->remove(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
                 delete invalidList.at(0);
                 invalidList.clear();
                 // Try remove list with null pointers (should fail, count remains same)
                 QVERIFY(invalidList.isEmpty());
                 invalidList.append(nullptr);
                 invalidList.append(nullptr);
                 invalidList.append(nullptr);
                 QVERIFY(!m_series->remove(invalidList));
                 QCOMPARE(m_series->count(), m_sets.count());
                 // Remove all sets (should succeed, count should be zero)
                 QVERIFY(m_series->remove(m_sets));
                 QCOMPARE(m_series->count(), 0);
                 // Remove same sets again (should fail, count should remain zero)
                 QVERIFY(!m_series->remove(m_sets));
                 QCOMPARE(m_series->count(), 0);
             }
             void tst_QCandlestickSeries::insert()
             {
                 QCOMPARE(m_series->count(), 0);
                 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
                 QSignalSpy addedSpy(m_series, SIGNAL(candlestickSetsAdded(QList<QCandlestickSet *>)));
                 for (int i = 0; i < m_sets.count(); ++i) {
                     QCandlestickSet *set = m_sets.at(i);
                     QVERIFY(m_series->insert(0, set));
                     QCOMPARE(m_series->count(), i + 1);
                     QTRY_COMPARE(countSpy.count(), i + 1);
                     QTRY_COMPARE(addedSpy.count(), i + 1);
                     QList<QVariant> args = addedSpy.value(i);
                     QCOMPARE(args.count(), 1);
                     QList<QCandlestickSet *> sets = qvariant_cast<QList<QCandlestickSet *>>(args.at(0));
                     QCOMPARE(sets.count(), 1);
                     QCOMPARE(sets.first(), set);
                 }
             }
             void tst_QCandlestickSeries::take()
             {
                 m_series->append(m_sets);
                 QCOMPARE(m_series->count(), m_sets.count());
                 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
                 QSignalSpy removedSpy(m_series, SIGNAL(candlestickSetsRemoved(QList<QCandlestickSet *>)));
                 for (int i = 0; i < m_sets.count(); ++i) {
                     QCandlestickSet *set = m_sets.at(i);
                     QVERIFY(m_series->take(set));
                     QCOMPARE(m_series->count(), m_sets.count() - i - 1);
                     QTRY_COMPARE(countSpy.count(), i + 1);
                     QTRY_COMPARE(removedSpy.count(), i + 1);
                     QList<QVariant> args = removedSpy.value(i);
                     QCOMPARE(args.count(), 1);
                     QList<QCandlestickSet *> sets = qvariant_cast<QList<QCandlestickSet *>>(args.at(0));
                     QCOMPARE(sets.count(), 1);
                     QCOMPARE(sets.first(), set);
                 }
             }
             void tst_QCandlestickSeries::clear()
             {
                 m_series->append(m_sets);
                 QCOMPARE(m_series->count(), m_sets.count());
                 m_series->clear();
                 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()
             {
                 QCOMPARE(m_series->type(), QAbstractSeries::SeriesTypeCandlestick);
             }
             void tst_QCandlestickSeries::maximumColumnWidth_data()
             {
                 QTest::addColumn<qreal>("maximumColumnWidth");
                 QTest::addColumn<qreal>("expectedMaximumColumnWidth");
                 QTest::newRow("maximum column width less than -1.0") << -3.0 << -1.0;
                 QTest::newRow("maximum column equals to -1.0") << -1.0 << -1.0;
                 QTest::newRow("maximum column width greater than -1.0, but less than zero") << -0.5 << -1.0;
                 QTest::newRow("maximum column width equals zero") << 0.0 << 0.0;
                 QTest::newRow("maximum column width greater than zero") << 1.0 << 1.0;
                 QTest::newRow("maximum column width contains a fractional part") << 3.4 << 3.4;
             }
             void tst_QCandlestickSeries::maximumColumnWidth()
             {
                 QFETCH(qreal, maximumColumnWidth);
                 QFETCH(qreal, expectedMaximumColumnWidth);
                 QSignalSpy spy(m_series, SIGNAL(maximumColumnWidthChanged()));
                 m_series->setMaximumColumnWidth(maximumColumnWidth);
                 QCOMPARE(m_series->maximumColumnWidth(), expectedMaximumColumnWidth);
                 QCOMPARE(spy.count(), 1);
                 // Try set same maximum column width
                 m_series->setMaximumColumnWidth(expectedMaximumColumnWidth);
                 QCOMPARE(m_series->maximumColumnWidth(), expectedMaximumColumnWidth);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::minimumColumnWidth_data()
             {
                 QTest::addColumn<qreal>("minimumColumnWidth");
                 QTest::addColumn<qreal>("expectedMinimumColumnWidth");
                 QTest::newRow("minimum column width less than -1.0") << -3.0 << -1.0;
                 QTest::newRow("minimum column equals to -1.0") << -1.0 << -1.0;
                 QTest::newRow("minimum column width greater than -1.0, but less than zero") << -0.5 << -1.0;
                 QTest::newRow("minimum column width equals zero") << 0.0 << 0.0;
                 QTest::newRow("minimum column width greater than zero") << 1.0 << 1.0;
                 QTest::newRow("minimum column width contains a fractional part") << 3.4 << 3.4;
             }
             void tst_QCandlestickSeries::minimumColumnWidth()
             {
                 QFETCH(qreal, minimumColumnWidth);
                 QFETCH(qreal, expectedMinimumColumnWidth);
                 QSignalSpy spy(m_series, SIGNAL(minimumColumnWidthChanged()));
                 m_series->setMinimumColumnWidth(minimumColumnWidth);
                 QCOMPARE(m_series->minimumColumnWidth(), expectedMinimumColumnWidth);
                 QCOMPARE(spy.count(), 1);
                 // Try set same minimum column width
                 m_series->setMinimumColumnWidth(expectedMinimumColumnWidth);
                 QCOMPARE(m_series->minimumColumnWidth(), expectedMinimumColumnWidth);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::bodyWidth_data()
             {
                 QTest::addColumn<qreal>("bodyWidth");
                 QTest::addColumn<qreal>("expectedBodyWidth");
                 QTest::newRow("body width less than zero") << -1.0 << 0.0;
                 QTest::newRow("body width equals zero") << 0.0 << 0.0;
                 QTest::newRow("body width greater than zero and less than one") << 0.5 << 0.5;
                 QTest::newRow("body width equals one") << 1.0 << 1.0;
                 QTest::newRow("body width greater than one") << 2.0 << 1.0;
             }
             void tst_QCandlestickSeries::bodyWidth()
             {
                 QFETCH(qreal, bodyWidth);
                 QFETCH(qreal, expectedBodyWidth);
                 QSignalSpy spy(m_series, SIGNAL(bodyWidthChanged()));
                 m_series->setBodyWidth(bodyWidth);
                 QCOMPARE(m_series->bodyWidth(), expectedBodyWidth);
                 QCOMPARE(spy.count(), 1);
                 // Try set same body width
                 m_series->setBodyWidth(bodyWidth);
                 QCOMPARE(m_series->bodyWidth(), expectedBodyWidth);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::bodyOutlineVisible()
             {
                 QSignalSpy spy(m_series, SIGNAL(bodyOutlineVisibilityChanged()));
                 bool visible = !m_series->bodyOutlineVisible();
                 m_series->setBodyOutlineVisible(visible);
                 QCOMPARE(m_series->bodyOutlineVisible(), visible);
                 QCOMPARE(spy.count(), 1);
                 // Try set same body outline visibility
                 m_series->setBodyOutlineVisible(visible);
                 QCOMPARE(m_series->bodyOutlineVisible(), visible);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::capsWidth_data()
             {
                 QTest::addColumn<qreal>("capsWidth");
                 QTest::addColumn<qreal>("expectedCapsWidth");
                 QTest::newRow("caps width less than zero") << -1.0 << 0.0;
                 QTest::newRow("caps width equals zero") << 0.0 << 0.0;
                 QTest::newRow("caps width greater than zero and less than one") << 0.5 << 0.5;
                 QTest::newRow("caps width equals one") << 1.0 << 1.0;
                 QTest::newRow("caps width greater than one") << 2.0 << 1.0;
             }
             void tst_QCandlestickSeries::capsWidth()
             {
                 QFETCH(qreal, capsWidth);
                 QFETCH(qreal, expectedCapsWidth);
                 QSignalSpy spy(m_series, SIGNAL(capsWidthChanged()));
                 m_series->setCapsWidth(capsWidth);
                 QCOMPARE(m_series->capsWidth(), expectedCapsWidth);
                 QCOMPARE(spy.count(), 1);
                 // Try set same caps width
                 m_series->setCapsWidth(capsWidth);
                 QCOMPARE(m_series->capsWidth(), expectedCapsWidth);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::capsVisible()
             {
                 QSignalSpy spy(m_series, SIGNAL(capsVisibilityChanged()));
                 bool visible = !m_series->capsVisible();
                 m_series->setCapsVisible(visible);
                 QCOMPARE(m_series->capsVisible(), visible);
                 QCOMPARE(spy.count(), 1);
                 // Try set same caps visibility
                 m_series->setCapsVisible(visible);
                 QCOMPARE(m_series->capsVisible(), visible);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::increasingColor()
             {
                 QSignalSpy spy(m_series, SIGNAL(increasingColorChanged()));
                 // Try set new increasing color
                 QColor newColor(200, 200, 200, 200);
                 m_series->setIncreasingColor(newColor);
                 QCOMPARE(m_series->increasingColor(), newColor);
                 QCOMPARE(spy.count(), 1);
                 // Try set same increasing color again
                 m_series->setIncreasingColor(newColor);
                 QCOMPARE(m_series->increasingColor(), newColor);
                 QCOMPARE(spy.count(), 1);
                 // Try set invalid increasing color (should change to default color)
                 QColor defaultColor = m_series->brush().color();
                 defaultColor.setAlpha(128);
                 m_series->setIncreasingColor(QColor());
                 QCOMPARE(m_series->increasingColor(), defaultColor);
                 QCOMPARE(spy.count(), 2);
                 // Set new brush, increasing color should change accordingly
                 QBrush brush(newColor);
                 defaultColor = brush.color();
                 defaultColor.setAlpha(128);
                 m_series->setBrush(brush);
                 QCOMPARE(m_series->increasingColor(), defaultColor);
                 QCOMPARE(spy.count(), 3);
             }
             void tst_QCandlestickSeries::decreasingColor()
             {
                 QSignalSpy spy(m_series, SIGNAL(decreasingColorChanged()));
                 // Try set new decreasing color
                 QColor newColor(200, 200, 200, 200);
                 m_series->setDecreasingColor(newColor);
                 QCOMPARE(m_series->decreasingColor(), newColor);
                 QCOMPARE(spy.count(), 1);
                 // Try set same decreasing color again
                 m_series->setDecreasingColor(newColor);
                 QCOMPARE(m_series->decreasingColor(), newColor);
                 QCOMPARE(spy.count(), 1);
                 // Try set invalid decreasing color (should change to default color)
                 m_series->setDecreasingColor(QColor());
                 QCOMPARE(m_series->decreasingColor(), m_series->brush().color());
                 QCOMPARE(spy.count(), 2);
                 // Set new brush, decreasing color should change accordingly
                 m_series->setBrush(QBrush(newColor));
                 QCOMPARE(m_series->decreasingColor(), m_series->brush().color());
                 QCOMPARE(spy.count(), 3);
             }
             void tst_QCandlestickSeries::brush()
             {
                 QSignalSpy spy(m_series, SIGNAL(brushChanged()));
                 QBrush brush(QColor(128, 128, 128, 128));
                 QColor increasingColor(brush.color());
                 increasingColor.setAlpha(128);
                 QColor decreasingColor(brush.color());
                 m_series->setBrush(brush);
                 QCOMPARE(m_series->brush(), brush);
                 QCOMPARE(m_series->increasingColor(), increasingColor);
                 QCOMPARE(m_series->decreasingColor(), decreasingColor);
                 QCOMPARE(spy.count(), 1);
                 // Try set same brush
                 m_series->setBrush(brush);
                 QCOMPARE(m_series->brush(), brush);
                 QCOMPARE(m_series->increasingColor(), increasingColor);
                 QCOMPARE(m_series->decreasingColor(), decreasingColor);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::pen()
             {
                 QSignalSpy spy(m_series, SIGNAL(penChanged()));
                 QPen pen(QColor(128, 128, 128, 128));
                 m_series->setPen(pen);
                 QCOMPARE(m_series->pen(), pen);
                 QCOMPARE(spy.count(), 1);
                 // Try set same pen
                 m_series->setPen(pen);
                 QCOMPARE(m_series->pen(), pen);
                 QCOMPARE(spy.count(), 1);
             }
             void tst_QCandlestickSeries::mouseClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 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()));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked()));
                 QChartView view(new QChart());
                 view.resize(400, 300);
                 view.chart()->addSeries(m_series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for candlesticks
                 QRectF plotArea = view.chart()->plotArea();
                 qreal candlestickWidth = plotArea.width() / m_series->count();
                 qreal candlestickHeight = plotArea.height();
                 QMap<QCandlestickSet *, QRectF> layout;
                 layout.insert(set1, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set1),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 layout.insert(set2, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set2),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 // Click set 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set1);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy1.takeFirst().isEmpty());
                 // Click set 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set2);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy2.takeFirst().isEmpty());
             }
             void tst_QCandlestickSeries::mouseHovered()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 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)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QChartView view(new QChart());
                 view.resize(400, 300);
                 view.chart()->addSeries(m_series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // This is hack since view does not get events otherwise
                 view.setMouseTracking(true);
                 // Calculate expected layout for candlesticks
                 QRectF plotArea = view.chart()->plotArea();
                 qreal candlestickWidth = plotArea.width() / m_series->count();
                 qreal candlestickHeight = plotArea.height();
                 QMap<QCandlestickSet *, QRectF> layout;
                 layout.insert(set1, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set1),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 layout.insert(set2, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set2),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 // Move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, layout.value(set1).center().y()));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 0);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 // Move mouse on top of set 1
                 QTest::mouseMove(view.viewport(), layout.value(set1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(1)), set1);
                 QCOMPARE(seriesSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(seriesSpyArgs.at(0).toBool(), true);
                 seriesSpyArgs.clear();
                 QList<QVariant> setSpyArgs = setSpy1.takeFirst();
                 QCOMPARE(setSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(setSpyArgs.at(0).toBool(), true);
                 setSpyArgs.clear();
                 // Move mouse from top of set 1 to top of set 2
                 QTest::mouseMove(view.viewport(), layout.value(set2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 2);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 1);
                 // Should leave set 1
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(1)), set1);
                 QCOMPARE(seriesSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(seriesSpyArgs.at(0).toBool(), false);
                 // Don't call seriesSpyArgs.clear() here
                 setSpyArgs = setSpy1.takeFirst();
                 QCOMPARE(setSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(setSpyArgs.at(0).toBool(), false);
                 // Don't call setSpyArgs.clear() here
                 // Should enter set 2
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(1)), set2);
                 QCOMPARE(seriesSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(seriesSpyArgs.at(0).toBool(), true);
                 seriesSpyArgs.clear();
                 setSpyArgs = setSpy2.takeFirst();
                 QCOMPARE(setSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(setSpyArgs.at(0).toBool(), true);
                 setSpyArgs.clear();
                 // Move mouse from top of set 2 to background
                 QTest::mouseMove(view.viewport(), QPoint(layout.value(set2).center().x(), 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 // Should leave set 2
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(1)), set2);
                 QCOMPARE(seriesSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(seriesSpyArgs.at(0).toBool(), false);
                 seriesSpyArgs.clear();
                 setSpyArgs = setSpy2.takeFirst();
                 QCOMPARE(setSpyArgs.at(0).type(), QVariant::Bool);
                 QCOMPARE(setSpyArgs.at(0).toBool(), false);
                 setSpyArgs.clear();
             }
             void tst_QCandlestickSeries::mousePressed()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 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()));
                 QSignalSpy setSpy2(set2, SIGNAL(pressed()));
                 QChartView view(new QChart());
                 view.resize(400, 300);
                 view.chart()->addSeries(m_series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for candlesticks
                 QRectF plotArea = view.chart()->plotArea();
                 qreal candlestickWidth = plotArea.width() / m_series->count();
                 qreal candlestickHeight = plotArea.height();
                 QMap<QCandlestickSet *, QRectF> layout;
                 layout.insert(set1, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set1),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 layout.insert(set2, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set2),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 // Press set 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set1);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy1.takeFirst().isEmpty());
                 // Press set 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set2);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy2.takeFirst().isEmpty());
             }
             void tst_QCandlestickSeries::mouseReleased()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 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()));
                 QSignalSpy setSpy2(set2, SIGNAL(released()));
                 QChartView view(new QChart());
                 view.resize(400, 300);
                 view.chart()->addSeries(m_series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for candlesticks
                 QRectF plotArea = view.chart()->plotArea();
                 qreal candlestickWidth = plotArea.width() / m_series->count();
                 qreal candlestickHeight = plotArea.height();
                 QMap<QCandlestickSet *, QRectF> layout;
                 layout.insert(set1, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set1),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 layout.insert(set2, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set2),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 // Release mouse over set 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set1);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy1.takeFirst().isEmpty());
                 // Release mouse over set 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, layout.value(set2).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set2);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy2.takeFirst().isEmpty());
             }
             void tst_QCandlestickSeries::mouseDoubleClicked()
             {
                 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
                 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()));
                 QSignalSpy setSpy2(set2, SIGNAL(doubleClicked()));
                 QChartView view(new QChart());
                 view.resize(400, 300);
                 view.chart()->addSeries(m_series);
                 view.chart()->createDefaultAxes();
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // Calculate expected layout for candlesticks
                 QRectF plotArea = view.chart()->plotArea();
                 qreal candlestickWidth = plotArea.width() / m_series->count();
                 qreal candlestickHeight = plotArea.height();
                 QMap<QCandlestickSet *, QRectF> layout;
                 layout.insert(set1, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set1),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 layout.insert(set2, QRectF(plotArea.left() + candlestickWidth * m_sets.indexOf(set2),
                                            plotArea.top(), candlestickWidth, candlestickHeight));
                 // Double-click set 1
                 QTest::mouseDClick(view.viewport(), Qt::LeftButton, 0, layout.value(set1).center().toPoint());
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(seriesSpy.count(), 1);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QList<QVariant> seriesSpyArgs = seriesSpy.takeFirst();
                 QCOMPARE(seriesSpyArgs.count(), 1);
                 QCOMPARE(qvariant_cast<QCandlestickSet *>(seriesSpyArgs.at(0)), set1);
                 seriesSpyArgs.clear();
                 QVERIFY(setSpy1.takeFirst().isEmpty());
             }
             QTEST_MAIN(tst_QCandlestickSeries)
             #include "tst_qcandlestickseries.moc"

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

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QCandlestickSeries>
             #include <QtCharts/QCandlestickSet>
             #include <QtCharts/QDateTimeAxis>
             #include <QtCharts/QHCandlestickModelMapper>
             #include <QtCharts/QValueAxis>
             #include <QtCore/QDateTime>
             #include <QtCore/QDebug>
             #include <QtWidgets/QCheckBox>
             #include <QtWidgets/QComboBox>
             #include <QtWidgets/QDoubleSpinBox>
             #include <QtWidgets/QGridLayout>
             #include <QtWidgets/QHeaderView>
             #include <QtWidgets/QLabel>
             #include <QtWidgets/QPushButton>
             #include <QtWidgets/QTableView>
             #include "customtablemodel.h"
             #include "mainwidget.h"
             QT_CHARTS_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent)
                 : QWidget(parent),
                   m_chart(new QChart()),
                   m_chartView(new QChartView(m_chart, this)),
                   m_axisX(nullptr),
                   m_axisY(nullptr),
                   m_maximumColumnWidth(-1.0),
                   m_minimumColumnWidth(5.0),
                   m_bodyOutlineVisible(true),
                   m_capsVisible(false),
                   m_bodyWidth(0.5),
                   m_capsWidth(0.5),
                   m_customIncreasingColor(false),
                   m_customDecreasingColor(false),
                   m_hModelMapper(new QHCandlestickModelMapper(this))
             {
                 qsrand(QDateTime::currentDateTime().toTime_t());
                 m_chartView->setRenderHint(QPainter::Antialiasing, false);
                 m_hModelMapper->setModel(new CustomTableModel(this));
                 m_hModelMapper->setTimestampColumn(0);
                 m_hModelMapper->setOpenColumn(1);
                 m_hModelMapper->setHighColumn(2);
                 m_hModelMapper->setLowColumn(3);
                 m_hModelMapper->setCloseColumn(4);
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(createSeriesControlsLayout(), 0, 0);
                 mainLayout->addLayout(createSetsControlsLayout(), 1, 0);
                 mainLayout->addLayout(createCandlestickControlsLayout(), 2, 0);
                 mainLayout->addLayout(createMiscellaneousControlsLayout(), 3, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, mainLayout->rowCount() + 1, 1);
                 mainLayout->addLayout(createModelMapperControlsLayout(), 0, 2, mainLayout->rowCount(), 1);
                 setLayout(mainLayout);
                 addSeries();
             }
             MainWidget::~MainWidget()
             {
             }
             QGridLayout *MainWidget::createSeriesControlsLayout()
             {
                 QGridLayout *layout = new QGridLayout();
                 int row = 0;
                 layout->addWidget(new QLabel(QStringLiteral("Series controls:")), row, 0, Qt::AlignLeft);
                 QPushButton *addSeriesButton = new QPushButton(QStringLiteral("Add a series"));
                 connect(addSeriesButton, SIGNAL(clicked(bool)), this, SLOT(addSeries()));
                 layout->addWidget(addSeriesButton, row++, 1, Qt::AlignLeft);
                 QPushButton *removeSeriesButton = new QPushButton(QStringLiteral("Remove a series"));
                 connect(removeSeriesButton, SIGNAL(clicked(bool)), this, SLOT(removeSeries()));
                 layout->addWidget(removeSeriesButton, row++, 1, Qt::AlignLeft);
                 QPushButton *removeAllSeriesButton = new QPushButton(QStringLiteral("Remove all series"));
                 connect(removeAllSeriesButton, SIGNAL(clicked(bool)), this, SLOT(removeAllSeries()));
                 layout->addWidget(removeAllSeriesButton, row++, 1, Qt::AlignLeft);
                 return layout;
             }
             QGridLayout *MainWidget::createSetsControlsLayout()
             {
                 QGridLayout *layout = new QGridLayout();
                 int row = 0;
                 layout->addWidget(new QLabel(QStringLiteral("Sets controls:")), row, 0, Qt::AlignLeft);
                 QPushButton *addSetButton = new QPushButton(QStringLiteral("Add a set"));
                 connect(addSetButton, SIGNAL(clicked(bool)), this, SLOT(addSet()));
                 layout->addWidget(addSetButton, row++, 1, Qt::AlignLeft);
                 QPushButton *insertSetButton = new QPushButton(QStringLiteral("Insert a set"));
                 connect(insertSetButton, SIGNAL(clicked(bool)), this, SLOT(insertSet()));
                 layout->addWidget(insertSetButton, row++, 1, Qt::AlignLeft);
                 QPushButton *removeSetButton = new QPushButton(QStringLiteral("Remove a set"));
                 connect(removeSetButton, SIGNAL(clicked(bool)), this, SLOT(removeSet()));
                 layout->addWidget(removeSetButton, row++, 1, Qt::AlignLeft);
                 QPushButton *removeAllSetsButton = new QPushButton(QStringLiteral("Remove all sets"));
                 connect(removeAllSetsButton, SIGNAL(clicked(bool)), this, SLOT(removeAllSets()));
                 layout->addWidget(removeAllSetsButton, row++, 1, Qt::AlignLeft);
                 return layout;
             }
             QGridLayout *MainWidget::createCandlestickControlsLayout()
             {
                 QGridLayout *layout = new QGridLayout();
                 int row = 0;
                 layout->addWidget(new QLabel(QStringLiteral("Maximum column width:")), row, 0, Qt::AlignLeft);
                 QDoubleSpinBox *maximumColumnWidthSpinBox = new QDoubleSpinBox();
                 maximumColumnWidthSpinBox->setRange(-1.0, 1024.0);
                 maximumColumnWidthSpinBox->setDecimals(0);
                 maximumColumnWidthSpinBox->setValue(m_maximumColumnWidth);
                 maximumColumnWidthSpinBox->setSingleStep(1.0);
                 connect(maximumColumnWidthSpinBox, SIGNAL(valueChanged(double)),
                         this, SLOT(changeMaximumColumnWidth(double)));
                 layout->addWidget(maximumColumnWidthSpinBox, row++, 1, Qt::AlignLeft);
                 layout->addWidget(new QLabel(QStringLiteral("Minimum column width:")), row, 0, Qt::AlignLeft);
                 QDoubleSpinBox *minimumColumnWidthSpinBox = new QDoubleSpinBox();
                 minimumColumnWidthSpinBox->setRange(-1.0, 1024.0);
                 minimumColumnWidthSpinBox->setDecimals(0);
                 minimumColumnWidthSpinBox->setValue(m_minimumColumnWidth);
                 minimumColumnWidthSpinBox->setSingleStep(1.0);
                 connect(minimumColumnWidthSpinBox, SIGNAL(valueChanged(double)),
                         this, SLOT(changeMinimumColumnWidth(double)));
                 layout->addWidget(minimumColumnWidthSpinBox, row++, 1, Qt::AlignLeft);
                 QCheckBox *bodyOutlineVisible = new QCheckBox(QStringLiteral("Body outline visible"));
                 connect(bodyOutlineVisible, SIGNAL(toggled(bool)), this, SLOT(bodyOutlineVisibleToggled(bool)));
                 bodyOutlineVisible->setChecked(m_bodyOutlineVisible);
                 layout->addWidget(bodyOutlineVisible, row++, 0, Qt::AlignLeft);
                 QCheckBox *capsVisible = new QCheckBox(QStringLiteral("Caps visible"));
                 connect(capsVisible, SIGNAL(toggled(bool)), this, SLOT(capsVisibleToggled(bool)));
                 capsVisible->setChecked(m_capsVisible);
                 layout->addWidget(capsVisible, row++, 0, Qt::AlignLeft);
                 layout->addWidget(new QLabel(QStringLiteral("Candlestick body width:")), row, 0, Qt::AlignLeft);
                 QDoubleSpinBox *bodyWidthSpinBox = new QDoubleSpinBox();
                 bodyWidthSpinBox->setRange(-1.0, 2.0);
                 bodyWidthSpinBox->setValue(m_bodyWidth);
                 bodyWidthSpinBox->setSingleStep(0.1);
                 connect(bodyWidthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(changeBodyWidth(double)));
                 layout->addWidget(bodyWidthSpinBox, row++, 1, Qt::AlignLeft);
                 layout->addWidget(new QLabel(QStringLiteral("Candlestick caps width:")), row, 0, Qt::AlignLeft);
                 QDoubleSpinBox *capsWidthSpinBox = new QDoubleSpinBox();
                 capsWidthSpinBox->setRange(-1.0, 2.0);
                 capsWidthSpinBox->setValue(m_capsWidth);
                 capsWidthSpinBox->setSingleStep(0.1);
                 connect(capsWidthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(changeCapsWidth(double)));
                 layout->addWidget(capsWidthSpinBox, row++, 1, Qt::AlignLeft);
                 QCheckBox *increasingColor = new QCheckBox(QStringLiteral("Custom increasing color (only S1)"));
                 connect(increasingColor, SIGNAL(toggled(bool)), this, SLOT(customIncreasingColorToggled(bool)));
                 increasingColor->setChecked(m_customIncreasingColor);
                 layout->addWidget(increasingColor, row++, 0, 1, 2, Qt::AlignLeft);
                 QCheckBox *decreasingColor = new QCheckBox(QStringLiteral("Custom decreasing color (only S1)"));
                 connect(decreasingColor, SIGNAL(toggled(bool)), this, SLOT(customDecreasingColorToggled(bool)));
                 decreasingColor->setChecked(m_customDecreasingColor);
                 layout->addWidget(decreasingColor, row++, 0, 1, 2, Qt::AlignLeft);
                 return layout;
             }
             QGridLayout *MainWidget::createMiscellaneousControlsLayout()
             {
                 QGridLayout *layout = new QGridLayout();
                 int row = 0;
                 layout->addWidget(new QLabel(QStringLiteral("Miscellaneous:")), row, 0, Qt::AlignLeft);
                 QCheckBox *antialiasingCheckBox = new QCheckBox(QStringLiteral("Antialiasing"));
                 connect(antialiasingCheckBox, SIGNAL(toggled(bool)), this, SLOT(antialiasingToggled(bool)));
                 antialiasingCheckBox->setChecked(false);
                 layout->addWidget(antialiasingCheckBox, row++, 1, Qt::AlignLeft);
                 QCheckBox *animationCheckBox = new QCheckBox(QStringLiteral("Animation"));
                 connect(animationCheckBox, SIGNAL(toggled(bool)), this, SLOT(animationToggled(bool)));
                 animationCheckBox->setChecked(false);
                 layout->addWidget(animationCheckBox, row++, 1, Qt::AlignLeft);
                 QCheckBox *legendCheckBox = new QCheckBox(QStringLiteral("Legend"));
                 connect(legendCheckBox, SIGNAL(toggled(bool)), this, SLOT(legendToggled(bool)));
                 legendCheckBox->setChecked(true);
                 layout->addWidget(legendCheckBox, row++, 1, Qt::AlignLeft);
                 QCheckBox *titleCheckBox = new QCheckBox(QStringLiteral("Title"));
                 connect(titleCheckBox, SIGNAL(toggled(bool)), this, SLOT(titleToggled(bool)));
                 titleCheckBox->setChecked(true);
                 layout->addWidget(titleCheckBox, row++, 1, Qt::AlignLeft);
                 layout->addWidget(new QLabel(QStringLiteral("Chart theme:")), row, 0, Qt::AlignLeft);
                 QComboBox *chartThemeComboBox = new QComboBox();
                 chartThemeComboBox->addItem(QStringLiteral("Light"));
                 chartThemeComboBox->addItem(QStringLiteral("Blue Cerulean"));
                 chartThemeComboBox->addItem(QStringLiteral("Dark"));
                 chartThemeComboBox->addItem(QStringLiteral("Brown Sand"));
                 chartThemeComboBox->addItem(QStringLiteral("Blue Ncs"));
                 chartThemeComboBox->addItem(QStringLiteral("High Contrast"));
                 chartThemeComboBox->addItem(QStringLiteral("Blue Icy"));
                 chartThemeComboBox->addItem(QStringLiteral("Qt"));
                 connect(chartThemeComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(changeChartTheme(int)));
                 layout->addWidget(chartThemeComboBox, row++, 1, Qt::AlignLeft);
                 layout->addWidget(new QLabel(QStringLiteral("Axis X:")), row, 0, Qt::AlignLeft);
                 QComboBox *axisXComboBox = new QComboBox();
                 axisXComboBox->addItem(QStringLiteral("BarCategory"));
                 axisXComboBox->addItem(QStringLiteral("DateTime"));
                 axisXComboBox->addItem(QStringLiteral("Value"));
                 connect(axisXComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAxisX(int)));
                 layout->addWidget(axisXComboBox, row++, 1, Qt::AlignLeft);
                 return layout;
             }
             QGridLayout *MainWidget::createModelMapperControlsLayout()
             {
                 QGridLayout *layout = new QGridLayout();
                 int row = 0;
                 layout->addWidget(new QLabel(QStringLiteral("First series:")), row, 0, Qt::AlignLeft);
                 QPushButton *attachModelMapperButton = new QPushButton(QStringLiteral("Attach model mapper"));
                 connect(attachModelMapperButton, SIGNAL(clicked(bool)), this, SLOT(attachModelMapper()));
                 layout->addWidget(attachModelMapperButton, row++, 1, Qt::AlignLeft);
                 QPushButton *detachModelMappeButton = new QPushButton(QStringLiteral("Detach model mapper"));
                 connect(detachModelMappeButton, SIGNAL(clicked(bool)), this, SLOT(detachModelMapper()));
                 layout->addWidget(detachModelMappeButton, row++, 1, Qt::AlignLeft);
                 QTableView *tableView = new QTableView();
                 tableView->setMinimumSize(320, 480);
                 tableView->setMaximumSize(320, 480);
                 tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
                 Q_ASSERT_X(m_hModelMapper->model(), Q_FUNC_INFO, "Model is not initialized");
                 tableView->setModel(m_hModelMapper->model());
                 layout->addWidget(tableView, row++, 0, 1, 2, Qt::AlignLeft);
                 layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Fixed, QSizePolicy::Expanding), row++, 0);
                 return layout;
             }
             qreal MainWidget::randomValue(int min, int max) const
             {
                 return (qrand() / (qreal(RAND_MAX) + 1)) * ((qMax(min, max) - qMin(min, max)) + qMin(min, max));
             }
             QCandlestickSet *MainWidget::randomSet(qreal timestamp)
             {
                 QCandlestickSet *set = new QCandlestickSet(timestamp);
                 set->setOpen(randomValue(4, 11));
                 set->setHigh(randomValue(12, 15));
                 set->setLow(randomValue(0, 3));
                 set->setClose(randomValue(4, 11));
                 return set;
             }
             void MainWidget::updateAxes()
             {
                 if (m_chart->axes().isEmpty())
                     m_chart->createDefaultAxes();
                 QCandlestickSeries *series;
                 if (!m_chart->series().isEmpty())
                     series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
                 else
                     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);
                         if (m_axisX->type() == QAbstractAxis::AxisTypeDateTime)
                             m_axisX->setRange(minDateTime, maxDateTime);
                         else
                             m_axisX->setRange(min, max);
                     }
                 }
                 m_axisY = m_chart->axes(Qt::Vertical).first();
                 m_axisY->setMax(15);
                 m_axisY->setMin(0);
             }
             void MainWidget::addSeries()
             {
                 if (m_chart->series().count() > 9) {
                     qDebug() << "Maximum series count is 10";
                     return;
                 }
                 QCandlestickSeries *series = new QCandlestickSeries();
                 series->setName(QStringLiteral("S%1").arg(m_chart->series().count() + 1));
                 series->setMaximumColumnWidth(m_maximumColumnWidth);
                 series->setMinimumColumnWidth(m_minimumColumnWidth);
                 series->setBodyOutlineVisible(m_bodyOutlineVisible);
                 series->setBodyWidth(m_bodyWidth);
                 series->setCapsVisible(m_capsVisible);
                 series->setCapsWidth(m_capsWidth);
                 if (m_chart->series().isEmpty()) {
                     if (m_customIncreasingColor)
                         series->setIncreasingColor(QColor(Qt::green));
                     if (m_customDecreasingColor)
                         series->setDecreasingColor(QColor(Qt::red));
                     for (int month = 1; month <= 12; ++month) {
                         QDateTime dateTime;
                         dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), month, 1));
                         dateTime.setTime(QTime(12, 34, 56, 789));
                         QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
                         series->append(set);
                     }
                 } 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);
                     }
                 }
                 m_chart->addSeries(series);
                 updateAxes();
                 if (!series->attachedAxes().contains(m_axisX))
                     series->attachAxis(m_axisX);
                 if (!series->attachedAxes().contains(m_axisY))
                     series->attachAxis(m_axisY);
             }
             void MainWidget::removeSeries()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 if (m_chart->series().count() == 1)
                     detachModelMapper();
                 QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().last());
                 m_chart->removeSeries(series);
                 delete series;
                 series = nullptr;
             }
             void MainWidget::removeAllSeries()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 detachModelMapper();
                 m_chart->removeAllSeries();
             }
             void MainWidget::addSet()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     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));
                         dateTime.setTime(QTime(12, 34, 56, 789));
                     }
                     QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
                     series->append(set);
                 }
                 updateAxes();
             }
             void MainWidget::insertSet()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     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));
                         dateTime.setTime(QTime(12, 34, 56, 789));
                     }
                     QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
                     series->insert(0, set);
                 }
                 updateAxes();
             }
             void MainWidget::removeSet()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 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();
             }
             void MainWidget::removeAllSets()
             {
                 if (m_chart->series().isEmpty()) {
                     qDebug() << "Create a series first";
                     return;
                 }
                 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();
                 }
                 updateAxes();
             }
             void MainWidget::changeMaximumColumnWidth(double width)
             {
                 m_maximumColumnWidth = width;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setMaximumColumnWidth(m_maximumColumnWidth);
                 }
             }
             void MainWidget::changeMinimumColumnWidth(double width)
             {
                 m_minimumColumnWidth = width;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setMinimumColumnWidth(m_minimumColumnWidth);
                 }
             }
             void MainWidget::bodyOutlineVisibleToggled(bool visible)
             {
                 m_bodyOutlineVisible = visible;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setBodyOutlineVisible(m_bodyOutlineVisible);
                 }
             }
             void MainWidget::capsVisibleToggled(bool visible)
             {
                 m_capsVisible = visible;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setCapsVisible(m_capsVisible);
                 }
             }
             void MainWidget::changeBodyWidth(double width)
             {
                 m_bodyWidth = width;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setBodyWidth(m_bodyWidth);
                 }
             }
             void MainWidget::changeCapsWidth(double width)
             {
                 m_capsWidth = width;
                 foreach (QAbstractSeries *s, m_chart->series()) {
                     QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
                     series->setCapsWidth(m_capsWidth);
                 }
             }
             void MainWidget::customIncreasingColorToggled(bool custom)
             {
                 m_customIncreasingColor = custom;
                 if (m_chart->series().isEmpty())
                     return;
                 QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
                 if (series) {
                     QColor color = m_customIncreasingColor ? QColor(Qt::green) : QColor();
                     series->setIncreasingColor(color);
                 }
             }
             void MainWidget::customDecreasingColorToggled(bool custom)
             {
                 m_customDecreasingColor = custom;
                 if (m_chart->series().isEmpty())
                     return;
                 QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
                 if (series) {
                     QColor color = m_customDecreasingColor ? QColor(Qt::red) : QColor();
                     series->setDecreasingColor(color);
                 }
             }
             void MainWidget::antialiasingToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::animationToggled(bool enabled)
             {
                 if (enabled)
                     m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 else
                     m_chart->setAnimationOptions(QChart::NoAnimation);
             }
             void MainWidget::legendToggled(bool visible)
             {
                 m_chart->legend()->setVisible(visible);
                 if (visible)
                     m_chart->legend()->setAlignment(Qt::AlignBottom);
             }
             void MainWidget::titleToggled(bool visible)
             {
                 if (visible)
                     m_chart->setTitle(QStringLiteral("Candlestick Chart"));
                 else
                     m_chart->setTitle(QString());
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 if (themeIndex < QChart::ChartThemeLight || themeIndex > QChart::ChartThemeQt) {
                     qDebug() << "Invalid chart theme index:" << themeIndex;
                     return;
                 }
                 m_chart->setTheme((QChart::ChartTheme)(themeIndex));
             }
             void MainWidget::changeAxisX(int axisXIndex)
             {
                 if (m_axisX) {
                     m_chart->removeAxis(m_axisX);
                     delete m_axisX;
                 }
                 switch (axisXIndex) {
                 case 0:
                     m_axisX = new QBarCategoryAxis();
                     break;
                 case 1:
                     m_axisX = new QDateTimeAxis();
                     break;
                 case 2:
                     m_axisX = new QValueAxis();
                     break;
                 default:
                     qDebug() << "Invalid axis x index:" << axisXIndex;
                     return;
                 }
                 m_chart->addAxis(m_axisX, Qt::AlignBottom);
                 updateAxes();
                 foreach (QAbstractSeries *series, m_chart->series())
                     series->attachAxis(m_axisX);
             }
             void MainWidget::attachModelMapper()
             {
                 if (m_hModelMapper->series()) {
                     qDebug() << "Model mapper is already attached";
                     return;
                 }
                 if (m_chart->series().isEmpty())
                     addSeries();
                 QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
                 Q_ASSERT(series);
                 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);
             }
             void MainWidget::detachModelMapper()
             {
                 if (!m_hModelMapper->series())
                     return;
                 QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_hModelMapper->series());
                 Q_ASSERT(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