HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r850:2e038915a77e

drop of variables in the visualization

trabillard -

r850:2e038915a77e

parent child

Context file:

r850:2e038915a77e

core/src/Variable/VariableModel.cpp +5 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/StringUtils.h>
             #include <Data/IDataSeries.h>
             #include <QMimeData>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NBPOINTS_COLUMN = 3;
             const auto UNIT_COLUMN = 4;
             const auto MISSION_COLUMN = 5;
             const auto PLUGIN_COLUMN = 6;
             const auto NB_COLUMNS = 7;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},      {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                 {UNIT_COLUMN, {QObject::tr("Unit")}},      {MISSION_COLUMN, {QObject::tr("Mission")}},
                 {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             QString uniqueName(const QString &defaultName,
                                const std::vector<std::shared_ptr<Variable> > &variables)
             {
                 auto forbiddenNames = std::vector<QString>(variables.size());
                 std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
                                [](const auto &variable) { return variable->name(); });
                 auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
             }
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 VariableController *m_VariableController;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(VariableController *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
                 impl->m_VariableController = parent;
             }
             void VariableModel::addVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 // Generates unique name for the variable
                 variable->setName(uniqueName(variable->name(), impl->m_Variables));
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
             }
             bool VariableModel::containsVariable(std::shared_ptr<Variable> variable) const noexcept
             {
                 auto end = impl->m_Variables.cend();
                 return std::find(impl->m_Variables.cbegin(), end, variable) != end;
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto variable = std::make_shared<Variable>(name, metadata);
                 addVariable(variable);
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             std::vector<std::shared_ptr<Variable> > VariableModel::variables() const
             {
                 return impl->m_Variables;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case TEND_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case NBPOINTS_COLUMN:
                                 return variable->nbPoints();
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             Qt::ItemFlags VariableModel::flags(const QModelIndex &index) const
             {
                 return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel::supportedDropActions() const
             {
                 return Qt::MoveAction;
             }
             Qt::DropActions VariableModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel::mimeTypes() const
             {
                 return {MIME_TYPE_VARIABLE_LIST};
             }
             QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 QList<std::shared_ptr<Variable> > variableList;
                 for (const auto &index : indexes) {
-                    auto variable = impl->m_Variables.at(index.row());
+                    if (index.column() == 0) { // only the first column
-                    if (variable.get() && index.isValid()) {
+                        auto variable = impl->m_Variables.at(index.row());
-                        variableList << variable;
+                        if (variable.get() && index.isValid()) {
+                            variableList << variable;
+                        }
                     }
                 }
                 auto encodedData = impl->m_VariableController->mimeDataForVariables(variableList);
                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, encodedData);
                 return mimeData;
             }
             bool VariableModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                 int column, const QModelIndex &parent) const
             {
                 return false;
             }
             bool VariableModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent)
             {
                 return false;
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

gui/include/DragDropHelper.h +43 -23

@@ -1,65 +1,85
1	#ifndef SCIQLOP_DRAGDROPHELPER_H	1	#ifndef SCIQLOP_DRAGDROPHELPER_H
2	#define SCIQLOP_DRAGDROPHELPER_H	2	#define SCIQLOP_DRAGDROPHELPER_H
3		3
4	#include <Common/spimpl.h>	4	#include <Common/spimpl.h>
		5	#include <QLoggingCategory>
5	#include <QWidget>	6	#include <QWidget>
6		7
7	class QVBoxLayout;	8	class QVBoxLayout;
8	class QScrollArea;	9	class QScrollArea;
9	class VisualizationDragWidget;	10	class VisualizationDragWidget;
		11	class VisualizationDragDropContainer;
10	class QMimeData;	12	class QMimeData;
11		13
12	/**	14	Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
13	* @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
14	* @note A QScrollArea inside an other QScrollArea is not fully supported.
15	*/
16	class DragDropScroller : public QObject {
17	Q_OBJECT
18
19	public:
20	DragDropScroller(QObject *parent = nullptr);
21
22	void addScrollArea(QScrollArea *scrollArea);
23	void removeScrollArea(QScrollArea *scrollArea);
24
25	protected:
26	bool eventFilter(QObject obj, QEvent event);
27
28	private:
29	class DragDropScrollerPrivate;
30	spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
31
32	private slots:
33	void onTimer();
34	};
35		15
36	/**	16	/**
37	* @brief Helper class for drag&drop operations.	17	* @brief Helper class for drag&drop operations.
		18	* @note The helper is accessible from the sqpApp singleton and has the same life as the whole
		19	* application (like a controller). But contrary to a controller, it doesn't live in a thread and
		20	* can interect with the gui.
		21	* @see SqpApplication
38	*/	22	*/
39	class DragDropHelper {	23	class DragDropHelper {
40	public:	24	public:
41	static const QString MIME_TYPE_GRAPH;	25	static const QString MIME_TYPE_GRAPH;
42	static const QString MIME_TYPE_ZONE;	26	static const QString MIME_TYPE_ZONE;
43		27
44	DragDropHelper();	28	DragDropHelper();
45	virtual ~DragDropHelper();	29	virtual ~DragDropHelper();
46		30
		31	/// Resets some internal variables. Must be called before any new drag&drop operation.
		32	void resetDragAndDrop();
		33
		34	/// Sets the visualization widget currently being drag on the visualization.
47	void setCurrentDragWidget(VisualizationDragWidget *dragWidget);	35	void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
		36
		37	/// Returns the visualization widget currently being drag on the visualization.
		38	/// Can be null if a new visualization widget is intended to be created by the drag&drop
		39	/// operation.
48	VisualizationDragWidget *getCurrentDragWidget() const;	40	VisualizationDragWidget *getCurrentDragWidget() const;
49		41
50	QWidget &placeHolder() const;	42	QWidget &placeHolder() const;
51	void insertPlaceHolder(QVBoxLayout *layout, int index);	43	void insertPlaceHolder(QVBoxLayout *layout, int index);
52	void removePlaceHolder();	44	void removePlaceHolder();
53	bool isPlaceHolderSet() const;	45	bool isPlaceHolderSet() const;
54		46
		47	/// Checks if the specified mime data is valid for a drop in the visualization
		48	bool checkMimeDataForVisualization(const QMimeData *mimeData,
		49	VisualizationDragDropContainer *dropContainer);
		50
55	void addDragDropScrollArea(QScrollArea *scrollArea);	51	void addDragDropScrollArea(QScrollArea *scrollArea);
56	void removeDragDropScrollArea(QScrollArea *scrollArea);	52	void removeDragDropScrollArea(QScrollArea *scrollArea);
57		53
58	QUrl imageTemporaryUrl(const QImage &image) const;	54	QUrl imageTemporaryUrl(const QImage &image) const;
59		55
60	private:	56	private:
61	class DragDropHelperPrivate;	57	class DragDropHelperPrivate;
62	spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;	58	spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
63	};	59	};
64		60
		61	/**
		62	* @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
		63	* @note A QScrollArea inside an other QScrollArea is not fully supported.
		64	*/
		65	class DragDropScroller : public QObject {
		66	Q_OBJECT
		67
		68	public:
		69	DragDropScroller(QObject *parent = nullptr);
		70
		71	void addScrollArea(QScrollArea *scrollArea);
		72	void removeScrollArea(QScrollArea *scrollArea);
		73
		74	protected:
		75	bool eventFilter(QObject obj, QEvent event);
		76
		77	private:
		78	class DragDropScrollerPrivate;
		79	spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
		80
		81	private slots:
		82	void onTimer();
		83	};
		84
65	#endif // SCIQLOP_DRAGDROPHELPER_H	85	#endif // SCIQLOP_DRAGDROPHELPER_H

gui/include/SqpApplication.h +2 -1

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
             class NetworkController;
             class TimeController;
             class VariableController;
             class VisualizationController;
             class DragDropHelper;
             /**
              * @brief The SqpApplication 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 load 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 SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
                 NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
-                /// Accessors for the differents sciqlop helpers
+                /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
+                /// doesn't live in a thread and access gui
                 DragDropHelper &dragDropHelper() noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/include/Visualization/VisualizationDragDropContainer.h +9 0

             #ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
             #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
             #include <Common/spimpl.h>
+            #include <QLoggingCategory>
             #include <QMimeData>
             #include <QVBoxLayout>
             #include <QWidget>
+            #include <functional>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
             class VisualizationDragWidget;
             class VisualizationDragDropContainer : public QWidget {
                 Q_OBJECT
             signals:
                 void dropOccured(int dropIndex, const QMimeData *mimeData);
             public:
+                using AcceptMimeDataFunction = std::function<bool(const QMimeData *mimeData)>;
                 VisualizationDragDropContainer(QWidget *parent = nullptr);
                 void addDragWidget(VisualizationDragWidget *dragWidget);
                 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
                 void setAcceptedMimeTypes(const QStringList &mimeTypes);
                 void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
                 int countDragWidget() const;
+                void setAcceptMimeDataFunction(AcceptMimeDataFunction fun);
             protected:
                 void dragEnterEvent(QDragEnterEvent *event);
                 void dragLeaveEvent(QDragLeaveEvent *event);
                 void dragMoveEvent(QDragMoveEvent *event);
                 void dropEvent(QDropEvent *event);
             private:
                 class VisualizationDragDropContainerPrivate;
                 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
             private slots:
                 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
             };
             #endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H

gui/src/DragDropHelper.cpp +63 -1

             #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 {
-                        m_PlaceHolder->setMinimumSize(200, 200);
+                        // Configuration of the placeHolder when there is no dragWidget
+                        // (for instance with a drag from a variable)
+                        m_PlaceHolder->setMinimumSize(400, 300);
+                        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)
+            {
+                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/Variable/VariableInspectorWidget.cpp +6 0

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

gui/src/Visualization/VisualizationDragDropContainer.cpp +85 -28

             #include "Visualization/VisualizationDragDropContainer.h"
             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
+            Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
                 QStringList m_AcceptedMimeTypes;
                 QStringList m_MergeAllowedMimeTypes;
+                VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
+                    = [](auto mimeData) { return true; };
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 bool acceptMimeData(const QMimeData *data) const
                 {
                     for (const auto &type : m_AcceptedMimeTypes) {
-                        if (data->hasFormat(type)) {
+                        if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool allowMergeMimeData(const QMimeData *data) const
                 {
                     for (const auto &type : m_MergeAllowedMimeTypes) {
                         if (data->hasFormat(type)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
                     return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
                 }
                 VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
                 {
                     VisualizationDragWidget *dragWidget = nullptr;
                     for (auto child : parent->children()) {
                         auto widget = qobject_cast<VisualizationDragWidget *>(child);
                         if (widget && widget->isVisible()) {
                             if (widget->frameGeometry().contains(pos)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 bool cursorIsInContainer(QWidget *container) const
                 {
                     auto adustNum = 18; // to be safe, in case of scrollbar on the side
                     auto containerRect = QRect(QPoint(), container->contentsRect().size())
                                              .adjusted(adustNum, adustNum, -adustNum, -adustNum);
                     return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
                 }
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
                     : QWidget{parent},
                       impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
             {
                 setAcceptDrops(true);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
             {
                 impl->m_AcceptedMimeTypes = mimeTypes;
             }
             void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
             {
                 impl->m_MergeAllowedMimeTypes = mimeTypes;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
                 auto nbGraph = 0;
                 for (auto child : children()) {
                     if (qobject_cast<VisualizationDragWidget *>(child)) {
                         nbGraph += 1;
                     }
                 }
                 return nbGraph;
             }
+            void VisualizationDragDropContainer::setAcceptMimeDataFunction(
+                VisualizationDragDropContainer::AcceptMimeDataFunction fun)
+            {
+                impl->m_AcceptMimeDataFun = fun;
+            }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
                 auto &helper = sqpApp->dragDropHelper();
+                helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 drag->setHotSpot(dragPosition);
                 auto mimeData = dragWidget->mimeData();
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap(dragWidget->size());
                 dragWidget->render(&pixmap);
                 drag->setPixmap(pixmap);
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
                     helper.setCurrentDragWidget(dragWidget);
                     if (impl->cursorIsInContainer(this)) {
                         auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                         helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
                         dragWidget->setVisible(false);
                     }
-                // Note: The exec() is blocking on windows but not on linux and macOS
+                    // Note: The exec() is blocking on windows but not on linux and macOS
-                drag->exec(Qt::MoveAction | Qt::CopyAction);
+                    drag->exec(Qt::MoveAction | Qt::CopyAction);
+                }
+                else {
+                    qCWarning(LOG_VisualizationDragDropContainer())
+                        << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
+                              "VisualizationDragWidget is not found in this container.");
+                }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
                     auto &helper = sqpApp->dragDropHelper();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
-                        auto parentWidget
-                            = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
+                        if (dragWidget) {
-                        if (parentWidget) {
+                            // If the drag&drop is internal to the visualization, entering the container hide
-                            dragWidget->setVisible(false);
+                            // the dragWidget which was hidden by the dragLeaveEvent
+                            auto parentWidget
+                                = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
+                            if (parentWidget) {
+                                dragWidget->setVisible(false);
+                            }
                         }
                         auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
                         if (dragWidgetHovered) {
                             auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
-                            auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
-                            if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
+                            if (dragWidget) {
-                                hoveredWidgetIndex
+                                auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
-                                    += 1; // Correction of the index if the drop occurs in the same container
+                                if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
+                                    // Correction of the index if the drop occurs in the same container
+                                    // and if the drag is started from the visualization (in that case, the
+                                    // dragWidget is hidden)
+                                    hoveredWidgetIndex += 1;
+                                }
                             }
                             helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
                         }
                         else {
                             helper.insertPlaceHolder(impl->m_Layout, 0);
                         }
                     }
+                    else {
+                        // do nothing
+                    }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
                 auto &helper = sqpApp->dragDropHelper();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
-                    bool isInternal = true;
+                    auto dragWidget = helper.getCurrentDragWidget();
-                    if (isInternal) {
+                    if (dragWidget) {
-                        // Only if the drag is started from the visualization
+                        // dragWidget has a value only if the drag is started from the visualization
-                        // Show the drag widget at its original place
+                        // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
-                        auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
                         if (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
+                else {
+                    // Leave event probably received for a child widget.
+                    // Do nothing.
+                    // Note: The DragLeave event, doesn't have any mean to determine who sent it.
+                }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
                     if (dragWidgetHovered) {
                         auto canMerge = impl->allowMergeMimeData(event->mimeData());
                         auto nbDragWidget = countDragWidget();
                         if (nbDragWidget > 0) {
                             auto graphHeight = size().height() / nbDragWidget;
                             auto dropIndex = floor(event->pos().y() / graphHeight);
                             auto zoneSize = qMin(graphHeight / 3.0, 150.0);
                             auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
                             auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
                             auto &helper = sqpApp->dragDropHelper();
                             auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
                             if (isOnTop || isOnBottom) {
                                 if (isOnBottom) {
                                     dropIndex += 1;
                                 }
-                                auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                                if (helper.getCurrentDragWidget()) {
-                                if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                                    auto dragWidgetIndex
-                                    dropIndex += 1; // Correction of the index if the drop occurs in the same
+                                        = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
-                                                    // container
+                                    if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                                        // Correction of the index if the drop occurs in the same container
+                                        // and if the drag is started from the visualization (in that case, the
+                                        // dragWidget is hidden)
+                                        dropIndex += 1;
+                                    }
                                 }
                                 if (dropIndex != placeHolderIndex) {
                                     helper.insertPlaceHolder(impl->m_Layout, dropIndex);
                                 }
                             }
                             else if (canMerge) {
                                 // drop on the middle -> merge
                                 if (impl->hasPlaceHolder()) {
                                     helper.removePlaceHolder();
                                 }
                             }
                         }
+                        else {
+                            qCWarning(LOG_VisualizationDragDropContainer())
+                                << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
+                                      "container");
+                        }
+                    }
+                    else {
+                        // No hovered drag widget, the mouse is probably hover the placeHolder
+                        // Do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragMoveEvent(event);
             }
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
-                    if (impl->hasPlaceHolder() && dragWidget) {
+                    if (impl->hasPlaceHolder()) {
                         auto &helper = sqpApp->dragDropHelper();
                         auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
-                        auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
+                        if (dragWidget) {
-                        if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
+                            auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
-                            droppedIndex
+                            if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
-                                -= 1; // Correction of the index if the drop occurs in the same container
+                                // Correction of the index if the drop occurs in the same container
+                                // and if the drag is started from the visualization (in that case, the
+                                // dragWidget is hidden)
+                                droppedIndex -= 1;
+                            }
-                        dragWidget->setVisible(true);
+                            dragWidget->setVisible(true);
+                        }
                         event->acceptProposedAction();
                         helper.removePlaceHolder();
                         emit dropOccured(droppedIndex, event->mimeData());
                     }
+                    else {
+                        qCWarning(LOG_VisualizationDragDropContainer())
+                            << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
+                                  "placeHolder is not found.");
+                        Q_ASSERT(false);
+                    }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dropEvent(event);
             }

gui/src/Visualization/VisualizationTabWidget.cpp +117 -43

             #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});
+                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)
             {
-                auto &helper = sqpApp->dragDropHelper();
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
-                    auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                    impl->dropGraph(index, this);
-                    auto parentDragDropContainer
-                        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+                else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
-                    Q_ASSERT(parentDragDropContainer);
+                    impl->dropZone(index, this);
+                }
-                    auto nbGraph = parentDragDropContainer->countDragWidget();
+                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                    auto variables = sqpApp->variableController().variablesForMimeData(
-                    const auto &variables = graphWidget->variables();
+                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                    impl->dropVariables(variables, index, this);
-                    if (!variables.isEmpty()) {
-                        // Abort the requests for the variables (if any)
+                else {
-                        // Commented, because it's not sure if it's needed or not
+                    qCWarning(LOG_VisualizationZoneWidget())
-                        // for (const auto& var : variables)
+                        << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
-                        //{
-                        //    sqpApp->variableController().onAbortProgressRequested(var);
-                        //}
+            void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
-                        if (nbGraph == 1) {
+                int index, VisualizationTabWidget *tabWidget)
-                            // This is the only graph in the previous zone, close the zone
-                            graphWidget->parentZoneWidget()->close();
+                auto &helper = sqpApp->dragDropHelper();
-                        else {
+                auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
-                            // Close the graph
+                if (!graphWidget) {
-                            graphWidget->close();
+                    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();
-                        createZone(variables, index);
+                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 {
-                        // The graph is empty, create an empty zone and move the graph inside
+                        // Close the graph
+                        graphWidget->close();
+                    }
-                        auto parentZoneWidget = graphWidget->parentZoneWidget();
+                    tabWidget->createZone(variables, index);
+                }
+                else {
+                    // The graph is empty, create an empty zone and move the graph inside
-                        parentDragDropContainer->layout()->removeWidget(graphWidget);
+                    auto parentZoneWidget = graphWidget->parentZoneWidget();
-                        auto zoneWidget = createEmptyZone(index);
+                    parentDragDropContainer->layout()->removeWidget(graphWidget);
-                        zoneWidget->addGraph(graphWidget);
-                        // Close the old zone if it was the only graph inside
+                    auto zoneWidget = tabWidget->createEmptyZone(index);
-                        if (nbGraph == 1) {
+                    zoneWidget->addGraph(graphWidget);
-                            parentZoneWidget->close();
+                    // Close the old zone if it was the only graph inside
+                    if (nbGraph == 1) {
+                        parentZoneWidget->close();
                     }
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
-                    // Simple move of the zone, no variable operation associated
-                    auto zoneWidget = static_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
-                    auto parentDragDropContainer = zoneWidget->parentWidget();
-                    parentDragDropContainer->layout()->removeWidget(zoneWidget);
-                    ui->dragDropContainer->insertDragWidget(index, zoneWidget);
+            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
+                // because the AcceptMimeDataFunction, set on the drop container, makes the check before the
+                // drop can occur.
+                tabWidget->createZone(variables, index);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +118 -45

             #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 <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 {
             /// Minimum height for graph added in zones (in pixels)
             const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// 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});
+                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());
                 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)
             {
-                auto &helper = sqpApp->dragDropHelper();
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
-                    auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                    impl->dropGraph(index, this);
-                    auto parentDragDropContainer
-                        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-                    Q_ASSERT(parentDragDropContainer);
+                    auto variables = sqpApp->variableController().variablesForMimeData(
+                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
-                    const auto &variables = graphWidget->variables();
+                    impl->dropVariables(variables, index, this);
+                }
-                    if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
+                else {
-                        // The drop didn't occur in the same zone
+                    qCWarning(LOG_VisualizationZoneWidget())
+                        << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
-                        // 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)
-                        //{
+            void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
-                        //    sqpApp->variableController().onAbortProgressRequested(var);
+                int index, VisualizationZoneWidget *zoneWidget)
-                        //}
+                auto &helper = sqpApp->dragDropHelper();
-                        auto previousParentZoneWidget = graphWidget->parentZoneWidget();
-                        auto nbGraph = parentDragDropContainer->countDragWidget();
+                auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
-                        if (nbGraph == 1) {
+                if (!graphWidget) {
-                            // This is the only graph in the previous zone, close the zone
+                    qCWarning(LOG_VisualizationZoneWidget())
-                            previousParentZoneWidget->close();
+                        << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
+                              "found or invalid.");
-                        else {
+                    Q_ASSERT(false);
-                            // Close the graph
+                    return;
-                            graphWidget->close();
+                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();
-                        // Creates the new graph in the zone
+                if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
-                        createGraph(variables, index);
+                    // 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 {
-                        // The drop occurred in the same zone or the graph is empty
+                        // Close the graph
-                        // Simple move of the graph, no variable operation associated
+                        graphWidget->close();
-                        parentDragDropContainer->layout()->removeWidget(graphWidget);
-                        if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
+                    // Creates the new graph in the zone
-                            // The graph is empty and dropped in a different zone.
+                    zoneWidget->createGraph(variables, index);
-                            // Take the range of the first graph in the zone (if existing).
-                            auto layout = ui->dragDropContainer->layout();
+                else {
-                            if (layout->count() > 0) {
+                    // The drop occurred in the same zone or the graph is empty
-                                if (auto visualizationGraphWidget
+                    // Simple move of the graph, no variable operation associated
-                                    = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                    parentDragDropContainer->layout()->removeWidget(graphWidget);
-                                    graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
+                    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
+                auto parent = zoneWidget->parentWidget();
+                while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
+                    parent = parent->parentWidget();
+                }
+                if (!parent) {
+                    qCWarning(LOG_VisualizationZoneWidget())
+                        << tr("VisualizationZoneWidget::dropVariables, drop aborted, the parent "
+                              "VisualizationWidget cannot be found.");
+                    Q_ASSERT(false);
+                    return;
+                }
+                auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
-                        ui->dragDropContainer->insertDragWidget(index, graphWidget);
+                // 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;
                     }
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages