| /**************************************************************************** |
| ** |
| ** 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> |
| |
| #include <algorithm> |
| |
| QT_CHARTS_BEGIN_NAMESPACE |
| |
| /*! |
| \class QCandlestickModelMapper |
| \since 5.8 |
| \inmodule QtCharts |
| \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 firstSetSection specifies the section of the model. Default value is -1. |
| */ |
| void QCandlestickModelMapper::setFirstSetSection(int firstSetSection) |
| { |
| Q_D(QCandlestickModelMapper); |
| |
| firstSetSection = qMax(firstSetSection, -1); |
| |
| if (d->m_firstSetSection == firstSetSection) |
| return; |
| |
| d->m_firstSetSection = firstSetSection; |
| 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::firstSetSection() const |
| { |
| Q_D(const QCandlestickModelMapper); |
| |
| return d->m_firstSetSection; |
| } |
| |
| /*! |
| Sets the section of the model that is used as the data source for the last candlestick set. |
| Parameter \a lastSetSection specifies the section of the model. Default value is -1. |
| */ |
| void QCandlestickModelMapper::setLastSetSection(int lastSetSection) |
| { |
| Q_D(QCandlestickModelMapper); |
| |
| lastSetSection = qMax(lastSetSection, -1); |
| |
| if (d->m_lastSetSection == lastSetSection) |
| return; |
| |
| d->m_lastSetSection = lastSetSection; |
| 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::lastSetSection() const |
| { |
| Q_D(const QCandlestickModelMapper); |
| |
| 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_firstSetSection(-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_sets.clear(); |
| |
| // create the initial candlestick sets |
| QList<QCandlestickSet *> sets; |
| 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())); |
| |
| sets.append(set); |
| } else { |
| break; |
| } |
| } |
| m_series->append(sets); |
| 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_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_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_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_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->sets().indexOf(sets.at(0)); |
| if (firstIndex == -1) |
| return; |
| |
| m_lastSetSection += sets.count(); |
| |
| blockModelSignals(); |
| if (q->orientation() == Qt::Vertical) |
| m_model->insertColumns(firstIndex + m_firstSetSection, sets.count()); |
| else |
| m_model->insertRows(firstIndex + m_firstSetSection, sets.count()); |
| |
| for (int i = 0; i < sets.count(); ++i) { |
| 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; |
| |
| QVector<int> removedIndices; |
| for (auto &set : sets) { |
| int index = m_sets.indexOf(set); |
| if (index != -1) |
| removedIndices << index; |
| } |
| |
| if (removedIndices.isEmpty()) |
| return; |
| |
| std::sort(removedIndices.begin(), removedIndices.end()); |
| |
| for (int i = removedIndices.size() - 1; i >= 0; --i) { |
| m_sets.removeAt(removedIndices[i]); |
| --m_lastSetSection; |
| } |
| |
| blockModelSignals(); |
| |
| // There is no guarantee removed sets are continuous, so remove them one by one |
| for (int i = removedIndices.size() - 1; i >= 0; --i) { |
| if (q->orientation() == Qt::Vertical) |
| m_model->removeColumns(removedIndices[i] + m_firstSetSection, 1); |
| else |
| m_model->removeRows(removedIndices[i] + m_firstSetSection, 1); |
| } |
| |
| blockModelSignals(false); |
| initializeCandlestickFromModel(); |
| } |
| |
| void QCandlestickModelMapperPrivate::candlestickSetChanged() |
| { |
| if (m_seriesSignalsBlock) |
| return; |
| |
| QCandlestickSet *set = qobject_cast<QCandlestickSet *>(QObject::sender()); |
| if (!set) |
| return; |
| |
| int section = m_series->sets().indexOf(set); |
| if (section < 0) |
| return; |
| |
| 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_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->sets().at(section - m_firstSetSection); |
| } |
| |
| QModelIndex QCandlestickModelMapperPrivate::candlestickModelIndex(int section, int pos) |
| { |
| Q_Q(QCandlestickModelMapper); |
| |
| 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; |
| } |
| |
| QT_CHARTS_END_NAMESPACE |
| |
| #include "moc_qcandlestickmodelmapper.cpp" |
| #include "moc_qcandlestickmodelmapper_p.cpp" |