GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r876:86e05857e5c8

Drag of product

trabillard -

r876:86e05857e5c8

parent child

Context file:

r876:86e05857e5c8

gui/include/DataSource/DataSourceTreeWidget.h created 644 +14 0

@@ -0,0 +1,14
	1	#ifndef SCIQLOP_DATASOURCETREEWIDGET_H
	2	#define SCIQLOP_DATASOURCETREEWIDGET_H
	3
	4	#include <QTreeWidget>
	5
	6	class DataSourceTreeWidget : public QTreeWidget {
	7	public:
	8	DataSourceTreeWidget(QWidget *parent);
	9
	10	protected:
	11	QMimeData mimeData(const QList<QTreeWidgetItem > items) const override;
	12	};
	13
	14	#endif // SCIQLOP_DATASOURCETREEWIDGET_H

gui/src/DataSource/DataSourceTreeWidget.cpp created 644 +37 0

@@ -0,0 +1,37
	1	#include "DataSource/DataSourceTreeWidget.h"
	2	#include "Common/MimeTypesDef.h"
	3	#include "DataSource/DataSourceController.h"
	4	#include "DataSource/DataSourceItem.h"
	5	#include "DataSource/DataSourceTreeWidgetItem.h"
	6
	7	#include "SqpApplication.h"
	8
	9	#include <QMimeData>
	10
	11	DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) {}
	12
	13	QMimeData DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem > items) const
	14	{
	15	auto mimeData = new QMimeData;
	16
	17	// Basic check to ensure the item are correctly typed
	18	Q_ASSERT(items.isEmpty() \|\| dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr);
	19
	20	QVariantList productData;
	21
	22	for (auto item : items) {
	23	auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item);
	24	auto dataSource = dataSourceTreeItem->data();
	25
	26	if (dataSource->type() == DataSourceItemType::COMPONENT
	27	\|\| dataSource->type() == DataSourceItemType::PRODUCT) {
	28	auto metaData = dataSource->data();
	29	productData << metaData;
	30	}
	31	}
	32
	33	auto encodedData = sqpApp->dataSourceController().mimeDataForProductsData(productData);
	34	mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData);
	35
	36	return mimeData;
	37	}

core/include/Common/MimeTypesDef.h +1 0

             #ifndef SCIQLOP_MIMETYPESDEF_H
             #define SCIQLOP_MIMETYPESDEF_H
             #include "CoreGlobal.h"
             #include <QString>
             // ////////////////// //
             // SciQlop Mime Types //
             // ////////////////// //
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_GRAPH;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_ZONE;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
+            extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_PRODUCT_LIST;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
             #endif // SCIQLOP_MIMETYPESDEF_H

core/include/DataSource/DataSourceController.h +3 0

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
             class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
             class SCIQLOP_CORE_EXPORT DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataSourceItem the structure of the data source. It must be not null to be registered
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
                 /**
                  * Sets the data provider used to retrieve data from of a data source. The controller takes
                  * ownership of the provider.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataProvider the provider of the data source
                  * @sa registerDataSource()
                  */
                 void setDataProvider(const QUuid &dataSourceUid,
                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
                 /**
                  * Loads an item (product) as a variable in SciQlop
                  * @param dataSourceUid the unique id of the data source containing the item. It is used to get
                  * the data provider associated to the data source, and pass it to for the variable creation
                  * @param productItem the item to load
                  */
                 void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
+                QByteArray mimeDataForProductsData(const QVariantList &productsData) const;
+                QVariantList productsDataForMimeData(const QByteArray &mimeData) const;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(DataSourceItem *dataSourceItem);
                 /**
                  * Signal emitted when a variable creation is asked for a product
                  * @param variableName the name of the variable
                  * @param variableMetadata the metadata of the variable
                  * @param variableProvider the provider that will be used to retrieve the data of the variable
                  * (can be null)
                  */
                 void variableCreationRequested(const QString &variableName,
                                                const QVariantHash &variableMetadata,
                                                std::shared_ptr<IDataProvider> variableProvider);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/meson.build +2 0

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
+              'include/DataSource/DataSourceWidget.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableCacheStrategy.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
+              'src/DataSource/DataSourceWidget.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/Common/MimeTypesDef.cpp +5 -4

@@ -1,6 +1,7
1	#include "Common/MimeTypesDef.h"	1	#include "Common/MimeTypesDef.h"
2		2
3	const QString MIME_TYPE_GRAPH = QStringLiteral("scqlop/graph");	3	const QString MIME_TYPE_GRAPH = QStringLiteral("sciqlop/graph");
4	const QString MIME_TYPE_ZONE = QStringLiteral("scqlop/zone");	4	const QString MIME_TYPE_ZONE = QStringLiteral("sciqlop/zone");
5	const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("scqlop/var-list");	5	const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("sciqlop/var-list");
6	const QString MIME_TYPE_~~TIME_RANGE~~ = QStringLiteral("sc~~qlop/time-range~~");	6	const QString MIME_TYPE_PRODUCT_LIST = QStringLiteral("sciqlop/product-list");
		7	const QString MIME_TYPE_TIME_RANGE = QStringLiteral("sciqlop/time-range");

core/src/DataSource/DataSourceController.cpp +20 0

             #include "DataSource/DataSourceController.h"
             #include "DataSource/DataSourceItem.h"
             #include <Data/IDataProvider.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             namespace {
             /**
              * Builds the metadata of the variable that will be generated from the loading of an item
              * @param dataSourceItem the data source item from which to generate the metadata
              * @return the metadata of the variable
              */
             QVariantHash variableMetadata(const DataSourceItem &dataSourceItem)
             {
                 // Variable metadata contains...
                 // ... all metadata of the item
                 auto result = dataSourceItem.data();
                 // ... and the name of the plugin, recovered from root item
                 result.insert(QStringLiteral("plugin"), dataSourceItem.rootItem().name());
                 return result;
             }
             } // namespace
             class DataSourceController::DataSourceControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 /// Data sources registered
                 QHash<QUuid, QString> m_DataSources;
                 /// Data sources structures
                 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
                 /// Data providers registered
                 /// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
                 /// continue to live without necessarily the data source controller
                 std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
             };
             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
                                                     << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
                                                     << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
             {
                 auto dataSourceUid = QUuid::createUuid();
                 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
                 return dataSourceUid;
             }
             void DataSourceController::setDataSourceItem(
                 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
                 if (!dataSourceItem) {
                     qCWarning(LOG_DataSourceController())
                         << tr("Data source item can't be registered (null item)");
                     return;
                 }
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     // The data provider is implicitly converted to a shared_ptr
                     impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                     // Retrieves the data source item to emit the signal with it
                     auto it = impl->m_DataSourceItems.find(dataSourceUid);
                     if (it != impl->m_DataSourceItems.end()) {
                         emit dataSourceItemSet(it->second.get());
                     }
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
                                                                 "data source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
             void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
                                                        std::unique_ptr<IDataProvider> dataProvider) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
                                                                 "source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
             void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
                                                        const DataSourceItem &productItem) noexcept
             {
                 if (productItem.type() == DataSourceItemType::PRODUCT
                     || productItem.type() == DataSourceItemType::COMPONENT) {
                     /// Retrieves the data provider of the data source (if any)
                     auto it = impl->m_DataProviders.find(dataSourceUid);
                     auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
                     emit variableCreationRequested(productItem.name(), variableMetadata(productItem),
                                                    dataProvider);
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
                 }
             }
+            QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData) const
+            {
+                QByteArray encodedData;
+                QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                stream << productsData;
+                return encodedData;
+            }
+            QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData) const
+            {
+                QDataStream stream{mimeData};
+                QVariantList productList;
+                stream >> productList;
+                return productList;
+            }
             void DataSourceController::initialize()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
                                                     << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             struct VariableRequestHandler {
                 VariableRequestHandler()
                 {
                     m_CanUpdate = false;
                     m_State = VariableRequestHandlerState::OFF;
                 }
                 QUuid m_VarId;
                 VariableRequest m_RunningVarRequest;
                 VariableRequest m_PendingVarRequest;
                 VariableRequestHandlerState m_State;
                 bool m_CanUpdate;
             };
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
                               CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariables(QUuid varRequestId);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
                 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
                 VariableController *q;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 // Deletes identifier
                 impl->m_VariableToIdentifierMap.erase(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             QByteArray
             VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
             {
                 auto encodedData = QByteArray{};
                 QVariantList ids;
                 for (auto &var : variables) {
                     auto itVar = impl->m_VariableToIdentifierMap.find(var);
                     if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to find the data for an unknown variable.");
                     }
                     ids << itVar->second.toByteArray();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << ids;
                 return encodedData;
             }
             QList<std::shared_ptr<Variable> >
             VariableController::variablesForMimeData(const QByteArray &mimeData) const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 for (auto id : ids) {
-                    auto uuid = QUuid(id.toByteArray());
+                    auto uuid = QUuid{id.toByteArray()};
                     auto var = impl->findVariable(uuid);
                     variables << var;
                 }
                 return variables;
             }
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto varId = QUuid::createUuid();
                     // Create the handler
                     auto varRequestHandler = std::make_unique<VariableRequestHandler>();
                     varRequestHandler->m_VarId = varId;
                     impl->m_VarIdToVarRequestHandler.insert(
                         std::make_pair(varId, std::move(varRequestHandler)));
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = varId;
                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
                     //        auto varRequestId = QUuid::createUuid();
                     //        qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
                     //        impl->processRequest(newVariable, range, varRequestId);
                     //        impl->updateVariableRequest(varRequestId);
                     return newVariable;
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
                 // DEPRECATED
                 // auto variables = QVector<std::shared_ptr<Variable> >{};
                 //        for (const auto &selectedRow : qAsConst(selectedRows)) {
                 //            if (auto selectedVariable =
                 //            impl->m_VariableModel->variable(selectedRow.row())) {
                 //                variables << selectedVariable;
                 //                // notify that rescale operation has to be done
                 //                emit rangeChanged(selectedVariable, dateTime);
                 //            }
                 //        }
                 //        if (!variables.isEmpty()) {
                 //            this->onRequestDataLoading(variables, dateTime, synchro);
                 //        }
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                         = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
                         auto itVar = impl->m_VariableToIdentifierMap.find(selectedVariable);
                         if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                             qCCritical(LOG_VariableController())
                                 << tr("Impossible to onDateTimeOnSelection request for unknown variable");
                             return;
                         }
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                         auto synchro = impl->m_VariableIdGroupIdMap.find(itVar->second)
                                        != impl->m_VariableIdGroupIdMap.cend();
                         this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{selectedVariable},
                                                    dateTime, synchro);
                     }
                 }
                 else if (selectedRows.size() > 1) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to set time for more than 1 variable in the same time");
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("There is no variable selected to set the time one");
                 }
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariables(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName() << variable->name();
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
                     return;
                 }
                 auto varHandler = itVarHandler->second.get();
                 // case where a variable has a running request
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                                                   << QThread::currentThread()->objectName()
                                                   << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
                             << variable->name();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to synchronize a variable with no identifier") << variable->name();
                 }
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
                 // Gets synchronization group
                 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: unknown synchronization group")
                                .arg(variable->name());
                     return;
                 }
                 auto variableId = variableIt->second;
                 // Removes variable from synchronization group
                 auto synchronizationGroup = groupIt->second;
                 synchronizationGroup->removeVariableId(variableId);
                 // Removes link between variable and synchronization group
                 impl->m_VariableIdGroupIdMap.erase(variableId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 // we want to load data of the variable for the dateTime.
                 if (variables.isEmpty()) {
                     return;
                 }
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId
                                                   << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     for (const auto &var : variables) {
                         auto vId = impl->m_VariableToIdentifierMap.at(var);
                         varIds.push_back(vId);
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
                         qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                 else {
                     auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
                     auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                     if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                         auto groupId = varIdToGroupIdIt->second;
                         auto vSynchronizationGroup
                             = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
                         auto varIds = std::list<QUuid>{};
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
                             // Don't process already processed var
                             if (var != nullptr) {
                                 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
                                                                   << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                                           : computeSynchroRangeRequested(var->range(), range,
                                                                          variables.first()->range());
                                 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                 impl->processRequest(var, vSyncRangeRequested, varRequestId);
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to synchronize a null variable");
                             }
                         }
                     }
                 }
                 impl->updateVariables(varRequestId);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 if (itVar == m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for variable with unknown handler");
                     return;
                 }
                 auto oldRange = var->range();
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
                 }
                 auto varRequest = VariableRequest{};
                 varRequest.m_VariableGroupId = varRequestId;
                 auto varStrategyRangesRequested
                     = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
                 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
                         qCDebug(LOG_VariableController()) << tr("Process Request OFF")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_RunningVarRequest = varRequest;
                         varHandler->m_State = VariableRequestHandlerState::RUNNING;
                         executeVarRequest(var, varRequest);
                         break;
                     }
                     case VariableRequestHandlerState::RUNNING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Unknown VariableRequestHandlerState");
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     return QUuid();
                 }
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
                     qCCritical(LOG_VariableController())
                         << tr("acceptVariableRequest impossible on a variable with OFF state");
                 }
                 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
                 varHandler->m_CanUpdate = true;
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
                 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
                                                   << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
             void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCWarning(LOG_VariableController())
                         << tr("Impossible to updateVariables of unknown variables") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         processVariableUpdate &= itVarHandler->second->m_CanUpdate;
                     }
                 }
                 if (processVariableUpdate) {
                     qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                             if (auto var = findVariable(*varIdsIt)) {
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested
                                                                   << varRequest.m_CacheRangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
                                                                   << var->nbPoints()
                                                                   << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
                                                                   << var->nbPoints();
                                 emit var->updated();
                                 qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                     }
                     updateVariableRequest(varRequestId);
                     // cleaning varRequestId
                     qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
                     m_VarGroupIdToVarIds.erase(varRequestId);
                 }
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController()) << QObject::tr(
                         "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Impossible to update a variable with handler in OFF state");
                             } break;
                             case VariableRequestHandlerState::RUNNING: {
                                 varHandler->m_State = VariableRequestHandlerState::OFF;
                                 varHandler->m_RunningVarRequest = VariableRequest{};
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                 varHandler->m_PendingVarRequest = VariableRequest{};
                                 auto var = findVariable(itVarHandler->first);
                                 executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_VarId = QUuid{};
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCWarning(LOG_VariableController())
                                     << QObject::tr("Impossible to cancel a variable with no running request");
                                 break;
                             }
                             case VariableRequestHandlerState::RUNNING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the running variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                     executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 }
                                 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
                 m_VarGroupIdToVarIds.erase(varRequestId);
             }
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
                 auto varId = m_VariableToIdentifierMap.at(var);
                 auto varCacheRange = var->cacheRange();
                 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                 auto notInCacheRangeList
                     = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 auto inCacheRangeList
                     = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 if (!notInCacheRangeList.empty()) {
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
                             varRequest.m_CacheRangeRequested,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }
             }

gui/src/DragDropHelper.cpp +6 0

             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QDragEnterEvent>
             #include <QDragMoveEvent>
             #include <QScrollArea>
             #include <QScrollBar>
             #include <QTimer>
             #include <QVBoxLayout>
             const int SCROLL_SPEED = 5;
             const int SCROLL_ZONE_SIZE = 50;
             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
             struct DragDropScroller::DragDropScrollerPrivate {
                 QList<QScrollArea *> m_ScrollAreas;
                 QScrollArea *m_CurrentScrollArea = nullptr;
                 std::unique_ptr<QTimer> m_Timer = nullptr;
                 enum class ScrollDirection { up, down, unknown };
                 ScrollDirection m_Direction = ScrollDirection::unknown;
                 explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
                 {
                     m_Timer->setInterval(0);
                 }
             };
             DragDropScroller::DragDropScroller(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
             {
                 connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
             }
             void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_ScrollAreas << scrollArea;
                 scrollArea->viewport()->setAcceptDrops(true);
             }
             void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_ScrollAreas.removeAll(scrollArea);
                 scrollArea->viewport()->setAcceptDrops(false);
             }
             bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
             {
                 if (event->type() == QEvent::DragMove) {
                     auto w = static_cast<QWidget *>(obj);
                     if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
                         auto moveEvent = static_cast<QDragMoveEvent *>(event);
                         auto pos = moveEvent->pos();
                         if (impl->m_CurrentScrollArea->viewport() != w) {
                             auto globalPos = w->mapToGlobal(moveEvent->pos());
                             pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
                         }
                         auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
                                                          - SCROLL_ZONE_SIZE;
                         auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
                         if (!isInTopZone && !isInBottomZone) {
                             impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                             impl->m_Timer->stop();
                         }
                         else if (!impl->m_Timer->isActive()) {
                             impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
                                                             : DragDropScrollerPrivate::ScrollDirection::down;
                             impl->m_Timer->start();
                         }
                     }
                 }
                 else if (event->type() == QEvent::DragEnter) {
                     auto w = static_cast<QWidget *>(obj);
                     for (auto scrollArea : impl->m_ScrollAreas) {
                         if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
                             auto enterEvent = static_cast<QDragEnterEvent *>(event);
                             enterEvent->acceptProposedAction();
                             enterEvent->setDropAction(Qt::IgnoreAction);
                             impl->m_CurrentScrollArea = scrollArea;
                             break;
                         }
                     }
                 }
                 else if (event->type() == QEvent::DragLeave) {
                     if (impl->m_CurrentScrollArea) {
                         if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
                                  .contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
                             impl->m_CurrentScrollArea = nullptr;
                             impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                             impl->m_Timer->stop();
                         }
                     }
                 }
                 else if (event->type() == QEvent::Drop) {
                     if (impl->m_CurrentScrollArea) {
                         impl->m_CurrentScrollArea = nullptr;
                         impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                         impl->m_Timer->stop();
                     }
                 }
                 return false;
             }
             void DragDropScroller::onTimer()
             {
                 if (impl->m_CurrentScrollArea) {
                     auto mvt = 0;
                     switch (impl->m_Direction) {
                         case DragDropScrollerPrivate::ScrollDirection::up:
                             mvt = SCROLL_SPEED;
                             break;
                         case DragDropScrollerPrivate::ScrollDirection::down:
                             mvt = -SCROLL_SPEED;
                             break;
                         default:
                             break;
                     }
                     impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
                         impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
                 }
             }
             struct DragDropHelper::DragDropHelperPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = 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.
                 explicit DragDropHelperPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()}
                 {
                     m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
                 }
                 void preparePlaceHolder() 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);
                     }
                 }
             };
             DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
             {
             }
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget &DragDropHelper::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
             void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder();
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
             void DragDropHelper::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 DragDropHelper::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                VisualizationDragDropContainer *dropContainer)
             {
+                if (!mimeData || !dropContainer) {
+                    qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                        "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
+                    Q_ASSERT(false);
+                }
                 auto result = true;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         // Check that the viariable is not already in a graph
                         // Search for the top level VisualizationWidget
                         auto parent = dropContainer->parentWidget();
                         while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                             parent = parent->parentWidget();
                         }
                         if (parent) {
                             auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                             FindVariableOperation findVariableOperation{variables.first()};
                             visualizationWidget->accept(&findVariableOperation);
                             auto variableContainers = findVariableOperation.result();
                             if (!variableContainers.empty()) {
                                 result = false;
                             }
                         }
                         else {
                             qCWarning(LOG_DragDropHelper()) << QObject::tr(
                                 "DragDropHelper::checkMimeDataForVisualization, the parent "
                                 "VisualizationWidget cannot be found.");
                             result = false;
                         }
                     }
                     else {
                         result = false;
                     }
                 }
                 return result;
             }

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

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <DragDropHelper.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 // Set axes properties according to the units of the data series
                 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                 auto xAxisUnit = Unit{};
                 auto valuesUnit = Unit{};
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     xAxisUnit = dataSeries->xAxisUnit();
                     valuesUnit = dataSeries->valuesUnit();
                     dataSeries->unlock();
                 }
                 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(const SqpRange &range)
             {
                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
-                mimeData->setData(MIME_TYPE_GRAPH, QByteArray());
+                mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                 return mimeData;
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
                 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

gui/src/Visualization/VisualizationTabWidget.cpp +8 -3

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * 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
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, 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);
                 ui->dragDropContainer->setAcceptedMimeTypes(
                     {MIME_TYPE_GRAPH, MIME_TYPE_ZONE, MIME_TYPE_VARIABLE_LIST});
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
                         &VisualizationTabWidget::dropMimeData);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().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);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<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().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 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.isEmpty()) {
                     // 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
                         graphWidget->parentZoneWidget()->close();
                     }
                     else {
                         // Close the graph
                         graphWidget->close();
                     }
                     tabWidget->createZone(variables, index);
                 }
                 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) {
                         parentZoneWidget->close();
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 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 QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
-                // Note: we are sure that there is a single and compatible variable here
+                // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
-                // because the AcceptMimeDataFunction, set on the drop container, makes the check before the
+                // compatible variable here
-                // drop can occur.
+                if (variables.count() > 1) {
+                    qCWarning(LOG_VisualizationZoneWidget())
+                        << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
+                              "aborted.");
+                    return;
                 tabWidget->createZone(variables, index);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +7 -23

             #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/SqpRange.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragDropHelper.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * 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
                             = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             } // 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 QList<std::shared_ptr<Variable> > &variables, 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->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
                         &VisualizationZoneWidget::dropMimeData);
                 // '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::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 SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     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 AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 // Apply visitor to graph children
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
                     if (auto visualizationGraphWidget
                         = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         range = visualizationGraphWidget->graphRange();
                     }
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 // get y using variable range
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     auto valuesBounds
                         = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
                     auto end = dataSeries->cend();
                     if (valuesBounds.first != end && valuesBounds.second != end) {
                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
                         auto minValue = rangeValue(valuesBounds.first->minValue());
                         auto maxValue = rangeValue(valuesBounds.second->maxValue());
                         graphWidget->setYRange(SqpRange{minValue, maxValue});
                     }
                     dataSeries->unlock();
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             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
             {
                 auto mimeData = new QMimeData;
-                mimeData->setData(MIME_TYPE_ZONE, QByteArray());
+                mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             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().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 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.isEmpty()) {
                     // 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
                         previousParentZoneWidget->close();
                     }
                     else {
                         // Close the graph
                         graphWidget->close();
                     }
                     // Creates the new graph in the zone
                     zoneWidget->createGraph(variables, index);
                 }
                 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.isEmpty() && 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 QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
-                // Search for the top level VisualizationWidget
+                // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
-                auto parent = zoneWidget->parentWidget();
+                // compatible variable here
-                while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
+                if (variables.count() > 1) {
-                    parent = parent->parentWidget();
-                if (!parent) {
                     qCWarning(LOG_VisualizationZoneWidget())
-                        << tr("VisualizationZoneWidget::dropVariables, drop aborted, the parent "
+                        << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
-                              "VisualizationWidget cannot be found.");
+                              "aborted.");
-                    Q_ASSERT(false);
                     return;
                 }
-                auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
+                zoneWidget->createGraph({variable}, index);
-                // Search for the first variable which can be dropped
-                for (auto variable : variables) {
-                    FindVariableOperation findVariableOperation{variable};
-                    visualizationWidget->accept(&findVariableOperation);
-                    auto variableContainers = findVariableOperation.result();
-                    if (variableContainers.empty()) {
-                        zoneWidget->createGraph(variable, index);
-                        break;
             }

gui/ui/DataSource/DataSourceWidget.ui +17 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>DataSourceWidget</class>
              <widget class="QWidget" name="DataSourceWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Data sources</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QLineEdit" name="filterLineEdit"/>
                </item>
                <item row="1" column="0">
-                <widget class="QTreeWidget" name="treeWidget">
+                <widget class="DataSourceTreeWidget" name="treeWidget">
+                 <property name="dragEnabled">
+                  <bool>true</bool>
+                 </property>
+                 <property name="dragDropMode">
+                  <enum>QAbstractItemView::DragOnly</enum>
+                 </property>
+                 <property name="selectionMode">
+                  <enum>QAbstractItemView::ExtendedSelection</enum>
+                 </property>
                  <column>
                   <property name="text">
                    <string notr="true">1</string>
                   </property>
                  </column>
                 </widget>
                </item>
               </layout>
              </widget>
+             <customwidgets>
+              <customwidget>
+               <class>DataSourceTreeWidget</class>
+               <extends>QTreeWidget</extends>
+               <header>DataSource/DataSourceTreeWidget.h</header>
+              </customwidget>
+             </customwidgets>
              <resources/>
              <connections/>
             </ui>

General Comments 1

trabillard

|

Auto status change to "Under Review"

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