HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1350:09a8c8a01145

Ported Mock plugin to new IDataProvider interface compatible with...

jeandet -

r1350:09a8c8a01145

parent child

Context file:

r1350:09a8c8a01145

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit de55e7be90966d1efbd34a10df9a3231c50e245b		1	Subproject commit c08d1b8ad2976824def52cf0fca26a72b1069356

gui/src/DragAndDrop/DragDropGuiController.cpp +1 -1

             #include "DragAndDrop/DragDropGuiController.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "DataSource/DataSourceController.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController2.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
             Q_LOGGING_CATEGORY(LOG_DragDropGuiController, "DragDropGuiController")
             struct DragDropGuiController::DragDropGuiControllerPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel *m_PlaceHolderLabel;
                 QWidget *m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
                 std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
                 QList<QWidget *> m_WidgetToClose;
                 explicit DragDropGuiControllerPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()},
                           m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                 {
                     auto layout = new QVBoxLayout{m_PlaceHolder.get()};
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
                 void preparePlaceHolder(DragDropGuiController::PlaceHolderType type,
                                         const QString &topLabelText) const
                 {
                     if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
                     else {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type) {
                         case DragDropGuiController::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
                         case DragDropGuiController::PlaceHolderType::Zone:
                         case DragDropGuiController::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
             DragDropGuiController::DragDropGuiController()
                     : impl{spimpl::make_unique_impl<DragDropGuiControllerPrivate>()}
             {
             }
             DragDropGuiController::~DragDropGuiController()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropGuiController::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
             void DragDropGuiController::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropGuiController::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget &DragDropGuiController::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
             void DragDropGuiController::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                                           const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
             void DragDropGuiController::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget) {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
                 }
             }
             bool DragDropGuiController::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropGuiController::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropGuiController::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             void DragDropGuiController::addDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
             void DragDropGuiController::removeDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
             QUrl DragDropGuiController::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             void DragDropGuiController::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropGuiController::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
             void DragDropGuiController::delayedCloseWidget(QWidget *widget)
             {
                 widget->hide();
                 impl->m_WidgetToClose << widget;
             }
             void DragDropGuiController::doCloseWidgets()
             {
                 for (auto widget : impl->m_WidgetToClose) {
                     widget->close();
                 }
                 impl->m_WidgetToClose.clear();
             }
             bool DragDropGuiController::checkMimeDataForVisualization(
                 const QMimeData *mimeData, VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
                     qCWarning(LOG_DragDropGuiController()) << QObject::tr(
                         "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     if (variables.size() == 1) {
                         auto variable = variables[0];
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent) {
                                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                                 FindVariableOperation findVariableOperation{variable};
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty()) {
                                     result = true;
                                 }
                                 else {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else {
                                 qCWarning(LOG_DragDropGuiController()) << QObject::tr(
                                     "DragDropGuiController::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto productDataList = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     if (productDataList.count() == 1) {
                         result = true;
                     }
                     else {
                         // result = false: cannot drop multiple products in the visualisation
                     }
                 }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/SqpApplication.cpp +6 -7

             #include "SqpApplication.h"
             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableModel2.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_VariableController{std::make_shared<VariableController2>()},
-                          m_VariableModel{m_VariableController},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(&m_DataSourceController,
-                            SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
+                            &DataSourceController::createVariable,[](const QString &variableName,
-                                                             std::shared_ptr<IDataProvider>)),
+                            const QVariantHash &variableMetadata,
-                            m_VariableController.get(),
+                            std::shared_ptr<IDataProvider> variableProvider)
-                            SLOT(createVariable(const QString &, const QVariantHash &,
-                                                std::shared_ptr<IDataProvider>)));
+                        sqpApp->variableController().createVariable(variableName,variableMetadata,variableProvider,sqpApp->timeController().dateTime());
+                    });
             //        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(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
             //                m_VisualizationController.get(),
             //                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
                     m_DataSourceController.moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController.moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VisualizationController.moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     //m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 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_VisualizationControllerThread;
                 DragDropGuiController m_DragDropGuiController;
                 ActionsGuiController m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         &impl->m_DataSourceController, &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         &impl->m_DataSourceController, &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, &impl->m_NetworkController,
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, &impl->m_NetworkController,
                         &NetworkController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         &impl->m_VisualizationController, &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         &impl->m_VisualizationController, &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
                 impl->m_CatalogueController.initialize();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return impl->m_TimeController;
             }
             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;
             }
             CatalogueController &SqpApplication::catalogueController() noexcept
             {
                 return impl->m_CatalogueController;
             }
             DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
             {
                 return impl->m_DragDropGuiController;
             }
             ActionsGuiController &SqpApplication::actionsGuiController() noexcept
             {
                 return impl->m_ActionsGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

gui/src/Variable/VariableInspectorWidget.cpp +13 -3

             #include <Variable/RenameVariableDialog.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel2.h>
+            #include <DataSource/DataSourceController.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QMouseEvent>
             #include <QSortFilterProxyModel>
             #include <QStyledItemDelegate>
             #include <QWidgetAction>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
             class QProgressBarItemDelegate : public QStyledItemDelegate {
             public:
                 QProgressBarItemDelegate(QObject *parent) : QStyledItemDelegate{parent} {}
                 void paint(QPainter *painter, const QStyleOptionViewItem &option,
                            const QModelIndex &index) const
                 {
                     auto data = index.data(Qt::DisplayRole);
                     auto progressData = index.data(VariableRoles::ProgressRole);
                     if (data.isValid() && progressData.isValid()) {
                         auto name = data.value<QString>();
                         auto progress = progressData.value<double>();
                         if (progress > 0) {
                             auto cancelButtonWidth = 20;
                             auto progressBarOption = QStyleOptionProgressBar{};
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             progressBarOption.rect = progressRect;
                             progressBarOption.minimum = 0;
                             progressBarOption.maximum = 100;
                             progressBarOption.progress = progress;
                             progressBarOption.text
                                 = QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
                             progressBarOption.textVisible = true;
                             progressBarOption.textAlignment = Qt::AlignCenter;
                             QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
                                                                painter);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto buttonOption = QStyleOptionButton{};
                             buttonOption.rect = buttonRect;
                             buttonOption.text = "X";
                             QApplication::style()->drawControl(QStyle::CE_PushButton, &buttonOption, painter);
                         }
                         else {
                             QStyledItemDelegate::paint(painter, option, index);
                         }
                     }
                     else {
                         QStyledItemDelegate::paint(painter, option, index);
                     }
                 }
                 bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
                                  const QModelIndex &index)
                 {
                     if (event->type() == QEvent::MouseButtonRelease) {
                         auto data = index.data(Qt::DisplayRole);
                         auto progressData = index.data(VariableRoles::ProgressRole);
                         if (data.isValid() && progressData.isValid()) {
                             auto cancelButtonWidth = 20;
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto e = (QMouseEvent *)event;
                             auto clickX = e->x();
                             auto clickY = e->y();
                             auto x = buttonRect.left();   // the X coordinate
                             auto y = buttonRect.top();    // the Y coordinate
                             auto w = buttonRect.width();  // button width
                             auto h = buttonRect.height(); // button height
                             if (clickX > x && clickX < x + w) {
                                 if (clickY > y && clickY < y + h) {
                                     //auto& variableModel = sqpApp->variableModel();
                                     //variableModel->abortProgress(index);
                                 }
                                 return true;
                             }
                             else {
                                 return QStyledItemDelegate::editorEvent(event, model, option, index);
                             }
                         }
                         else {
                             return QStyledItemDelegate::editorEvent(event, model, option, index);
                         }
                     }
                     else {
                         return QStyledItemDelegate::editorEvent(event, model, option, index);
                     }
                     return QStyledItemDelegate::editorEvent(event, model, option, index);
                 }
             };
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VariableInspectorWidget},
                       m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
-                m_model = new VariableModel2(sqpApp->variableControllerOwner());
+                m_model = new VariableModel2();
                 ui->tableView->setModel(m_model);
+                connect(m_model, &VariableModel2::createVariable,
+                        [](const QVariantHash &productData)
+                {
+                    sqpApp->dataSourceController().requestVariable(productData);
+                });
+                auto vc = &(sqpApp->variableController());
+                connect(vc, &VariableController2::variableAdded, m_model, &VariableModel2::variableAdded);
+                connect(vc, &VariableController2::variableDeleted, m_model, &VariableModel2::variableDeleted);
+                connect(m_model, &VariableModel2::asyncChangeRange, vc, &VariableController2::asyncChangeRange);
                 // 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(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
+                //connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
-                        SLOT(refresh()));
+                //        SLOT(refresh()));
                 //ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i) {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                         &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
                 auto& vc = sqpApp->variableController();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = vc[selectedRow.row()]) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu{};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     tableMenu.addSeparator();
                     // 'Rename' and 'Duplicate' actions (only if one variable selected)
                     if (selectedVariables.size() == 1) {
                         auto selectedVariable = selectedVariables.front();
                         auto duplicateFun = [varW = std::weak_ptr<Variable>(selectedVariable)]()
                         {
                             if (auto var = varW.lock()) {
                                 sqpApp->variableController().cloneVariable(var);
                             }
                         };
                         tableMenu.addAction(tr("Duplicate"), duplicateFun);
                         auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), this ]()
                         {
                             if (auto var = varW.lock()) {
                                 // Generates forbidden names (names associated to existing variables)
                                 auto allVariables = sqpApp->variableController().variables();
                                 auto forbiddenNames = QVector<QString>(allVariables.size());
                                 std::transform(allVariables.cbegin(), allVariables.cend(),
                                                forbiddenNames.begin(),
                                                [](const auto &variable) { return variable->name(); });
                                 RenameVariableDialog dialog{var->name(), forbiddenNames, this};
                                 if (dialog.exec() == QDialog::Accepted) {
                                     var->setName(dialog.name());
                                 }
                             }
                         };
                         tableMenu.addAction(tr("Rename..."), renameFun);
                     }
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
                         for(const auto& var:selectedVariables)
                             sqpApp->variableController().deleteVariable(var);
                     };
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty()) {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction{&tableMenu};
                     headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
                     tableMenu.exec(QCursor::pos());
                 }
             }
             void VariableInspectorWidget::refresh() noexcept
             {
                 ui->tableView->viewport()->update();
             }

gui/src/Visualization/VisualizationTabWidget.cpp +1 -1

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/MacScrollBarStyle.h"
             #include "DataSource/DataSourceController.h"
             #include "Variable/VariableController2.h"
             #include "Common/MimeTypesDef.h"
             #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = qobject_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(QLayout &layout)
             {
                 QSet<QString> existingNames;
                 processZones(layout,
                              [&existingNames](auto &zoneWidget) { existingNames.insert(zoneWidget.name()); });
                 int zoneNum = 1;
                 QString name;
                 do {
                     name = QObject::tr("Zone ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
                 return name;
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
             #ifdef Q_OS_MAC
                 std::unique_ptr<MacScrollBarStyle> m_MacScrollBarStyle = std::make_unique<MacScrollBarStyle>();
             #endif
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
                 void dropProducts(const QVariantList &productsMetaData, int index,
                                   VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
             #ifdef Q_OS_MAC
                 impl->m_MacScrollBarStyle->selfInstallOn(ui->scrollArea, true);
             #endif
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 12);
                 ui->dragDropContainer->layout()->setSpacing(0);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_VARIABLE_LIST,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_PRODUCT_LIST,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
                 sqpApp->dragDropGuiController().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropGuiController().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             QStringList VisualizationTabWidget::availableZoneWidgets() const
             {
                 QStringList zones;
                 processZones(tabLayout(),
                              [&zones](VisualizationZoneWidget &zoneWidget) { zones << zoneWidget.name(); });
                 return zones;
             }
             VisualizationZoneWidget *VisualizationTabWidget::getZoneWithName(const QString &zoneName)
             {
                 VisualizationZoneWidget *result = nullptr;
                 processZones(tabLayout(), [&zoneName, &result](VisualizationZoneWidget &zoneWidget) {
                     if (!result && zoneWidget.name() == zoneName) {
                         result = &zoneWidget;
                     }
                 });
                 return result;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const std::vector<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto productsData = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(productsData, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 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)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     auto zoneWidget = tabWidget->createZone(variables, index);
                     auto firstGraph = zoneWidget->firstGraph();
                     if (firstGraph) {
                         firstGraph->addSelectionZones(graphWidget->selectionZoneRanges());
                     }
                     else {
                         qCWarning(LOG_VisualizationZoneWidget())
                             << tr("VisualizationTabWidget::dropGraph, no graph added in the widget.");
                         Q_ASSERT(false);
                     }
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
                         helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 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.size() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropProducts(
                 const QVariantList &productsMetaData, int index, VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (productsMetaData.count() != 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");
                     return;
                 }
                 auto context = new QObject{tabWidget};
                 connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, index, tabWidget, context](auto variable) {
                             tabWidget->createZone({variable}, index);
                             delete context; // removes the connection
                         },
                         Qt::QueuedConnection);
                 auto productData = productsMetaData.first().toHash();
                 QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                           Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +3 -3

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #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/VariableController2.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             #include <QStyle>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(QLayout &layout)
             {
                 QSet<QString> existingNames;
                 processGraphs(
                     layout, [&existingNames](auto &graphWidget) { existingNames.insert(graphWidget.name()); });
                 int zoneNum = 1;
                 QString name;
                 do {
                     name = QObject::tr("Graph ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
                 return name;
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
                 void dropProducts(const QVariantList &productsData, int index,
                                   VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
                     if (!mimeData) {
                         return false;
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variables(
-                            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                            Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                         if (variables.size() != 1) {
                             return false;
                         }
                         auto variable = variables.front();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                     return true;
                 };
                 ui->dragDropContainer->setAcceptDragWidgetFunction(acceptDragWidgetFun);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::setZoneRange(const DateTimeRange &range)
             {
                 if (auto graph = firstGraph()) {
                     graph->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("setZoneRange:Cannot set the range of an empty zone.");
                 }
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
                                                                  const DateTimeRange &oldGraphRange) {
                     auto zoomType = DateTimeRangeHelper::getTransformationType(oldGraphRange, graphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 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;
                                     break;
                                 }
                                 case TransformationType::ZoomOut: {
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 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;
                                     break;
                                 }
                                 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 TransformationType::Unknown: {
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->setFlags(GraphFlag::DisableAll);
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->setFlags(GraphFlag::EnableAll);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = DateTimeRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const std::vector<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.empty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.front(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *VisualizationZoneWidget::firstGraph() const
             {
                 VisualizationGraphWidget *firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     if (auto visualizationGraphWidget
                         = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
                 return firstGraph;
             }
             void VisualizationZoneWidget::closeAllGraphs()
             {
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = this->firstGraph()) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
                                                                  const QPointF &plotPosition,
                                                                  VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
                                                                     VisualizationGraphWidget &processedGraph) {
                     switch (sqpApp->plotsCursorMode()) {
                         case SqpApplication::PlotsCursorMode::Vertical:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                             break;
                         case SqpApplication::PlotsCursorMode::Temporal:
                             processedGraph.addVerticalCursor(plotPosition.x());
                             processedGraph.removeHorizontalCursor();
                             break;
                         case SqpApplication::PlotsCursorMode::Horizontal:
                             processedGraph.removeVerticalCursor();
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::Cross:
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.removeVerticalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::NoCursor:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.removeVerticalCursor();
                             break;
                     }
                 });
             }
             void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
                     processedGraph.removeHorizontalCursor();
                     processedGraph.removeVerticalCursor();
                 });
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject{this};
                     connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                             [this, graphWidget, context](auto variable) {
                                 graphWidget->addVariable(variable, graphWidget->graphRange());
                                 delete context; // removes the connection
                             },
                             Qt::QueuedConnection);
                     auto productData = products.first().toHash();
                     QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                               Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.empty()) {
                     // The drop didn't occur in the same zone
                     // 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)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     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();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 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.size() > 1) {
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
                 const QVariantList &productsData, int index, VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (productsData.count() != 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");
                     return;
                 }
                 auto context = new QObject{zoneWidget};
                 connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, index, zoneWidget, context](auto variable) {
                             zoneWidget->createGraph(variable, index);
                             delete context; // removes the connection
                         },
                         Qt::QueuedConnection);
                 auto productData = productsData.first().toHash();
                 QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                           Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
             }

plugins/mockplugin/include/CosinusProvider.h +4 0

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include "MockPluginGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <QUuid>
             #include <QHash>
             Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
             public:
                 std::shared_ptr<IDataProvider> clone() const override;
                 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
+                virtual IDataSeries* getData(const DataProviderParameters &parameters) override;
                 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
                 void requestDataAborting(QUuid acqIdentifier) override;
                 /// Provide data
                 std::shared_ptr<IDataSeries> provideDataSeries(const DateTimeRange &dataRangeRequested,
                                                                const QVariantHash &data);
             private:
                 std::shared_ptr<IDataSeries>
                 retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
+                IDataSeries* _generate(const DateTimeRange &range, const QVariantHash &metaData);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp +52 -11

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <cmath>
             #include <set>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             namespace {
             /// Number of bands generated for a spectrogram
             const auto SPECTROGRAM_NUMBER_BANDS = 30;
             /// Bands for which to generate NaN values for a spectrogram
             const auto SPECTROGRAM_NAN_BANDS = std::set<int>{1, 3, 10, 20};
             /// Bands for which to generate zeros for a spectrogram
             const auto SPECTROGRAM_ZERO_BANDS = std::set<int>{2, 15, 19, 29};
             /// Abstract cosinus type
             struct ICosinusType {
                 virtual ~ICosinusType() = default;
                 /// @return the number of components generated for the type
-                virtual int componentCount() const = 0;
+                virtual std::size_t componentCount() const = 0;
                 /// @return the data series created for the type
-                virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                virtual IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                                       std::vector<double> valuesData) const = 0;
                 /// Generates values (one value per component)
                 /// @param x the x-axis data used to generate values
                 /// @param values the vector in which to insert the generated values
                 /// @param dataIndex the index of insertion of the generated values
                 ///
                 virtual void generateValues(double x, std::vector<double> &values, int dataIndex) const = 0;
             };
             struct ScalarCosinus : public ICosinusType {
-                int componentCount() const override { return 1; }
+                std::size_t componentCount() const override { return 1; }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
+                    return new ScalarSeries(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     values[dataIndex] = std::cos(x);
                 }
             };
             struct SpectrogramCosinus : public ICosinusType {
                 /// Ctor with y-axis
                 explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit, Unit valuesUnit)
                         : m_YAxisData{std::move(yAxisData)},
                           m_YAxisUnit{std::move(yAxisUnit)},
                           m_ValuesUnit{std::move(valuesUnit)}
                 {
                 }
-                int componentCount() const override { return m_YAxisData.size(); }
+                std::size_t componentCount() const override { return m_YAxisData.size(); }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<SpectrogramSeries>(
+                    return new SpectrogramSeries(
                         std::move(xAxisData), m_YAxisData, std::move(valuesData),
                         Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     auto componentCount = this->componentCount();
                     for (int i = 0; i < componentCount; ++i) {
                         auto y = m_YAxisData[i];
                         double value;
                         if (SPECTROGRAM_ZERO_BANDS.find(y) != SPECTROGRAM_ZERO_BANDS.end()) {
                             value = 0.;
                         }
                         else if (SPECTROGRAM_NAN_BANDS.find(y) != SPECTROGRAM_NAN_BANDS.end()) {
                             value = std::numeric_limits<double>::quiet_NaN();
                         }
                         else {
                             // Generates value for non NaN/zero bands
                             auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
                             value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
                         }
                         values[componentCount * dataIndex + i] = value;
                     }
                 }
                 std::vector<double> m_YAxisData;
                 Unit m_YAxisUnit;
                 Unit m_ValuesUnit;
             };
             struct VectorCosinus : public ICosinusType {
-                int componentCount() const override { return 3; }
+                std::size_t componentCount() const override { return 3; }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
+                    return new VectorSeries(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     // Generates value for each component: cos(x), cos(x)/2, cos(x)/3
                     auto xValue = std::cos(x);
                     auto componentCount = this->componentCount();
                     for (auto i = 0; i < componentCount; ++i) {
                         values[componentCount * dataIndex + i] = xValue / (i + 1);
                     }
                 }
             };
             /// Converts string to cosinus type
             /// @return the cosinus type if the string could be converted, nullptr otherwise
             std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
             {
                 if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<ScalarCosinus>();
                 }
                 else if (type.compare(QStringLiteral("spectrogram"), Qt::CaseInsensitive) == 0) {
                     // Generates default y-axis data for spectrogram [0., 1., 2., ...]
                     std::vector<double> yAxisData(SPECTROGRAM_NUMBER_BANDS);
                     std::iota(yAxisData.begin(), yAxisData.end(), 0.);
                     return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"},
                                                                 Unit{"eV/(cm^2-s-sr-eV)"});
                 }
                 else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<VectorCosinus>();
                 }
                 else {
                     return nullptr;
                 }
             }
             } // namespace
             std::shared_ptr<IDataProvider> CosinusProvider::clone() const
             {
                 // No copy is made in clone
                 return std::make_shared<CosinusProvider>();
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const DateTimeRange &dataRangeRequested,
                                                                        const QVariantHash &data)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Retrieves cosinus type
                 auto typeVariant = data.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
                 if (!typeVariant.canConvert<QString>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid type");
                     return nullptr;
                 }
                 auto type = cosinusType(typeVariant.toString());
                 if (!type) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: unknown type");
                     return nullptr;
                 }
                 // Retrieves frequency
                 auto freqVariant = data.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
                 if (!freqVariant.canConvert<double>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid frequency");
                     return nullptr;
                 }
                 // Gets the timerange from the parameters
                 double freq = freqVariant.toDouble();
                 double start = std::ceil(dataRangeRequested.m_TStart * freq);
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second, end value is
                 // included)
                 auto dataCount = end - start + 1;
                 // Number of components (depending on the cosinus type)
                 auto componentCount = type->componentCount();
                 auto xAxisData = std::vector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = std::vector<double>{};
                 valuesData.resize(dataCount * componentCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time <= end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto x = time / freq;
                         xAxisData[dataIndex] = x;
                         // Generates values (depending on the type)
                         type->generateValues(x, valuesData, dataIndex);
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
                             qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
                                                            << QThread::currentThread()->objectName()
                                                            << progress;
                             // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 if (progress != 100) {
                     // We can close progression beacause all data has been retrieved
                     emit dataProvidedProgress(acqIdentifier, 100);
                 }
+                return std::shared_ptr<IDataSeries>(type->createDataSeries(std::move(xAxisData), std::move(valuesData)));
+            }
+            IDataSeries *CosinusProvider::_generate(const DateTimeRange &range, const QVariantHash &metaData)
+            {
+                auto dataIndex = 0;
+                // Retrieves cosinus type
+                auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
+                auto type = cosinusType(typeVariant.toString());
+                auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
+                double freq = freqVariant.toDouble();
+                double start = std::ceil(range.m_TStart * freq);
+                double end = std::floor(range.m_TEnd * freq);
+                if (end < start) {
+                    std::swap(start, end);
+                }
+                std::size_t dataCount = static_cast<std::size_t>(end - start + 1);
+                std::size_t componentCount = type->componentCount();
+                auto xAxisData = std::vector<double>{};
+                xAxisData.resize(dataCount);
+                auto valuesData = std::vector<double>{};
+                valuesData.resize(dataCount * componentCount);
+                int progress = 0;
+                auto progressEnd = dataCount;
+                for (auto time = start; time <= end; ++time, ++dataIndex)
+                {
+                        const auto x = time / freq;
+                        xAxisData[dataIndex] = x;
+                        // Generates values (depending on the type)
+                        type->generateValues(x, valuesData, dataIndex);
+                }
                 return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime, parameters.m_Data);
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
+            IDataSeries* CosinusProvider::getData(const DataProviderParameters &parameters)
+            {
+                return _generate(parameters.m_Times.front(),parameters.m_Data);
+            }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCDebug(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const DateTimeRange &dataRangeRequested,
                                                                             const QVariantHash &data)
             {
                 auto uid = QUuid::createUuid();
                 m_VariableToEnableProvider[uid] = true;
                 auto dataSeries = this->retrieveData(uid, dataRangeRequested, data);
                 m_VariableToEnableProvider.remove(uid);
                 return dataSeries;
             }

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