From ea7d1a66f4abb70dcbc479ecdd3ce76f124c7cb9 2018-08-16 18:38:33
From: Alexis Jeandet <alexis.jeandet@member.fsf.org>
Date: 2018-08-16 18:38:33
Subject: [PATCH] All the codebase is modified to build with new Variable Controller
it only builds now there won't be any data update most of the code is
broken now ¯\_(ツ)_/¯

Signed-off-by: Alexis Jeandet <alexis.jeandet@member.fsf.org>

---

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 14d3042..2cfed99 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,7 +47,13 @@ ENDIF(IWYU)
 
 enable_testing()
 
-add_subdirectory(core)
+find_package(core CONFIG QUIET)
+if (NOT sciqlopcore_FOUND)
+    execute_process(COMMAND git submodule init core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    execute_process(COMMAND git submodule update core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    add_subdirectory(core)
+endif()
+
 add_subdirectory(gui)
 add_subdirectory(app)
 add_subdirectory(plugins)
diff --git a/app/src/MainWindow.cpp b/app/src/MainWindow.cpp
index d3a508d..f603c6a 100644
--- a/app/src/MainWindow.cpp
+++ b/app/src/MainWindow.cpp
@@ -319,8 +319,8 @@ MainWindow::MainWindow(QWidget *parent)
     // /////////// //
 
     // Controllers / controllers connections
-    connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->variableController(),
-            SLOT(onDateTimeOnSelection(DateTimeRange)));
+//    connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->variableController(),
+//            SLOT(onDateTimeOnSelection(DateTimeRange)));
 
     // Widgets / controllers connections
 
diff --git a/core b/core
index 5a50815..5f4f956 160000
--- a/core
+++ b/core
@@ -1 +1 @@
-Subproject commit 5a50815a763fb421298a06a6d0380b8f5364e7cd
+Subproject commit 5f4f9560990ba00394322fa1d06d4a30feaf7075
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index fad8eb6..4984fa0 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -19,6 +19,8 @@ class DataSourceController;
 class NetworkController;
 class TimeController;
 class VariableController;
+class VariableController2;
+class VariableModel2;
 class VisualizationController;
 class DragDropGuiController;
 class ActionsGuiController;
@@ -37,14 +39,17 @@ class SqpApplication : public QApplication {
     Q_OBJECT
 public:
     explicit SqpApplication(int &argc, char **argv);
-    virtual ~SqpApplication();
+     ~SqpApplication() override;
     void initialize();
 
     /// Accessors for the differents sciqlop controllers
     DataSourceController &dataSourceController() noexcept;
     NetworkController &networkController() noexcept;
     TimeController &timeController() noexcept;
-    VariableController &variableController() noexcept;
+    VariableController2 &variableController() noexcept;
+    std::shared_ptr<VariableController2> variableControllerOwner() noexcept;
+    //@TODO there should not be any global model it's just GUI impl detail
+//    VariableModel2 &variableModel() noexcept;
     VisualizationController &visualizationController() noexcept;
     CatalogueController &catalogueController() noexcept;
 
diff --git a/gui/include/Variable/VariableInspectorWidget.h b/gui/include/Variable/VariableInspectorWidget.h
index f8e249c..9039107 100644
--- a/gui/include/Variable/VariableInspectorWidget.h
+++ b/gui/include/Variable/VariableInspectorWidget.h
@@ -7,6 +7,8 @@
 
 #include <memory>
 
+#include <Variable/VariableModel2.h>
+
 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableInspectorWidget)
 
 class Variable;
@@ -45,6 +47,7 @@ private:
     Ui::VariableInspectorWidget *ui;
 
     QProgressBarItemDelegate *m_ProgressBarItemDelegate;
+    VariableModel2* m_model;
 
 private slots:
     /// Slot called when right clicking on an variable in the table (displays a menu)
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 0c1cbd1..aa21ae9 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -64,7 +64,7 @@ public:
     void removeVariable(std::shared_ptr<Variable> variable) noexcept;
 
     /// Returns the list of all variables used in the graph
-    QList<std::shared_ptr<Variable> > variables() const;
+    std::vector<std::shared_ptr<Variable> > variables() const;
 
     /// Sets the y-axis range based on the data of a variable
     void setYRange(std::shared_ptr<Variable> variable);
diff --git a/gui/include/Visualization/VisualizationTabWidget.h b/gui/include/Visualization/VisualizationTabWidget.h
index 5299e6e..a9f8db8 100644
--- a/gui/include/Visualization/VisualizationTabWidget.h
+++ b/gui/include/Visualization/VisualizationTabWidget.h
@@ -53,7 +53,7 @@ public:
      * @param index The index where the zone should be inserted in the layout
      * @return the pointer to the created zone
      */
-    VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
+    VisualizationZoneWidget *createZone(const std::vector<std::shared_ptr<Variable> > &variables,
                                         int index);
 
     /**
diff --git a/gui/include/Visualization/VisualizationZoneWidget.h b/gui/include/Visualization/VisualizationZoneWidget.h
index 743a20d..7b5216a 100644
--- a/gui/include/Visualization/VisualizationZoneWidget.h
+++ b/gui/include/Visualization/VisualizationZoneWidget.h
@@ -62,7 +62,7 @@ public:
      * @param index The index where the graph should be inserted in the layout
      * @return the pointer to the created graph
      */
-    VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
+    VisualizationGraphWidget *createGraph( std::vector<std::shared_ptr<Variable> > variables,
                                           int index);
 
     /// Returns the first graph in the zone or nullptr if there is no graph inside
diff --git a/gui/src/Catalogue/CatalogueEventsWidget.cpp b/gui/src/Catalogue/CatalogueEventsWidget.cpp
index b875af4..e8d770e 100644
--- a/gui/src/Catalogue/CatalogueEventsWidget.cpp
+++ b/gui/src/Catalogue/CatalogueEventsWidget.cpp
@@ -12,6 +12,7 @@
 #include <SqpApplication.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 #include <Visualization/VisualizationGraphWidget.h>
 #include <Visualization/VisualizationTabWidget.h>
 #include <Visualization/VisualizationWidget.h>
@@ -240,11 +241,9 @@ struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
         // Closes the previous graph and delete the asociated variables
         for (auto graph : m_CustomGraphs) {
             graph->close();
-            auto variables = graph->variables().toVector();
-
-            QMetaObject::invokeMethod(&sqpApp->variableController(), "deleteVariables",
-                                      Qt::QueuedConnection,
-                                      Q_ARG(QVector<std::shared_ptr<Variable> >, variables));
+            auto variables = graph->variables();
+            for(const auto& variable:variables)
+                sqpApp->variableController().deleteVariable(variable);
         }
         m_CustomGraphs.clear();
 
@@ -276,7 +275,7 @@ struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
 
             auto context = new QObject{catalogueEventWidget};
             QObject::connect(
-                &sqpApp->variableController(), &VariableController::variableAdded, context,
+                &sqpApp->variableController(), &VariableController2::variableAdded, context,
                 [this, catalogueEventWidget, zone, context, event, range, productRange,
                  productId](auto variable) {
 
diff --git a/gui/src/DragAndDrop/DragDropGuiController.cpp b/gui/src/DragAndDrop/DragDropGuiController.cpp
index 22f058b..87ed9f0 100644
--- a/gui/src/DragAndDrop/DragDropGuiController.cpp
+++ b/gui/src/DragAndDrop/DragDropGuiController.cpp
@@ -9,7 +9,7 @@
 
 #include "DataSource/DataSourceController.h"
 #include "Variable/Variable.h"
-#include "Variable/VariableController.h"
+#include "Variable/VariableController2.h"
 
 #include "Common/MimeTypesDef.h"
 #include "Common/VisualizationDef.h"
@@ -244,12 +244,12 @@ bool DragDropGuiController::checkMimeDataForVisualization(
     auto result = false;
 
     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-        auto variables = sqpApp->variableController().variablesForMimeData(
+        auto variables = sqpApp->variableController().variables(
             mimeData->data(MIME_TYPE_VARIABLE_LIST));
 
-        if (variables.count() == 1) {
+        if (variables.size() == 1) {
 
-            auto variable = variables.first();
+            auto variable = variables[0];
             if (variable->dataSeries() != nullptr) {
 
                 // Check that the variable is not already in a graph
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index 419d8a6..38ead16 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -10,6 +10,8 @@
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
+#include <Variable/VariableModel2.h>
 #include <Variable/VariableModel.h>
 #include <Visualization/VisualizationController.h>
 
@@ -18,14 +20,8 @@ Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
 class SqpApplication::SqpApplicationPrivate {
 public:
     SqpApplicationPrivate()
-            : m_DataSourceController{std::make_unique<DataSourceController>()},
-              m_VariableController{std::make_unique<VariableController>()},
-              m_TimeController{std::make_unique<TimeController>()},
-              m_NetworkController{std::make_unique<NetworkController>()},
-              m_VisualizationController{std::make_unique<VisualizationController>()},
-              m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
-              m_CatalogueController{std::make_unique<CatalogueController>()},
-              m_ActionsGuiController{std::make_unique<ActionsGuiController>()},
+            : m_VariableController{std::make_shared<VariableController2>()},
+              m_VariableModel{m_VariableController},
               m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
               m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
     {
@@ -34,35 +30,33 @@ public:
         // /////////////////////////////// //
 
         // VariableController <-> DataSourceController
-        connect(m_DataSourceController.get(),
+        connect(&m_DataSourceController,
                 SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                  std::shared_ptr<IDataProvider>)),
                 m_VariableController.get(),
                 SLOT(createVariable(const QString &, const QVariantHash &,
                                     std::shared_ptr<IDataProvider>)));
 
-        connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
-                m_DataSourceController.get(), &DataSourceController::requestVariable);
+//        connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
+//                m_DataSourceController.get(), &DataSourceController::requestVariable);
 
         // VariableController <-> VisualizationController
-        connect(m_VariableController.get(),
-                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
-                m_VisualizationController.get(),
-                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
+//        connect(m_VariableController.get(),
+//                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
+//                m_VisualizationController.get(),
+//                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
 
-        connect(m_VariableController.get(),
-                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
-                m_VisualizationController.get(),
-                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
+//        connect(m_VariableController.get(),
+//                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
+//                m_VisualizationController.get(),
+//                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
 
 
-        m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+        m_DataSourceController.moveToThread(&m_DataSourceControllerThread);
         m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
-        m_NetworkController->moveToThread(&m_NetworkControllerThread);
+        m_NetworkController.moveToThread(&m_NetworkControllerThread);
         m_NetworkControllerThread.setObjectName("NetworkControllerThread");
-        m_VariableController->moveToThread(&m_VariableControllerThread);
-        m_VariableControllerThread.setObjectName("VariableControllerThread");
-        m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+        m_VisualizationController.moveToThread(&m_VisualizationControllerThread);
         m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
 
         // Additionnal init
@@ -77,27 +71,24 @@ public:
         m_NetworkControllerThread.quit();
         m_NetworkControllerThread.wait();
 
-        m_VariableControllerThread.quit();
-        m_VariableControllerThread.wait();
-
         m_VisualizationControllerThread.quit();
         m_VisualizationControllerThread.wait();
     }
 
-    std::unique_ptr<DataSourceController> m_DataSourceController;
-    std::unique_ptr<VariableController> m_VariableController;
-    std::unique_ptr<TimeController> m_TimeController;
-    std::unique_ptr<NetworkController> m_NetworkController;
-    std::unique_ptr<VisualizationController> m_VisualizationController;
-    std::unique_ptr<CatalogueController> m_CatalogueController;
+    DataSourceController m_DataSourceController;
+    std::shared_ptr<VariableController2> m_VariableController;
+    TimeController m_TimeController;
+    NetworkController m_NetworkController;
+    VisualizationController m_VisualizationController;
+    CatalogueController m_CatalogueController;
+    VariableModel2 m_VariableModel;
 
     QThread m_DataSourceControllerThread;
     QThread m_NetworkControllerThread;
-    QThread m_VariableControllerThread;
     QThread m_VisualizationControllerThread;
 
-    std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
-    std::unique_ptr<ActionsGuiController> m_ActionsGuiController;
+    DragDropGuiController m_DragDropGuiController;
+    ActionsGuiController m_ActionsGuiController;
 
     SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
     SqpApplication::PlotsCursorMode m_PlotCursorMode;
@@ -112,30 +103,24 @@ SqpApplication::SqpApplication(int &argc, char **argv)
     QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
 
     connect(&impl->m_DataSourceControllerThread, &QThread::started,
-            impl->m_DataSourceController.get(), &DataSourceController::initialize);
+            &impl->m_DataSourceController, &DataSourceController::initialize);
     connect(&impl->m_DataSourceControllerThread, &QThread::finished,
-            impl->m_DataSourceController.get(), &DataSourceController::finalize);
+            &impl->m_DataSourceController, &DataSourceController::finalize);
 
-    connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
+    connect(&impl->m_NetworkControllerThread, &QThread::started, &impl->m_NetworkController,
             &NetworkController::initialize);
-    connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
+    connect(&impl->m_NetworkControllerThread, &QThread::finished, &impl->m_NetworkController,
             &NetworkController::finalize);
 
-    connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
-            &VariableController::initialize);
-    connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
-            &VariableController::finalize);
-
     connect(&impl->m_VisualizationControllerThread, &QThread::started,
-            impl->m_VisualizationController.get(), &VisualizationController::initialize);
+            &impl->m_VisualizationController, &VisualizationController::initialize);
     connect(&impl->m_VisualizationControllerThread, &QThread::finished,
-            impl->m_VisualizationController.get(), &VisualizationController::finalize);
+            &impl->m_VisualizationController, &VisualizationController::finalize);
 
     impl->m_DataSourceControllerThread.start();
     impl->m_NetworkControllerThread.start();
-    impl->m_VariableControllerThread.start();
     impl->m_VisualizationControllerThread.start();
-    impl->m_CatalogueController->initialize();
+    impl->m_CatalogueController.initialize();
 }
 
 SqpApplication::~SqpApplication()
@@ -148,42 +133,52 @@ void SqpApplication::initialize()
 
 DataSourceController &SqpApplication::dataSourceController() noexcept
 {
-    return *impl->m_DataSourceController;
+    return impl->m_DataSourceController;
 }
 
 NetworkController &SqpApplication::networkController() noexcept
 {
-    return *impl->m_NetworkController;
+    return impl->m_NetworkController;
 }
 
 TimeController &SqpApplication::timeController() noexcept
 {
-    return *impl->m_TimeController;
+    return impl->m_TimeController;
 }
 
-VariableController &SqpApplication::variableController() noexcept
+VariableController2 &SqpApplication::variableController() noexcept
 {
     return *impl->m_VariableController;
 }
 
+std::shared_ptr<VariableController2> SqpApplication::variableControllerOwner() noexcept
+{
+    return impl->m_VariableController;
+}
+
+//VariableModel2 &SqpApplication::variableModel() noexcept
+//{
+//    return impl->m_VariableModel;
+//}
+
 VisualizationController &SqpApplication::visualizationController() noexcept
 {
-    return *impl->m_VisualizationController;
+    return impl->m_VisualizationController;
 }
 
 CatalogueController &SqpApplication::catalogueController() noexcept
 {
-    return *impl->m_CatalogueController;
+    return impl->m_CatalogueController;
 }
 
 DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
 {
-    return *impl->m_DragDropGuiController;
+    return impl->m_DragDropGuiController;
 }
 
 ActionsGuiController &SqpApplication::actionsGuiController() noexcept
 {
-    return *impl->m_ActionsGuiController;
+    return impl->m_ActionsGuiController;
 }
 
 SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index 101ceb6..e74eea1 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -1,9 +1,9 @@
 #include <Variable/RenameVariableDialog.h>
 #include <Variable/Variable.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 #include <Variable/VariableInspectorWidget.h>
 #include <Variable/VariableMenuHeaderWidget.h>
-#include <Variable/VariableModel.h>
+#include <Variable/VariableModel2.h>
 
 #include <ui_VariableInspectorWidget.h>
 
@@ -92,8 +92,8 @@ public:
 
                 if (clickX > x && clickX < x + w) {
                     if (clickY > y && clickY < y + h) {
-                        auto variableModel = sqpApp->variableController().variableModel();
-                        variableModel->abortProgress(index);
+                        //auto& variableModel = sqpApp->variableModel();
+                        //variableModel->abortProgress(index);
                     }
                     return true;
                 }
@@ -125,15 +125,15 @@ VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
     //    auto sortFilterModel = new QSortFilterProxyModel{this};
     //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
 
-    auto variableModel = sqpApp->variableController().variableModel();
-    ui->tableView->setModel(variableModel);
+    m_model = new VariableModel2(sqpApp->variableControllerOwner());
+    ui->tableView->setModel(m_model);
 
     // Adds extra signal/slot between view and model, so the view can be updated instantly when
     // there is a change of data in the model
-    connect(variableModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
+    connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
             SLOT(refresh()));
 
-    ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
+    //ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
     ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
 
     // Fixes column sizes
@@ -164,10 +164,10 @@ void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
     auto selectedRows = ui->tableView->selectionModel()->selectedRows();
 
     // Gets the model to retrieve the underlying selected variables
-    auto model = sqpApp->variableController().variableModel();
+    auto& vc = sqpApp->variableController();
     auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
     for (const auto &selectedRow : qAsConst(selectedRows)) {
-        if (auto selectedVariable = model->variable(selectedRow.row())) {
+        if (auto selectedVariable = vc[selectedRow.row()]) {
             selectedVariables.push_back(selectedVariable);
         }
     }
@@ -194,11 +194,11 @@ void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
 
             tableMenu.addAction(tr("Duplicate"), duplicateFun);
 
-            auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), &model, this ]()
+            auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), this ]()
             {
                 if (auto var = varW.lock()) {
                     // Generates forbidden names (names associated to existing variables)
-                    auto allVariables = model->variables();
+                    auto allVariables = sqpApp->variableController().variables();
                     auto forbiddenNames = QVector<QString>(allVariables.size());
                     std::transform(allVariables.cbegin(), allVariables.cend(),
                                    forbiddenNames.begin(),
@@ -216,7 +216,8 @@ void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
 
         // 'Delete' action
         auto deleteFun = [&selectedVariables]() {
-            sqpApp->variableController().deleteVariables(selectedVariables);
+            for(const auto& var:selectedVariables)
+                sqpApp->variableController().deleteVariable(var);
         };
 
         tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 8976a24..05fb972 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -253,11 +253,12 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
     connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
             &VisualizationGraphWidget::onGraphMenuRequested);
 
-    connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
-            &VariableController::onRequestDataLoading);
+    //@TODO implement this :)
+//    connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+//            &VariableController::onRequestDataLoading);
 
-    connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
-            &VisualizationGraphWidget::onUpdateVarDisplaying);
+//    connect(&sqpApp->variableController(), &VariableController2::updateVarDisplaying, this,
+//            &VisualizationGraphWidget::onUpdateVarDisplaying);
 
     // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
     plot().setPlottingHint(QCP::phFastPolylines, true);
@@ -365,12 +366,12 @@ void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable
     ui->widget->replot();
 }
 
-QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
+std::vector<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
 {
-    auto variables = QList<std::shared_ptr<Variable> >{};
+    auto variables = std::vector<std::shared_ptr<Variable> >{};
     for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
          it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
-        variables << it->first;
+        variables.push_back (it->first);
     }
 
     return variables;
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 383f384..d2d8b9f 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -8,7 +8,7 @@
 #include "Visualization/MacScrollBarStyle.h"
 
 #include "DataSource/DataSourceController.h"
-#include "Variable/VariableController.h"
+#include "Variable/VariableController2.h"
 
 #include "Common/MimeTypesDef.h"
 
@@ -68,7 +68,7 @@ struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
 
     void dropGraph(int index, VisualizationTabWidget *tabWidget);
     void dropZone(int index, VisualizationTabWidget *tabWidget);
-    void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
+    void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                        VisualizationTabWidget *tabWidget);
     void dropProducts(const QVariantList &productsMetaData, int index,
                       VisualizationTabWidget *tabWidget);
@@ -154,7 +154,7 @@ VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Vari
 }
 
 VisualizationZoneWidget *
-VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
+VisualizationTabWidget::createZone(const std::vector<std::shared_ptr<Variable> > &variables, int index)
 {
     auto zoneWidget = createEmptyZone(index);
 
@@ -230,7 +230,7 @@ void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
         impl->dropZone(index, this);
     }
     else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-        auto variables = sqpApp->variableController().variablesForMimeData(
+        auto variables = sqpApp->variableController().variables(
             mimeData->data(MIME_TYPE_VARIABLE_LIST));
         impl->dropVariables(variables, index, this);
     }
@@ -273,7 +273,7 @@ void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
 
     const auto &variables = graphWidget->variables();
 
-    if (!variables.isEmpty()) {
+    if (!variables.empty()) {
         // Abort the requests for the variables (if any)
         // Commented, because it's not sure if it's needed or not
         // for (const auto& var : variables)
@@ -348,12 +348,12 @@ void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
 }
 
 void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
-    const QList<std::shared_ptr<Variable> > &variables, int index,
+    const std::vector<std::shared_ptr<Variable> > &variables, int index,
     VisualizationTabWidget *tabWidget)
 {
     // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
     // compatible variable here
-    if (variables.count() > 1) {
+    if (variables.size() > 1) {
         qCWarning(LOG_VisualizationZoneWidget())
             << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                   "aborted.");
@@ -376,7 +376,7 @@ void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropProducts(
     }
 
     auto context = new QObject{tabWidget};
-    connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+    connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
             [this, index, tabWidget, context](auto variable) {
                 tabWidget->createZone({variable}, index);
                 delete context; // removes the connection
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 59bbcbf..a1de13b 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -10,10 +10,11 @@
 #include "Common/VisualizationDef.h"
 
 #include <Data/DateTimeRange.h>
+#include <Data/DateTimeRangeHelper.h>
 #include <DataSource/DataSourceController.h>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 
 #include <Visualization/operations/FindVariableOperation.h>
 
@@ -78,7 +79,7 @@ struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
     std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
 
     void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
-    void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
+    void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                        VisualizationZoneWidget *zoneWidget);
     void dropProducts(const QVariantList &productsData, int index,
                       VisualizationZoneWidget *zoneWidget);
@@ -117,13 +118,13 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
         }
 
         if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-            auto variables = sqpApp->variableController().variablesForMimeData(
+            auto variables = sqpApp->variableController().variables(
                 mimeData->data(MIME_TYPE_VARIABLE_LIST));
 
-            if (variables.count() != 1) {
+            if (variables.size() != 1) {
                 return false;
             }
-            auto variable = variables.first();
+            auto variable = variables.front();
 
             if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                 return graphWidget->canDrop(*variable);
@@ -202,7 +203,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
                                                      const DateTimeRange &oldGraphRange) {
 
-        auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
+        auto zoomType = DateTimeRangeHelper::getTransformationType(oldGraphRange, graphRange);
         auto frameLayout = ui->dragDropContainer->layout();
         for (auto i = 0; i < frameLayout->count(); ++i) {
             auto graphChild
@@ -211,57 +212,36 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
 
                 auto graphChildRange = graphChild->graphRange();
                 switch (zoomType) {
-                    case AcquisitionZoomType::ZoomIn: {
+                    case TransformationType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
-                        qCDebug(LOG_VisualizationZoneWidget())
-                            << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
-
                         break;
                     }
 
-                    case AcquisitionZoomType::ZoomOut: {
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
+                    case TransformationType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
-                        qCDebug(LOG_VisualizationZoneWidget())
-                            << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
                         graphChildRange.m_TEnd += deltaRight;
                         break;
                     }
-                    case AcquisitionZoomType::PanRight: {
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
+                    case TransformationType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd += deltaRight;
-                        qCDebug(LOG_VisualizationZoneWidget())
-                            << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         break;
                     }
-                    case AcquisitionZoomType::PanLeft: {
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
+                    case TransformationType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         graphChildRange.m_TStart -= deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
                         break;
                     }
-                    case AcquisitionZoomType::Unknown: {
-                        qCDebug(LOG_VisualizationZoneWidget())
-                            << tr("Impossible to synchronize: zoom type unknown");
+                    case TransformationType::Unknown: {
                         break;
                     }
                     default:
@@ -271,12 +251,6 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         break;
                 }
                 graphChild->setFlags(GraphFlag::DisableAll);
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                       << graphChild->graphRange();
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                       << graphChildRange;
-                qCDebug(LOG_VisualizationZoneWidget())
-                    << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                 graphChild->setGraphRange(graphChildRange);
                 graphChild->setFlags(GraphFlag::EnableAll);
             }
@@ -309,13 +283,13 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
 }
 
 VisualizationGraphWidget *
-VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
+VisualizationZoneWidget::createGraph(const std::vector<std::shared_ptr<Variable> > variables, int index)
 {
-    if (variables.isEmpty()) {
+    if (variables.empty()) {
         return nullptr;
     }
 
-    auto graphWidget = createGraph(variables.first(), index);
+    auto graphWidget = createGraph(variables.front(), index);
     for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
         graphWidget->addVariable(*variableIt, graphWidget->graphRange());
     }
@@ -485,7 +459,7 @@ void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
         impl->dropGraph(index, this);
     }
     else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-        auto variables = sqpApp->variableController().variablesForMimeData(
+        auto variables = sqpApp->variableController().variables(
             mimeData->data(MIME_TYPE_VARIABLE_LIST));
         impl->dropVariables(variables, index, this);
     }
@@ -513,7 +487,7 @@ void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragW
     }
 
     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-        auto variables = sqpApp->variableController().variablesForMimeData(
+        auto variables = sqpApp->variableController().variables(
             mimeData->data(MIME_TYPE_VARIABLE_LIST));
         for (const auto &var : variables) {
             graphWidget->addVariable(var, graphWidget->graphRange());
@@ -524,7 +498,7 @@ void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragW
             mimeData->data(MIME_TYPE_PRODUCT_LIST));
 
         auto context = new QObject{this};
-        connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+        connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                 [this, graphWidget, context](auto variable) {
                     graphWidget->addVariable(variable, graphWidget->graphRange());
                     delete context; // removes the connection
@@ -571,7 +545,7 @@ void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
 
     const auto &variables = graphWidget->variables();
 
-    if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
+    if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.empty()) {
         // The drop didn't occur in the same zone
 
         // Abort the requests for the variables (if any)
@@ -601,7 +575,7 @@ void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
         // Simple move of the graph, no variable operation associated
         parentDragDropContainer->layout()->removeWidget(graphWidget);
 
-        if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
+        if (variables.empty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
             // The graph is empty and dropped in a different zone.
             // Take the range of the first graph in the zone (if existing).
             auto layout = zoneWidget->ui->dragDropContainer->layout();
@@ -618,18 +592,14 @@ void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
 }
 
 void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
-    const QList<std::shared_ptr<Variable> > &variables, int index,
+    const std::vector<std::shared_ptr<Variable> > &variables, int index,
     VisualizationZoneWidget *zoneWidget)
 {
     // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
     // compatible variable here
-    if (variables.count() > 1) {
-        qCWarning(LOG_VisualizationZoneWidget())
-            << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
-                  "aborted.");
+    if (variables.size() > 1) {
         return;
     }
-
     zoneWidget->createGraph(variables, index);
 }
 
@@ -646,7 +616,7 @@ void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
     }
 
     auto context = new QObject{zoneWidget};
-    connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+    connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
             [this, index, zoneWidget, context](auto variable) {
                 zoneWidget->createGraph(variable, index);
                 delete context; // removes the connection
diff --git a/plugins/amda/tests/PyTestAmdaWrapper.cpp b/plugins/amda/tests/PyTestAmdaWrapper.cpp
index bad20a4..7b2fce0 100644
--- a/plugins/amda/tests/PyTestAmdaWrapper.cpp
+++ b/plugins/amda/tests/PyTestAmdaWrapper.cpp
@@ -30,7 +30,7 @@
 #include <pybind11/chrono.h>
 
 #include <SqpApplication.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 #include <Time/TimeController.h>
 #include <Data/DateTimeRange.h>
 #include <Data/DataSeriesType.h>
@@ -73,38 +73,38 @@ PYBIND11_MODULE(pytestamda, m){
 
     m.doc() = "hello";
 
-    py::class_<VariableController>(m, "VariableController")
-            .def_static("createVariable",[](const QString &name,
-                        std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
-        return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
-    })
-            .def_static("hasPendingDownloads",
-                        [](){return sqpApp->variableController().hasPendingDownloads();}
-                        )
-            .def_static("addSynchronizationGroup",
-                        [](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}
-                        )
-            .def_static("removeSynchronizationGroup",
-                [](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}
-                )
-            .def_static("synchronizeVar",
-                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}
-                )
-            .def_static("deSynchronizeVar",
-                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}
-                )
-            .def_static("deleteVariable",
-                        [](std::shared_ptr<Variable> variable){
-        sqpApp->variableController().deleteVariable(variable);}
-                        )
-            .def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){
-        sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
-    })
-            .def_static("wait_for_downloads",[](){
-        while (sqpApp->variableController().hasPendingDownloads()) {
-            usleep(100);
-        }
-    });
+//    py::class_<VariableController>(m, "VariableController")
+//            .def_static("createVariable",[](const QString &name,
+//                        std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
+//        return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
+//    })
+//            .def_static("hasPendingDownloads",
+//                        [](){return sqpApp->variableController().hasPendingDownloads();}
+//                        )
+//            .def_static("addSynchronizationGroup",
+//                        [](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}
+//                        )
+//            .def_static("removeSynchronizationGroup",
+//                [](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}
+//                )
+//            .def_static("synchronizeVar",
+//                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}
+//                )
+//            .def_static("deSynchronizeVar",
+//                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}
+//                )
+//            .def_static("deleteVariable",
+//                        [](std::shared_ptr<Variable> variable){
+//        sqpApp->variableController().deleteVariable(variable);}
+//                        )
+//            .def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){
+//        sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
+//    })
+//            .def_static("wait_for_downloads",[](){
+//        while (sqpApp->variableController().hasPendingDownloads()) {
+//            usleep(100);
+//        }
+//    });
 
     py::class_<TimeController>(m,"TimeController")
             .def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});
diff --git a/plugins/amda/tests/TestAmdaAcquisition.cpp b/plugins/amda/tests/TestAmdaAcquisition.cpp
index 878e983..f7b9037 100644
--- a/plugins/amda/tests/TestAmdaAcquisition.cpp
+++ b/plugins/amda/tests/TestAmdaAcquisition.cpp
@@ -7,7 +7,7 @@
 #include <Data/ScalarSeries.h>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 
 #include <QObject>
 #include <QtTest>
@@ -143,7 +143,7 @@ void TestAmdaAcquisition::testAcquisition()
     QFETCH(std::vector<DateTimeRange>, operations);
     for (const auto &operation : operations) {
         // Asks request on the variable and waits during its execution
-        sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+        sqpApp->variableController().changeRange({variable}, operation);
 
         QTest::qWait(OPERATION_DELAY);
         validateVariable(variable, operation);
diff --git a/plugins/amda/tests/TestAmdaFuzzing.cpp b/plugins/amda/tests/TestAmdaFuzzing.cpp
index 8e83e7b..aa842ad 100644
--- a/plugins/amda/tests/TestAmdaFuzzing.cpp
+++ b/plugins/amda/tests/TestAmdaFuzzing.cpp
@@ -11,7 +11,7 @@
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 
 #include <QLoggingCategory>
 #include <QObject>
@@ -173,7 +173,7 @@ void validate(const VariablesPool &variablesPool, const Validators &validators)
  */
 class FuzzingTest {
 public:
-    explicit FuzzingTest(VariableController &variableController, Properties properties)
+    explicit FuzzingTest(VariableController2 &variableController, Properties properties)
             : m_VariableController{variableController},
               m_Properties{std::move(properties)},
               m_FuzzingState{}
@@ -186,7 +186,7 @@ public:
         // Inits sync groups and registers them into the variable controller
         for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
             auto syncGroupId = SyncGroupId::createUuid();
-            variableController.onAddSynchronizationGroupId(syncGroupId);
+            //variableController.onAddSynchronizationGroupId(syncGroupId);
             m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
         }
     }
@@ -229,8 +229,8 @@ public:
                 auto waitAcquisition = nextValidationCounter == 0
                                        || operationsPool().at(fuzzingOperation).m_WaitAcquisition;
 
-                fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
-                                          m_Properties);
+//                fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
+//                                          m_Properties);
 
                 if (waitAcquisition) {
                     qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
@@ -285,7 +285,7 @@ private:
     DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
     DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
 
-    VariableController &m_VariableController;
+    VariableController2 &m_VariableController;
     Properties m_Properties;
     FuzzingState m_FuzzingState;
 };
diff --git a/plugins/mockplugin/tests/TestCosinusAcquisition.cpp b/plugins/mockplugin/tests/TestCosinusAcquisition.cpp
index 95e7857..3112e92 100644
--- a/plugins/mockplugin/tests/TestCosinusAcquisition.cpp
+++ b/plugins/mockplugin/tests/TestCosinusAcquisition.cpp
@@ -6,7 +6,7 @@
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
-#include <Variable/VariableController.h>
+#include <Variable/VariableController2.h>
 
 #include <QObject>
 #include <QtTest>
@@ -168,7 +168,7 @@ void TestCosinusAcquisition::testAcquisition()
     QFETCH(std::vector<DateTimeRange>, operations);
     for (const auto &operation : operations) {
         // Asks request on the variable and waits during its execution
-        sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+        sqpApp->variableController().changeRange(variable, operation);
 
         QTest::qWait(operationDelay);
         validateVariable(variable, operation);
@@ -177,7 +177,7 @@ void TestCosinusAcquisition::testAcquisition()
 
     for (const auto &operation : operations) {
         // Asks request on the variable and waits during its execution
-        sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
+        sqpApp->variableController().changeRange(variable, operation);
     }
     QTest::qWait(operationDelay);
     validateVariable(variable, operations.back());