GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r235:746eaca503e3

The mock plugin can now create data with view operation

perrinel -

r235:746eaca503e3

parent child

Context file:

r235:746eaca503e3

core/include/Variable/Variable.h +13 -4

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
-            class Variable {
+            class Variable : public QObject {
+                Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QString &unit, const QString &mission,
                                   const SqpDateTime &dateTime);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
+                SqpDateTime dateTime() const noexcept;
-                void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
+                bool contains(SqpDateTime dateTime);
+                void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
-                void onXRangeChanged(SqpDateTime dateTime);
+                void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+            signals:
+                void dataCacheUpdated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableController.h +7 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
+            #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
+                /// Request the data loading of the variable whithin dateTime
+                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/src/Variable/Variable.cpp +20 -5

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission,
                                          const SqpDateTime &dateTime)
                         : m_Name{name},
                           m_Unit{unit},
                           m_Mission{mission},
                           m_DateTime{dateTime},
                           m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
             Variable::Variable(const QString &name, const QString &unit, const QString &mission,
                                const SqpDateTime &dateTime)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
-            void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+            SqpDateTime Variable::dateTime() const noexcept
+            {
+                return impl->m_DateTime;
+            }
+            void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
-                /// @todo : else, merge the two data series (if possible)
+            void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
+            {
+                if (impl->m_DataSeries) {
+                    impl->m_DataSeries->merge(dataSeries.get());
+                    emit dataCacheUpdated();
+                }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
-            void Variable::onXRangeChanged(SqpDateTime dateTime)
+            bool Variable::contains(SqpDateTime dateTime)
             {
-                qCInfo(LOG_Variable()) << "onXRangeChanged detected";
                 if (!impl->m_DateTime.contains(dateTime)) {
                     // The current variable dateTime isn't enough to display the dateTime requested.
                     // We have to update it to the new dateTime requested.
                     // the correspondant new data to display will be given by the cache if possible and the
                     // provider if necessary.
                     qCInfo(LOG_Variable()) << "NEW DATE NEEDED";
                     impl->m_DateTime = dateTime;
+                    return false;
                 }
+                return true;
             }

core/src/Variable/VariableController.cpp +48 -7

+            #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
+            #include <QElapsedTimer>
             #include <QMutex>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
+                std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
+                    m_VariableToProviderMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
-                // TORM
-                //    auto dateTime = SqpDateTime{
-                //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
-                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
-                //                            / 1000.),
-                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
-                //            / 1000.};
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(
                         name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
+                    // store the provider
+                    impl->m_VariableToProviderMap[newVariable] = provider;
+                    qRegisterMetaType<std::shared_ptr<IDataSeries> >();
+                    qRegisterMetaType<SqpDateTime>();
+                    connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
+                            &Variable::onAddDataSeries);
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
+            void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
+                                                        const SqpDateTime &dateTime)
+            {
+                // we want to load data of the variable for the dateTime.
+                // First we check if the cache contains some of them.
+                // For the other, we ask the provider to give them.
+                if (variable) {
+                    QElapsedTimer timer;
+                    timer.start();
+                    qCInfo(LOG_VariableController()) << "The slow s0 operation took" << timer.elapsed()
+                                                     << "milliseconds";
+                    auto dateTimeListNotInCache
+                        = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
+                    qCInfo(LOG_VariableController()) << "The slow s1 operation took" << timer.elapsed()
+                                                     << "milliseconds";
+                    // Ask the provider for each data on the dateTimeListNotInCache
+                    impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
+                    qCInfo(LOG_VariableController()) << "The slow s2 operation took" << timer.elapsed()
+                                                     << "milliseconds";
+                    // store in cache
+                    impl->m_VariableCacheController->addDateTime(variable, dateTime);
+                    qCInfo(LOG_VariableController()) << "The slow s3 operation took" << timer.elapsed()
+                                                     << "milliseconds";
+                }
+                else {
+                    qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
+                }
+            }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableModel.cpp +1 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto UNIT_COLUMN = 1;
             const auto MISSION_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable>
             VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
                                           std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
                 auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                            QStringLiteral("mission"), dateTime);
-                variable->addDataSeries(std::move(defaultDataSeries));
+                variable->setDataSeries(std::move(defaultDataSeries));
                 impl->m_Variables.push_back(variable);
                 endInsertRows();
                 return variable;
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case UNIT_COLUMN:
                                 return variable->unit();
                             case MISSION_COLUMN:
                                 return variable->mission();
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     switch (section) {
                         case NAME_COLUMN:
                             return tr("Name");
                         case UNIT_COLUMN:
                             return tr("Unit");
                         case MISSION_COLUMN:
                             return tr("Mission");
                         default:
                             // No action
                             break;
                     }
                     qWarning(LOG_VariableModel())
                         << tr("Can't get header data (unknown column %1)").arg(section);
                 }
                 return QVariant{};
             }

gui/include/DataSource/DataSourceWidget.h +1 0

             #ifndef SCIQLOP_DATASOURCEWIDGET_H
             #define SCIQLOP_DATASOURCEWIDGET_H
             #include <QWidget>
             namespace Ui {
             class DataSourceWidget;
             } // Ui
             class DataSourceItem;
             /**
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
             class DataSourceWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit DataSourceWidget(QWidget *parent = 0);
+                virtual ~DataSourceWidget() noexcept;
             public slots:
                 /**
                  * Adds a data source. An item associated to the data source is created and then added to the
                  * representation tree
                  * @param dataSource the data source to add. The pointer has to be not null
                  */
                 void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
                 Ui::DataSourceWidget *ui;
             private slots:
                 /// Slot called when right clicking on an item in the tree (displays a menu)
                 void onTreeMenuRequested(const QPoint &pos) noexcept;
             };
             #endif // SCIQLOP_DATASOURCEWIDGET_H

gui/include/Visualization/GraphPlottablesFactory.h +6 0

             #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
             #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QVector>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
+            class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
              * @brief The GraphPlottablesFactory class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
             struct GraphPlottablesFactory {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
                 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                               QCustomPlot &plot) noexcept;
+                static void updateData(QVector<QCPAbstractPlottable *> plotableVect, IDataSeries *dataSeries,
+                                       const SqpDateTime &dateTime);
             };
             #endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H

gui/include/Visualization/VisualizationGraphWidget.h +5 0

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 void close() override;
                 QString name() const override;
+                void updateDisplay(std::shared_ptr<Variable> variable);
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
+                void onDataCacheVariableUpdated();
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/src/Visualization/GraphPlottablesFactory.cpp +63 -3

             #include "Visualization/GraphPlottablesFactory.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
+            #include <QElapsedTimer>
             Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
             namespace {
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
-            QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot)
+            void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
+                                  const SqpDateTime &dateTime)
+            {
+                QElapsedTimer timer;
+                timer.start();
+                if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
+                    // Clean the graph
+                    qCDebug(LOG_GraphPlottablesFactory()) << "The slow s1 operation took" << timer.elapsed()
+                                                          << "milliseconds";
+                    // NAIVE approch
+                    const auto &xData = scalarSeries.xAxisData()->data();
+                    const auto &valuesData = scalarSeries.valuesData()->data();
+                    auto xValue = QVector<double>();
+                    auto vValue = QVector<double>();
+                    const auto count = xData.count();
+                    auto ite = 0;
+                    for (auto i = 0; i < count; ++i) {
+                        const auto x = xData.at(i);
+                        if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
+                            xValue.push_back(x);
+                            vValue.push_back(valuesData.at(i));
+                            ++ite;
+                        }
+                    }
+                    qcpGraph->setData(xValue, vValue);
+                    qCDebug(LOG_GraphPlottablesFactory()) << "The slow s2 operation took" << timer.elapsed()
+                                                          << "milliseconds";
+                }
+                else {
+                    /// @todo DEBUG
+                }
+            }
+            QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
+                                                              const SqpDateTime &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
-                    // Graph data
+                    //        // Graph data
                     component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
                                        true);
+                    updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                     /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
                     setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_GraphPlottablesFactory())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<Variable> variable,
                                                                            QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
-                        result.append(createScalarSeriesComponent(*scalarSeries, plot));
+                        result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
                     }
                     else {
                         qCDebug(LOG_GraphPlottablesFactory())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_GraphPlottablesFactory())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
+            void GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *> plotableVect,
+                                                    IDataSeries *dataSeries, const SqpDateTime &dateTime)
+            {
+                if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
+                    if (plotableVect.size() == 1) {
+                        updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
+                    }
+                    else {
+                        qCCritical(LOG_GraphPlottablesFactory()) << QObject::tr(
+                            "Can't update Data of a scalarSeries because there is not only one component "
+                            "associated");
+                    }
+                }
+                else {
+                    /// @todo DEBUG
+                }
+            }

gui/src/Visualization/VisualizationGraphWidget.cpp +49 -5

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/GraphPlottablesFactory.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationGraphWidget.h"
+            #include <Data/ArrayData.h>
+            #include <Data/IDataSeries.h>
+            #include <SqpApplication.h>
             #include <Variable/Variable.h>
+            #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
-                std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
+                std::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
+                    m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // qcpplot title
                 ui->widget->plotLayout()->insertRow(0);
                 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
-                    impl->m_VariableToPlotMap.insert({variable, createdPlottable});
+                    impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
+                connect(variable.get(), &Variable::dataCacheUpdated, this,
+                        &VisualizationGraphWidget::onDataCacheVariableUpdated);
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
                 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
                     return title->text();
                 }
                 else {
                     return QString{};
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
-                for (auto it = impl->m_VariableToPlotMap.cbegin(); it != impl->m_VariableToPlotMap.cend();
-                     ++it) {
+                qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
-                    it->first->onXRangeChanged(SqpDateTime{t2.lower, t2.upper});
+                for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+                     it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+                    auto variable = it->first;
+                    auto tolerance = 0.1 * (t2.upper - t2.lower);
+                    auto dateTime = SqpDateTime{t2.lower - tolerance, t2.upper + tolerance};
+                    qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
+                                                           << variable->dataSeries()->xAxisData()->size();
+                    if (!variable->contains(dateTime)) {
+                        sqpApp->variableController().requestDataLoading(variable, dateTime);
+                    }
                 }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
+            void VisualizationGraphWidget::onDataCacheVariableUpdated()
+            {
+                for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+                     it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+                    auto variable = it->first;
+                    GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                                                       variable->dataSeries(), variable->dateTime());
+                }
+            }
+            void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
+            {
+                auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
+                auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
+                for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
+                    abstractPlotableVect.push_back(it->second);
+                }
+                GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
+                                                   variable->dateTime());
+            }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

		ok
		I'll go back on it for the next sprint.
		Changed for visualizationGraphHelper
		OK, I will add TOREMOVE Prefix message
		We could, but for the moment it's not necessary.

	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