GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r321:b1c50789867a

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r321:b1c50789867a

parent child

Context file:

r321:b1c50789867a

Collapse all files

core/include/Data/SqpDateTime.h +2 -2

             #ifndef SCIQLOP_SQPDATETIME_H
             #define SCIQLOP_SQPDATETIME_H
             #include <QObject>
             #include <QDateTime>
             #include <QDebug>
             #include <Common/MetaTypes.h>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
                 /// Start time
                 double m_TStart;
                 /// End time
                 double m_TEnd;
-                bool contains(const SqpDateTime &dateTime)
+                bool contains(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
-                bool intersect(const SqpDateTime &dateTime)
+                bool intersect(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
             };
             inline QDebug operator<<(QDebug d, SqpDateTime obj)
             {
                 auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
                 auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
                 //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPDATETIME_REGISTRY, SqpDateTime)
             #endif // SCIQLOP_SQPDATETIME_H

core/include/Variable/Variable.h +3 -2

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/MetaTypes.h>
             #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 : 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 setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
-                bool contains(const SqpDateTime &dateTime);
+                bool contains(const SqpDateTime &dateTime) const noexcept;
-                bool intersect(const SqpDateTime &dateTime);
+                bool intersect(const SqpDateTime &dateTime) const noexcept;
+                bool isInside(const SqpDateTime &dateTime) const noexcept;
             public slots:
                 void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableModel.h +2 -4

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
             #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class VariableModel : public QAbstractTableModel {
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
-                 * @param defaultDataSeries the default data of the new variable
                  * @return the pointer to the new variable
                  */
-                std::shared_ptr<Variable>
+                std::shared_ptr<Variable> createVariable(const QString &name,
-                createVariable(const QString &name, const SqpDateTime &dateTime,
+                                                         const SqpDateTime &dateTime) noexcept;
-                               std::shared_ptr<IDataSeries> defaultDataSeries) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLEMODEL_H

core/src/Variable/Variable.cpp +7 -2

             #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;
             }
             SqpDateTime Variable::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
             void Variable::setDateTime(const SqpDateTime &dateTime) noexcept
             {
                 impl->m_DateTime = dateTime;
             }
             void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 // Inits the data series of the variable
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit updated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
-            bool Variable::contains(const SqpDateTime &dateTime)
+            bool Variable::contains(const SqpDateTime &dateTime) const noexcept
             {
                 return impl->m_DateTime.contains(dateTime);
             }
-            bool Variable::intersect(const SqpDateTime &dateTime)
+            bool Variable::intersect(const SqpDateTime &dateTime) const noexcept
             {
                 return impl->m_DateTime.intersect(dateTime);
             }
+            bool Variable::isInside(const SqpDateTime &dateTime) const noexcept
+            {
+                return dateTime.contains(SqpDateTime{impl->m_DateTime.m_TStart, impl->m_DateTime.m_TEnd});
+            }

core/src/Variable/VariableCacheController.cpp +6 -7

             #include "Variable/VariableCacheController.h"
             #include "Variable/Variable.h"
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
                     m_VariableToSqpDateTimeListMap;
                 void addInCacheDataByEnd(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                          QVector<SqpDateTime> &notInCache, int cacheIndex,
                                          double currentTStart);
                 void addInCacheDataByStart(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                            QVector<SqpDateTime> &notInCache, int cacheIndex,
                                            double currentTStart);
                 void addDateTimeRecurse(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                         int cacheIndex);
             };
             VariableCacheController::VariableCacheController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
             {
             }
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
                         impl->m_VariableToSqpDateTimeListMap[variable].push_back(dateTime);
                     }
                     else {
                         // addDateTime modify the list<SqpDateTime> of the variable in a way to ensure
                         // that the list is ordered : l(0) < l(1). We assume also a < b
                         // (with a & b of type SqpDateTime) means ts(b) > te(a)
                         // The algorithm will try the merge of two interval:
                         // - dateTime will be compare with the first interval of the list:
                         //   A: if it is inferior, it will be inserted and it's finished.
                         //   B: if it is in intersection, it will be merge then the merged one
                         //      will be compared to the next interval. The old one is remove from the list
                         //   C: if it is superior, we do the same with the next interval of the list
                         try {
                             impl->addDateTimeRecurse(dateTime,
                                                      impl->m_VariableToSqpDateTimeListMap.at(variable), 0);
                         }
                         catch (const std::out_of_range &e) {
-                            qCWarning(LOG_VariableCacheController()) << e.what();
+                            qCWarning(LOG_VariableCacheController()) << "addDateTime" << e.what();
                         }
                     }
                 }
             }
             QVector<SqpDateTime>
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
                 // list of date time request associated to the variable
                 // We assume that the list is ordered in a way that l(0) < l(1). We assume also a < b
                 // (with a & b of type SqpDateTime) means ts(b) > te(a)
+                auto it = impl->m_VariableToSqpDateTimeListMap.find(variable);
-                try {
+                if (it != impl->m_VariableToSqpDateTimeListMap.end()) {
-                    impl->addInCacheDataByStart(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
+                    impl->addInCacheDataByStart(dateTime, it->second, notInCache, 0, dateTime.m_TStart);
-                                                notInCache, 0, dateTime.m_TStart);
                 }
-                catch (const std::out_of_range &e) {
+                else {
-                    qCWarning(LOG_VariableCacheController()) << e.what();
+                    notInCache << dateTime;
                 }
                 return notInCache;
             }
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }
                 catch (const std::out_of_range &e) {
                     qCWarning(LOG_VariableCacheController()) << e.what();
                     return QVector<SqpDateTime>{};
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList, int cacheIndex)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     dateTimeList.push_back(dateTime);
                     // there is no anymore interval to compore, we can just push_back it
                     return;
                 }
                 auto currentDateTime = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd < currentDateTime.m_TStart) {
                     // The compared one is < to current one compared, we can insert it
                     dateTimeList.insert(cacheIndex, dateTime);
                 }
                 else if (dateTime.m_TStart > currentDateTime.m_TEnd) {
                     // The compared one is > to current one compared  we can comparet if to the next one
                     addDateTimeRecurse(dateTime, dateTimeList, ++cacheIndex);
                 }
                 else {
                     // Merge cases: we need to merge the two interval, remove the old one from the list then
                     // rerun the algo from this index with the merged interval
                     auto mTStart = std::min(dateTime.m_TStart, currentDateTime.m_TStart);
                     auto mTEnd = std::max(dateTime.m_TEnd, currentDateTime.m_TEnd);
                     auto mergeDateTime = SqpDateTime{mTStart, mTEnd};
                     dateTimeList.remove(cacheIndex);
                     addDateTimeRecurse(mergeDateTime, dateTimeList, cacheIndex);
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByEnd(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     if (currentTStart < dateTime.m_TEnd) {
                         // te localised after all other interval: The last interval is [currentTsart, te]
                         notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     }
                     return;
                 }
                 auto currentDateTimeJ = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd <= currentDateTimeJ.m_TStart) {
                     // te localised between to interval: The last interval is [currentTsart, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                 }
                 else {
                     notInCache.push_back(SqpDateTime{currentTStart, currentDateTimeJ.m_TStart});
                     if (dateTime.m_TEnd > currentDateTimeJ.m_TEnd) {
                         // te not localised before the current interval: we need to look at the next interval
                         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                             currentDateTimeJ.m_TEnd);
                     }
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByStart(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // ts localised after all other interval: The last interval is [ts, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     return;
                 }
                 auto currentDateTimeI = dateTimeList[cacheIndex];
                 if (currentTStart < currentDateTimeI.m_TStart) {
                     // ts localised between to interval: let's localized te
                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
                 else if (currentTStart < currentDateTimeI.m_TEnd) {
                     if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
                         // ts not localised before the current interval: we need to look at the next interval
                         // We can assume now current tstart is the last interval tend, because data between them
                         // are
                         // in the cache
                         addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                               currentDateTimeI.m_TEnd);
                     }
                 }
                 else {
                     // ts not localised before the current interval: we need to look at the next interval
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
                 }
             }
             void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) const
             {
                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.end()) {
                     qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
                                                           << variableDateTimeList->second;
                 }
                 else {
                     qCWarning(LOG_VariableCacheController())
                         << tr("Cannot display a variable that is not in the cache");
                 }
             }

core/src/Variable/VariableController.cpp +10 -8

             #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 <QMutex>
             #include <QThread>
             #include <QtCore/QItemSelectionModel>
             #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::shared_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_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 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;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 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(
+                if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
-                        name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
-                    connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
-                            &Variable::setDataSeries);
+                    auto addDateTimeAcquired
+                        = [this, newVariable](auto dataSeriesAcquired, auto dateTimeToPutInCache) {
-                    // store in cache
+                              impl->m_VariableCacheController->addDateTime(newVariable, dateTimeToPutInCache);
-                    impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
+                              newVariable->setDataSeries(dataSeriesAcquired);
+                          };
+                    connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
+                    this->onRequestDataLoading(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onRequestDataLoading(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) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             std::move(dateTimeListNotInCache));
-                        // store in cache
-                        impl->m_VariableCacheController->addDateTime(variable, dateTime);
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 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 +2 -4

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             #include <QDateTime>
             #include <QSize>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES
                 = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // 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>
+            std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
-            VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
+                                                                    const SqpDateTime &dateTime) noexcept
-                                          std::shared_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->setDataSeries(std::move(defaultDataSeries));
                 impl->m_Variables.push_back(variable);
                 endInsertRows();
                 return variable;
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             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()) {
                         /// Lambda function that builds the variant to return for a time value
                         auto dateTimeVariant = [](double time) {
                             auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TStart);
                             case TEND_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TEnd);
                             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 && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }

gui/include/Visualization/VisualizationGraphWidget.h +2 -1

             #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 SqpDateTime;
             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);
+                void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 QString name() const override;
                 void updateDisplay(std::shared_ptr<Variable> variable);
             signals:
                 void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
-                void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
+                void onRangeChanged(const QCPRange &t1);
                 /// 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/VisualizationGraphHelper.cpp +4 -2

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             #include <QElapsedTimer>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             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();
                 }
             }
             void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
                                   const SqpDateTime &dateTime)
             {
                 QElapsedTimer timer;
                 timer.start();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     // Clean the graph
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     const auto &valuesData = scalarSeries.valuesData()->data();
                     const auto count = xData.count();
                     qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
                     auto xValue = QVector<double>(count);
                     auto vValue = QVector<double>(count);
                     int n = 0;
                     for (auto i = 0; i < count; ++i) {
                         const auto x = xData[i];
                         if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
                             xValue[n] = x;
                             vValue[n] = valuesData[i];
                             ++n;
                         }
                     }
                     xValue.resize(n);
                     vValue.resize(n);
                     qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
                                                            << xValue.count();
                     qcpGraph->setData(xValue, vValue);
+                    // Display all data
+                    component->rescaleAxes();
+                    component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
                                                               const SqpDateTime &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // 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_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::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, variable->dateTime()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::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_VisualizationGraphHelper()) << 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 +45 -8

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.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::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);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // 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 &)>(
+                connect(ui->widget->xAxis,
-                                               &QCPAxis::rangeChanged),
+                        static_cast<void (QCPAxis::*)(const QCPRange &)>(&QCPAxis::rangeChanged), this,
-                        this, &VisualizationGraphWidget::onRangeChanged);
+                        &VisualizationGraphWidget::onRangeChanged);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
             }
             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 = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
+            void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
+            {
+                // when adding a variable, we need to set its time range to the current graph range
+                auto grapheRange = ui->widget->xAxis->range();
+                auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
+                variable->setDateTime(dateTime);
+                auto variableDateTimeWithTolerance = dateTime;
+                // add 10% tolerance for each side
+                auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
+                variableDateTimeWithTolerance.m_TStart -= tolerance;
+                variableDateTimeWithTolerance.m_TEnd += tolerance;
+                // Uses delegate to create the qcpplot components according to the variable
+                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                for (auto createdPlottable : qAsConst(createdPlottables)) {
+                    impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
+                }
+                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                // CHangement detected, we need to ask controller to request data loading
+                emit requestDataLoading(variable, variableDateTimeWithTolerance);
+            }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             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;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(mapToGlobal(pos));
                 }
             }
-            void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
+            void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
-                    auto dateTime = SqpDateTime{t2.lower, t2.upper};
+                    auto dateTime = SqpDateTime{t1.lower, t1.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
-                        if (variable->intersect(dateTime)) {
+                        if (!variable->isInside(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
+                                qCDebug(LOG_VisualizationGraphWidget()) << tr("TDetection pan to right:");
                                 auto diffEndToKeepDelta = dateTime.m_TEnd - variableDateTime.m_TEnd;
                                 dateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                 // Tolerance have to be added to the right
                                 // add 10% tolerance for right (end) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
-                            if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
+                            else if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
+                                qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection pan to left: ");
                                 auto diffStartToKeepDelta = variableDateTime.m_TStart - dateTime.m_TStart;
                                 dateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                 // Tolerance have to be added to the left
                                 // add 10% tolerance for left (start) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
+                            else {
+                                qCWarning(LOG_VisualizationGraphWidget())
+                                    << tr("Detection anormal zoom detection: ");
+                            }
                         }
                         else {
+                            qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom out: ");
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                             variableDateTimeWithTolerance.m_TStart -= tolerance;
                             variableDateTimeWithTolerance.m_TEnd += tolerance;
                         }
                         variable->setDateTime(dateTime);
                         // CHangement detected, we need to ask controller to request data loading
                         emit requestDataLoading(variable, variableDateTimeWithTolerance);
                     }
+                    else {
+                        qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom in: ");
+                    }
                 }
             }
             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()
             {
                 // NOTE:
                 //    We don't want to call the method for each component of a variable unitarily, but for
                 //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     VisualizationGraphHelper::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);
                 }
                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
                                                      variable->dateTime());
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +1 -1

             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/MenuBuilder.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include <Variable/Variable.h>
             #include <QMenu>
             #include <QStack>
             Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
             struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
                 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
                         : m_Variable{variable}, m_MenuBuilder{menu}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
                     m_MenuBuilder.addMenu(QObject::tr("Plot"));
                 }
                 void visitRootLeave()
                 {
                     // Closes the root menu
                     m_MenuBuilder.closeMenu();
                 }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
                     m_MenuBuilder.addMenu(container.name());
                 }
                 template <typename ActionFun>
                 void visitNodeLeave(const IVisualizationWidget &container, const QString &actionName,
                                     ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
                         m_MenuBuilder.addSeparator();
                         m_MenuBuilder.addAction(actionName, actionFunction);
                     }
                     // Closes the menu associated to the node
                     m_MenuBuilder.closeMenu();
                 }
                 template <typename ActionFun>
                 void visitLeaf(const IVisualizationWidget &container, const QString &actionName,
                                ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
                         m_MenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 std::shared_ptr<Variable> m_Variable;
                 MenuBuilder m_MenuBuilder;
             };
             GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
                                                                          std::shared_ptr<Variable> variable)
                     : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
             {
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
                 impl->visitRootEnter();
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
                 impl->visitRootLeave();
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
                     impl->visitNodeEnter(*tabWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
                     impl->visitNodeLeave(
                         *tabWidget, QObject::tr("Open in a new zone"),
                         [ var = impl->m_Variable, tabWidget ]() { tabWidget->createZone(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     impl->visitNodeEnter(*zoneWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     impl->visitNodeLeave(
                         *zoneWidget, QObject::tr("Open in a new graph"),
                         [ var = impl->m_Variable, zoneWidget ]() { zoneWidget->createGraph(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
                     impl->visitLeaf(
                         *graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
-                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariable(var); });
+                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariableUsingGraph(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

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