diff --git a/core/include/Common/MimeTypesDef.h b/core/include/Common/MimeTypesDef.h
new file mode 100644
index 0000000..2212853
--- /dev/null
+++ b/core/include/Common/MimeTypesDef.h
@@ -0,0 +1,18 @@
+#ifndef SCIQLOP_MIMETYPESDEF_H
+#define SCIQLOP_MIMETYPESDEF_H
+
+#include "CoreGlobal.h"
+
+#include <QString>
+
+// ////////////////// //
+// SciQlop Mime Types //
+// ////////////////// //
+
+extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_GRAPH;
+extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_ZONE;
+extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
+extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
+
+
+#endif // SCIQLOP_MIMETYPESDEF_H
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index 3e18ad1..b198dcd 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -68,6 +68,8 @@ public:
      */
     void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
 
+    QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;
+    QList<std::shared_ptr<Variable> > variablesForMimeData(const QByteArray &mimeData) const;
 
     static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
 signals:
diff --git a/core/include/Variable/VariableModel.h b/core/include/Variable/VariableModel.h
index 960ea81..95da42c 100644
--- a/core/include/Variable/VariableModel.h
+++ b/core/include/Variable/VariableModel.h
@@ -18,6 +18,7 @@ enum VariableRoles { ProgressRole = Qt::UserRole };
 
 class IDataSeries;
 class Variable;
+class VariableController;
 
 /**
  * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
@@ -25,7 +26,7 @@ class Variable;
 class SCIQLOP_CORE_EXPORT VariableModel : public QAbstractTableModel {
     Q_OBJECT
 public:
-    explicit VariableModel(QObject *parent = nullptr);
+    explicit VariableModel(VariableController *parent = nullptr);
 
     /**
      * Adds an existing variable in the model.
@@ -73,7 +74,20 @@ public:
     virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     virtual QVariant headerData(int section, Qt::Orientation orientation,
                                 int role = Qt::DisplayRole) const override;
-
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
+
+    // ///////////////// //
+    // Drag&Drop methods //
+    // ///////////////// //
+
+    virtual Qt::DropActions supportedDropActions() const override;
+    virtual Qt::DropActions supportedDragActions() const override;
+    virtual QStringList mimeTypes() const override;
+    virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
+    virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                                 const QModelIndex &parent) const override;
+    virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                              const QModelIndex &parent) override;
 
     void abortProgress(const QModelIndex &index);
 
diff --git a/core/src/Common/MimeTypesDef.cpp b/core/src/Common/MimeTypesDef.cpp
new file mode 100644
index 0000000..24ef739
--- /dev/null
+++ b/core/src/Common/MimeTypesDef.cpp
@@ -0,0 +1,6 @@
+#include "Common/MimeTypesDef.h"
+
+const QString MIME_TYPE_GRAPH = QStringLiteral("scqlop/graph");
+const QString MIME_TYPE_ZONE = QStringLiteral("scqlop/zone");
+const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("scqlop/var-list");
+const QString MIME_TYPE_TIME_RANGE = QStringLiteral("scqlop/time-range");
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index d1865e6..5377542 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -12,6 +12,7 @@
 #include <Data/VariableRequest.h>
 #include <Time/TimeController.h>
 
+#include <QDataStream>
 #include <QMutex>
 #include <QThread>
 #include <QUuid>
@@ -277,6 +278,46 @@ void VariableController::deleteVariables(
     }
 }
 
+QByteArray
+VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
+{
+    auto encodedData = QByteArray{};
+
+    QVariantList ids;
+    for (auto &var : variables) {
+        auto itVar = impl->m_VariableToIdentifierMap.find(var);
+        if (itVar == impl->m_VariableToIdentifierMap.cend()) {
+            qCCritical(LOG_VariableController())
+                << tr("Impossible to find the data for an unknown variable.");
+        }
+
+        ids << itVar->second.toByteArray();
+    }
+
+    QDataStream stream{&encodedData, QIODevice::WriteOnly};
+    stream << ids;
+
+    return encodedData;
+}
+
+QList<std::shared_ptr<Variable> >
+VariableController::variablesForMimeData(const QByteArray &mimeData) const
+{
+    auto variables = QList<std::shared_ptr<Variable> >{};
+    QDataStream stream{mimeData};
+
+    QVariantList ids;
+    stream >> ids;
+
+    for (auto id : ids) {
+        auto uuid = QUuid(id.toByteArray());
+        auto var = impl->findVariable(uuid);
+        variables << var;
+    }
+
+    return variables;
+}
+
 std::shared_ptr<Variable>
 VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                    std::shared_ptr<IDataProvider> provider) noexcept
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index e5f9947..ccc9933 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -1,11 +1,14 @@
 #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>
 
@@ -66,14 +69,16 @@ 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(QObject *parent)
+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
@@ -255,6 +260,59 @@ QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int
     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) {
+        if (index.column() == 0) { // only the first column
+            auto variable = impl->m_Variables.at(index.row());
+            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())) {
diff --git a/gui/include/Common/VisualizationDef.h b/gui/include/Common/VisualizationDef.h
new file mode 100644
index 0000000..34f87f4
--- /dev/null
+++ b/gui/include/Common/VisualizationDef.h
@@ -0,0 +1,7 @@
+#ifndef SCIQLOP_VISUALIZATIONDEF_H
+#define SCIQLOP_VISUALIZATIONDEF_H
+
+/// Minimum height for graph added in zones (in pixels)
+extern const int GRAPH_MINIMUM_HEIGHT;
+
+#endif // SCIQLOP_VISUALIZATIONDEF_H
diff --git a/gui/include/DragDropHelper.h b/gui/include/DragDropHelper.h
index 95a9c45..871b84d 100644
--- a/gui/include/DragDropHelper.h
+++ b/gui/include/DragDropHelper.h
@@ -2,39 +2,23 @@
 #define SCIQLOP_DRAGDROPHELPER_H
 
 #include <Common/spimpl.h>
+#include <QLoggingCategory>
 #include <QWidget>
 
 class QVBoxLayout;
 class QScrollArea;
 class VisualizationDragWidget;
+class VisualizationDragDropContainer;
 class QMimeData;
 
-/**
- * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
- * @note A QScrollArea inside an other QScrollArea is not fully supported.
- */
-class DragDropScroller : public QObject {
-    Q_OBJECT
-
-public:
-    DragDropScroller(QObject *parent = nullptr);
-
-    void addScrollArea(QScrollArea *scrollArea);
-    void removeScrollArea(QScrollArea *scrollArea);
-
-protected:
-    bool eventFilter(QObject *obj, QEvent *event);
-
-private:
-    class DragDropScrollerPrivate;
-    spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
-
-private slots:
-    void onTimer();
-};
+Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
 
 /**
  * @brief Helper class for drag&drop operations.
+ * @note The helper is accessible from the sqpApp singleton and  has the same life as the whole
+ * application (like a controller). But contrary to a controller, it doesn't live in a thread and
+ * can interect with the gui.
+ * @see SqpApplication
  */
 class DragDropHelper {
 public:
@@ -44,7 +28,15 @@ public:
     DragDropHelper();
     virtual ~DragDropHelper();
 
+    /// Resets some internal variables. Must be called before any new drag&drop operation.
+    void resetDragAndDrop();
+
+    /// Sets the visualization widget currently being drag on the visualization.
     void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
+
+    /// Returns the visualization widget currently being drag on the visualization.
+    /// Can be null if a new visualization widget is intended to be created by the drag&drop
+    /// operation.
     VisualizationDragWidget *getCurrentDragWidget() const;
 
     QWidget &placeHolder() const;
@@ -52,6 +44,10 @@ public:
     void removePlaceHolder();
     bool isPlaceHolderSet() const;
 
+    /// Checks if the specified mime data is valid for a drop in the visualization
+    bool checkMimeDataForVisualization(const QMimeData *mimeData,
+                                       VisualizationDragDropContainer *dropContainer);
+
     void addDragDropScrollArea(QScrollArea *scrollArea);
     void removeDragDropScrollArea(QScrollArea *scrollArea);
 
@@ -62,4 +58,28 @@ private:
     spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
 };
 
+/**
+ * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
+ * @note A QScrollArea inside an other QScrollArea is not fully supported.
+ */
+class DragDropScroller : public QObject {
+    Q_OBJECT
+
+public:
+    DragDropScroller(QObject *parent = nullptr);
+
+    void addScrollArea(QScrollArea *scrollArea);
+    void removeScrollArea(QScrollArea *scrollArea);
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *event);
+
+private:
+    class DragDropScrollerPrivate;
+    spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
+
+private slots:
+    void onTimer();
+};
+
 #endif // SCIQLOP_DRAGDROPHELPER_H
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index 1027e29..c03124a 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -45,7 +45,8 @@ public:
     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:
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
index d8460de..6abfbc3 100644
--- a/gui/include/Visualization/VisualizationDragDropContainer.h
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -2,10 +2,15 @@
 #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 {
@@ -15,6 +20,8 @@ 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);
@@ -25,6 +32,8 @@ public:
 
     int countDragWidget() const;
 
+    void setAcceptMimeDataFunction(AcceptMimeDataFunction fun);
+
 protected:
     void dragEnterEvent(QDragEnterEvent *event);
     void dragLeaveEvent(QDragLeaveEvent *event);
diff --git a/gui/src/Common/VisualizationDef.cpp b/gui/src/Common/VisualizationDef.cpp
new file mode 100644
index 0000000..fd2acf3
--- /dev/null
+++ b/gui/src/Common/VisualizationDef.cpp
@@ -0,0 +1,3 @@
+#include "Common/VisualizationDef.h"
+
+const int GRAPH_MINIMUM_HEIGHT = 300;
diff --git a/gui/src/DragDropHelper.cpp b/gui/src/DragDropHelper.cpp
index 9db14fe..7e91e83 100644
--- a/gui/src/DragDropHelper.cpp
+++ b/gui/src/DragDropHelper.cpp
@@ -1,6 +1,14 @@
 #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>
@@ -10,12 +18,11 @@
 #include <QTimer>
 #include <QVBoxLayout>
 
-const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
-const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
-
 const int SCROLL_SPEED = 5;
 const int SCROLL_ZONE_SIZE = 50;
 
+Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
+
 struct DragDropScroller::DragDropScrollerPrivate {
 
     QList<QScrollArea *> m_ScrollAreas;
@@ -159,7 +166,11 @@ struct DragDropHelper::DragDropHelperPrivate {
             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(0, GRAPH_MINIMUM_HEIGHT);
+            m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         }
     }
 };
@@ -174,6 +185,11 @@ DragDropHelper::~DragDropHelper()
     QFile::remove(impl->m_ImageTempUrl);
 }
 
+void DragDropHelper::resetDragAndDrop()
+{
+    setCurrentDragWidget(nullptr);
+}
+
 void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
 {
     impl->m_CurrentDragWidget = dragWidget;
@@ -228,3 +244,46 @@ 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;
+}
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index 038bcdb..138fe12 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -12,6 +12,7 @@
 #include <QStyledItemDelegate>
 #include <QWidgetAction>
 
+#include <DragDropHelper.h>
 #include <SqpApplication.h>
 
 Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
@@ -151,6 +152,11 @@ VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
     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()
diff --git a/gui/src/Visualization/VisualizationDragDropContainer.cpp b/gui/src/Visualization/VisualizationDragDropContainer.cpp
index e128e8d..e957a28 100644
--- a/gui/src/Visualization/VisualizationDragDropContainer.cpp
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -3,6 +3,8 @@
 #include "SqpApplication.h"
 #include "Visualization/VisualizationDragWidget.h"
 
+#include "Common/VisualizationDef.h"
+
 #include <QDrag>
 #include <QDragEnterEvent>
 #include <QVBoxLayout>
@@ -10,11 +12,15 @@
 #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)
     {
@@ -25,7 +31,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
     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;
             }
         }
@@ -121,10 +127,17 @@ int VisualizationDragDropContainer::countDragWidget() const
     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};
@@ -149,10 +162,15 @@ void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidg
             helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
             dragWidget->setVisible(false);
         }
-    }
 
-    // Note: The exec() is blocking on windows but not on linux and macOS
-    drag->exec(Qt::MoveAction | Qt::CopyAction);
+        // Note: The exec() is blocking on windows but not on linux and macOS
+        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)
@@ -164,20 +182,30 @@ void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
 
         if (!impl->hasPlaceHolder()) {
             auto dragWidget = helper.getCurrentDragWidget();
-            auto parentWidget
-                = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
-            if (parentWidget) {
-                dragWidget->setVisible(false);
+
+            if (dragWidget) {
+                // If the drag&drop is internal to the visualization, entering the container hide
+                // 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) {
-                    hoveredWidgetIndex
-                        += 1; // Correction of the index if the drop occurs in the same container
+
+                if (dragWidget) {
+                    auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                    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);
@@ -186,6 +214,9 @@ void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
                 helper.insertPlaceHolder(impl->m_Layout, 0);
             }
         }
+        else {
+            // do nothing
+        }
     }
     else {
         event->ignore();
@@ -203,19 +234,23 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
     if (!impl->cursorIsInContainer(this)) {
         helper.removePlaceHolder();
 
-        bool isInternal = true;
-        if (isInternal) {
-            // Only if the drag is started from the visualization
-            // Show the drag widget at its original place
+        auto dragWidget = helper.getCurrentDragWidget();
+        if (dragWidget) {
+            // dragWidget has a value only if the drag is started from the visualization
+            // 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);
 }
@@ -229,7 +264,8 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
 
             auto nbDragWidget = countDragWidget();
             if (nbDragWidget > 0) {
-                auto graphHeight = size().height() / nbDragWidget;
+                auto graphHeight = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
+
                 auto dropIndex = floor(event->pos().y() / graphHeight);
                 auto zoneSize = qMin(graphHeight / 3.0, 150.0);
 
@@ -244,10 +280,15 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
                         dropIndex += 1;
                     }
 
-                    auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
-                    if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
-                        dropIndex += 1; // Correction of the index if the drop occurs in the same
-                                        // container
+                    if (helper.getCurrentDragWidget()) {
+                        auto dragWidgetIndex
+                            = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                        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) {
@@ -261,6 +302,15 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
                     }
                 }
             }
+            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 {
@@ -274,18 +324,22 @@ 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 (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
-                droppedIndex
-                    -= 1; // Correction of the index if the drop occurs in the same container
-            }
+            if (dragWidget) {
+                auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
+                if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
+                    // 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();
 
@@ -293,6 +347,12 @@ void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
 
             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();
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index cc42944..5956f76 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -6,6 +6,7 @@
 #include "Visualization/VisualizationZoneWidget.h"
 #include "ui_VisualizationGraphWidget.h"
 
+#include <Common/MimeTypesDef.h>
 #include <Data/ArrayData.h>
 #include <Data/IDataSeries.h>
 #include <DragDropHelper.h>
@@ -232,7 +233,7 @@ QString VisualizationGraphWidget::name() const
 QMimeData *VisualizationGraphWidget::mimeData() const
 {
     auto mimeData = new QMimeData;
-    mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+    mimeData->setData(MIME_TYPE_GRAPH, QByteArray());
 
     return mimeData;
 }
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 15f61b2..d6b63d6 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -7,6 +7,8 @@
 
 #include "Variable/VariableController.h"
 
+#include "Common/MimeTypesDef.h"
+
 #include "DragDropHelper.h"
 #include "SqpApplication.h"
 
@@ -52,6 +54,11 @@ 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)
@@ -62,9 +69,13 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
     ui->setupUi(this);
 
     ui->dragDropContainer->setAcceptedMimeTypes(
-        {DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
+        {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
@@ -162,58 +173,122 @@ QLayout &VisualizationTabWidget::tabLayout() const noexcept
 
 void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
 {
+    if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
+        impl->dropGraph(index, this);
+    }
+    else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
+        impl->dropZone(index, this);
+    }
+    else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+        auto variables = sqpApp->variableController().variablesForMimeData(
+            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+        impl->dropVariables(variables, index, this);
+    }
+    else {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
+    }
+}
+
+void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
+    int index, VisualizationTabWidget *tabWidget)
+{
     auto &helper = sqpApp->dragDropHelper();
-    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
-        auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
-        auto parentDragDropContainer
-            = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
-        Q_ASSERT(parentDragDropContainer);
-
-        auto nbGraph = parentDragDropContainer->countDragWidget();
-
-        const auto &variables = graphWidget->variables();
-
-        if (!variables.isEmpty()) {
-            // Abort the requests for the variables (if any)
-            // Commented, because it's not sure if it's needed or not
-            // for (const auto& var : variables)
-            //{
-            //    sqpApp->variableController().onAbortProgressRequested(var);
-            //}
-
-            if (nbGraph == 1) {
-                // This is the only graph in the previous zone, close the zone
-                graphWidget->parentZoneWidget()->close();
-            }
-            else {
-                // Close the graph
-                graphWidget->close();
-            }
 
-            createZone(variables, index);
+    auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+    if (!graphWidget) {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
+                  "found or invalid.");
+        Q_ASSERT(false);
+        return;
+    }
+
+    auto parentDragDropContainer
+        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+    if (!parentDragDropContainer) {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
+                  "the dropped graph is not found.");
+        Q_ASSERT(false);
+        return;
+    }
+
+    auto nbGraph = parentDragDropContainer->countDragWidget();
+
+    const auto &variables = graphWidget->variables();
+
+    if (!variables.isEmpty()) {
+        // Abort the requests for the variables (if any)
+        // Commented, because it's not sure if it's needed or not
+        // for (const auto& var : variables)
+        //{
+        //    sqpApp->variableController().onAbortProgressRequested(var);
+        //}
+
+        if (nbGraph == 1) {
+            // This is the only graph in the previous zone, close the zone
+            graphWidget->parentZoneWidget()->close();
         }
         else {
-            // 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);
-            zoneWidget->addGraph(graphWidget);
+        parentDragDropContainer->layout()->removeWidget(graphWidget);
 
-            // Close the old zone if it was the only graph inside
-            if (nbGraph == 1) {
-                parentZoneWidget->close();
-            }
+        auto zoneWidget = tabWidget->createEmptyZone(index);
+        zoneWidget->addGraph(graphWidget);
+
+        // Close the old zone if it was the only graph inside
+        if (nbGraph == 1) {
+            parentZoneWidget->close();
         }
     }
-    else if (mimeData->hasFormat(DragDropHelper::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);
 }
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 45355c5..ec39bdd 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -3,12 +3,18 @@
 #include "Visualization/IVisualizationWidgetVisitor.h"
 #include "Visualization/QCustomPlotSynchronizer.h"
 #include "Visualization/VisualizationGraphWidget.h"
+#include "Visualization/VisualizationWidget.h"
 #include "ui_VisualizationZoneWidget.h"
 
+#include "Common/MimeTypesDef.h"
+#include "Common/VisualizationDef.h"
+
 #include <Data/SqpRange.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
+#include <Visualization/operations/FindVariableOperation.h>
+
 #include <DragDropHelper.h>
 #include <QUuid>
 #include <SqpApplication.h>
@@ -20,8 +26,6 @@ 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
@@ -66,6 +70,10 @@ struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
     }
     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)
@@ -77,7 +85,11 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
 
     ui->zoneNameLabel->setText(name);
 
-    ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::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);
 
@@ -315,7 +327,7 @@ QString VisualizationZoneWidget::name() const
 QMimeData *VisualizationZoneWidget::mimeData() const
 {
     auto mimeData = new QMimeData;
-    mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
+    mimeData->setData(MIME_TYPE_ZONE, QByteArray());
 
     return mimeData;
 }
@@ -354,57 +366,119 @@ void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variabl
 
 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
 {
+    if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
+        impl->dropGraph(index, this);
+    }
+    else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+        auto variables = sqpApp->variableController().variablesForMimeData(
+            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+        impl->dropVariables(variables, index, this);
+    }
+    else {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
+    }
+}
+
+void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
+    int index, VisualizationZoneWidget *zoneWidget)
+{
     auto &helper = sqpApp->dragDropHelper();
-    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
-        auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
-        auto parentDragDropContainer
-            = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
-        Q_ASSERT(parentDragDropContainer);
-
-        const auto &variables = graphWidget->variables();
-
-        if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
-            // The drop didn't occur in the same zone
-
-            // Abort the requests for the variables (if any)
-            // Commented, because it's not sure if it's needed or not
-            // for (const auto& var : variables)
-            //{
-            //    sqpApp->variableController().onAbortProgressRequested(var);
-            //}
-
-            auto previousParentZoneWidget = graphWidget->parentZoneWidget();
-            auto nbGraph = parentDragDropContainer->countDragWidget();
-            if (nbGraph == 1) {
-                // This is the only graph in the previous zone, close the zone
-                previousParentZoneWidget->close();
-            }
-            else {
-                // Close the graph
-                graphWidget->close();
-            }
 
-            // Creates the new graph in the zone
-            createGraph(variables, index);
+    auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+    if (!graphWidget) {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
+                  "found or invalid.");
+        Q_ASSERT(false);
+        return;
+    }
+
+    auto parentDragDropContainer
+        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+    if (!parentDragDropContainer) {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
+                  "the dropped graph is not found.");
+        Q_ASSERT(false);
+        return;
+    }
+
+    const auto &variables = graphWidget->variables();
+
+    if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
+        // The drop didn't occur in the same zone
+
+        // Abort the requests for the variables (if any)
+        // Commented, because it's not sure if it's needed or not
+        // for (const auto& var : variables)
+        //{
+        //    sqpApp->variableController().onAbortProgressRequested(var);
+        //}
+
+        auto previousParentZoneWidget = graphWidget->parentZoneWidget();
+        auto nbGraph = parentDragDropContainer->countDragWidget();
+        if (nbGraph == 1) {
+            // This is the only graph in the previous zone, close the zone
+            previousParentZoneWidget->close();
         }
         else {
-            // The drop occurred in the same zone or the graph is empty
-            // Simple move of the graph, no variable operation associated
-            parentDragDropContainer->layout()->removeWidget(graphWidget);
-
-            if (variables.isEmpty() && parentDragDropContainer != 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 = ui->dragDropContainer->layout();
-                if (layout->count() > 0) {
-                    if (auto visualizationGraphWidget
-                        = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
-                        graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
-                    }
+            // Close the graph
+            graphWidget->close();
+        }
+
+        // Creates the new graph in the zone
+        zoneWidget->createGraph(variables, index);
+    }
+    else {
+        // The drop occurred in the same zone or the graph is empty
+        // Simple move of the graph, no variable operation associated
+        parentDragDropContainer->layout()->removeWidget(graphWidget);
+
+        if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
+            // The graph is empty and dropped in a different zone.
+            // Take the range of the first graph in the zone (if existing).
+            auto layout = zoneWidget->ui->dragDropContainer->layout();
+            if (layout->count() > 0) {
+                if (auto visualizationGraphWidget
+                    = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                    graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                 }
             }
+        }
+
+        zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
+    }
+}
+
+void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
+    const QList<std::shared_ptr<Variable> > &variables, int index,
+    VisualizationZoneWidget *zoneWidget)
+{
+    // Search for the top level VisualizationWidget
+    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;
         }
     }
 }