File indexing completed on 2025-03-09 03:42:14

 /*
  * This file is part of KQuickCharts
  * SPDX-FileCopyrightText: 2019 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  */
 
 #include "HistoryProxySource.h"
 
 #include <QDebug>
 
 HistoryProxySource::HistoryProxySource(QObject *parent)
     : ChartDataSource(parent)
 {
 }
 
 int HistoryProxySource::itemCount() const
 {
     if (m_fillMode == DoNotFill) {
         return m_history.size();
     } else {
         return m_maximumHistory;
     }
 }
 
 QVariant HistoryProxySource::item(int index) const
 {
     if (index < 0 || !m_dataSource || m_dataSource->itemCount() == 0) {
         return QVariant{};
     }
 
     if (m_fillMode == DoNotFill && index >= m_history.count()) {
         return QVariant{};
     }
 
     if (m_fillMode == FillFromStart && index >= m_history.count()) {
         return QVariant{QMetaType(m_dataSource->item(0).userType())};
     }
 
     if (m_fillMode == FillFromEnd && m_history.count() != m_maximumHistory) {
         auto actualIndex = index - (m_maximumHistory - m_history.count());
         if (actualIndex < 0 || actualIndex >= m_history.size()) {
             return QVariant{QMetaType(m_dataSource->item(0).userType())};
         } else {
             return m_history.at(actualIndex);
         }
     }
 
     if (index < m_history.count()) {
         return m_history.at(index);
     } else {
         return QVariant{};
     }
 }
 
 QVariant HistoryProxySource::minimum() const
 {
     if (m_history.isEmpty() || !m_dataSource) {
         return QVariant{};
     }
 
     // TODO: Find a nicer solution for data sources to indicate
     // "I provide a min/max value not derived from my items"
     auto model = m_dataSource->property("model").value<QObject *>();
     if (model) {
         auto minProperty = model->property("minimum");
         auto maxProperty = model->property("maximum");
         if (minProperty.isValid() && minProperty != maxProperty) {
             return minProperty;
         }
     }
 
     return *std::min_element(m_history.begin(), m_history.end(), variantCompare);
 }
 
 QVariant HistoryProxySource::maximum() const
 {
     if (m_history.isEmpty() || !m_dataSource) {
         return QVariant{};
     }
 
     auto model = m_dataSource->property("model").value<QObject *>();
     if (model) {
         auto minProperty = model->property("minimum");
         auto maxProperty = model->property("maximum");
         if (maxProperty.isValid() && maxProperty != minProperty) {
             return maxProperty;
         }
     }
 
     return *std::max_element(m_history.begin(), m_history.end(), variantCompare);
 }
 
 QVariant HistoryProxySource::first() const
 {
     if (!m_history.isEmpty()) {
         return m_history.first();
     }
     return QVariant{};
 }
 
 ChartDataSource *HistoryProxySource::source() const
 {
     return m_dataSource;
 }
 
 void HistoryProxySource::setSource(ChartDataSource *newSource)
 {
     if (newSource == m_dataSource) {
         return;
     }
 
     if (m_dataSource) {
         m_dataSource->disconnect(this);
     }
 
     m_dataSource = newSource;
     clear();
     if (m_dataSource) {
         connect(m_dataSource, &ChartDataSource::dataChanged, this, [this]() {
             if (!m_updateTimer) {
                 update();
             }
         });
     }
     Q_EMIT sourceChanged();
 }
 
 int HistoryProxySource::item() const
 {
     return m_item;
 }
 
 void HistoryProxySource::setItem(int newItem)
 {
     if (newItem == m_item) {
         return;
     }
 
     m_item = newItem;
     clear();
     Q_EMIT itemChanged();
 }
 
 int HistoryProxySource::maximumHistory() const
 {
     return m_maximumHistory;
 }
 
 void HistoryProxySource::setMaximumHistory(int newMaximumHistory)
 {
     if (newMaximumHistory == m_maximumHistory) {
         return;
     }
 
     m_maximumHistory = newMaximumHistory;
     while (m_history.size() > 0 && m_history.size() > m_maximumHistory) {
         m_history.removeLast();
     }
 
     Q_EMIT maximumHistoryChanged();
 }
 
 int HistoryProxySource::interval() const
 {
     return m_updateTimer ? m_updateTimer->interval() : -1;
 }
 
 void HistoryProxySource::setInterval(int newInterval)
 {
     if (m_updateTimer && newInterval == m_updateTimer->interval()) {
         return;
     }
 
     if (newInterval > 0) {
         if (!m_updateTimer) {
             m_updateTimer = std::make_unique<QTimer>();
             // We need precise timers to avoid missing updates when dealing with semi-constantly
             // updating source. That is, if the source updates at 500ms and we also update at that
             // rate, a drift of 2ms can cause us to miss updates.
             m_updateTimer->setTimerType(Qt::PreciseTimer);
             connect(m_updateTimer.get(), &QTimer::timeout, this, &HistoryProxySource::update);
         }
         m_updateTimer->setInterval(newInterval);
         m_updateTimer->start();
     } else {
         m_updateTimer.reset();
     }
 
     Q_EMIT intervalChanged();
 }
 
 HistoryProxySource::FillMode HistoryProxySource::fillMode() const
 {
     return m_fillMode;
 }
 
 void HistoryProxySource::setFillMode(FillMode newFillMode)
 {
     if (newFillMode == m_fillMode) {
         return;
     }
 
     m_fillMode = newFillMode;
     clear();
     Q_EMIT fillModeChanged();
 }
 
 void HistoryProxySource::clear()
 {
     m_history.clear();
     Q_EMIT dataChanged();
 }
 
 void HistoryProxySource::update()
 {
     if (!m_dataSource) {
         return;
     }
 
     m_history.prepend(m_dataSource->item(m_item));
     while (m_history.size() > 0 && m_history.size() > m_maximumHistory) {
         m_history.removeLast();
     }
 
     Q_EMIT dataChanged();
 }
 
 #include "moc_HistoryProxySource.cpp"