diff --git a/gui/include/DragDropHelper.h b/gui/include/DragDropHelper.h
new file mode 100644
index 0000000..95a9c45
--- /dev/null
+++ b/gui/include/DragDropHelper.h
@@ -0,0 +1,65 @@
+#ifndef SCIQLOP_DRAGDROPHELPER_H
+#define SCIQLOP_DRAGDROPHELPER_H
+
+#include <Common/spimpl.h>
+#include <QWidget>
+
+class QVBoxLayout;
+class QScrollArea;
+class VisualizationDragWidget;
+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();
+};
+
+/**
+ * @brief Helper class for drag&drop operations.
+ */
+class DragDropHelper {
+public:
+    static const QString MIME_TYPE_GRAPH;
+    static const QString MIME_TYPE_ZONE;
+
+    DragDropHelper();
+    virtual ~DragDropHelper();
+
+    void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
+    VisualizationDragWidget *getCurrentDragWidget() const;
+
+    QWidget &placeHolder() const;
+    void insertPlaceHolder(QVBoxLayout *layout, int index);
+    void removePlaceHolder();
+    bool isPlaceHolderSet() const;
+
+    void addDragDropScrollArea(QScrollArea *scrollArea);
+    void removeDragDropScrollArea(QScrollArea *scrollArea);
+
+    QUrl imageTemporaryUrl(const QImage &image) const;
+
+private:
+    class DragDropHelperPrivate;
+    spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
+};
+
+#endif // SCIQLOP_DRAGDROPHELPER_H
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index a23bd7f..1027e29 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -20,6 +20,7 @@ class NetworkController;
 class TimeController;
 class VariableController;
 class VisualizationController;
+class DragDropHelper;
 
 /**
  * @brief The SqpApplication class aims to make the link between SciQlop
@@ -44,6 +45,9 @@ public:
     VariableController &variableController() noexcept;
     VisualizationController &visualizationController() noexcept;
 
+    /// Accessors for the differents sciqlop helpers
+    DragDropHelper &dragDropHelper() noexcept;
+
 private:
     class SqpApplicationPrivate;
     spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
new file mode 100644
index 0000000..d8460de
--- /dev/null
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -0,0 +1,42 @@
+#ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
+#define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
+
+#include <Common/spimpl.h>
+#include <QMimeData>
+#include <QVBoxLayout>
+#include <QWidget>
+
+class VisualizationDragWidget;
+
+class VisualizationDragDropContainer : public QWidget {
+    Q_OBJECT
+
+signals:
+    void dropOccured(int dropIndex, const QMimeData *mimeData);
+
+public:
+    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;
+
+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
diff --git a/gui/include/Visualization/VisualizationDragWidget.h b/gui/include/Visualization/VisualizationDragWidget.h
new file mode 100644
index 0000000..3552cef
--- /dev/null
+++ b/gui/include/Visualization/VisualizationDragWidget.h
@@ -0,0 +1,29 @@
+#ifndef SCIQLOP_VISUALIZATIONDRAGWIDGET_H
+#define SCIQLOP_VISUALIZATIONDRAGWIDGET_H
+
+#include <Common/spimpl.h>
+#include <QMimeData>
+#include <QWidget>
+
+class VisualizationDragWidget : public QWidget {
+    Q_OBJECT
+
+public:
+    VisualizationDragWidget(QWidget *parent = nullptr);
+
+    virtual QMimeData *mimeData() const = 0;
+    virtual bool isDragAllowed() const = 0;
+
+protected:
+    virtual void mousePressEvent(QMouseEvent *event) override;
+    virtual void mouseMoveEvent(QMouseEvent *event) override;
+
+private:
+    class VisualizationDragWidgetPrivate;
+    spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
+
+signals:
+    void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
+};
+
+#endif // SCIQLOP_VISUALIZATIONDRAGWIDGET_H
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 98a1c1d..b0e85c7 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -2,6 +2,7 @@
 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
 
 #include "Visualization/IVisualizationWidget.h"
+#include "Visualization/VisualizationDragWidget.h"
 
 #include <QLoggingCategory>
 #include <QWidget>
@@ -16,12 +17,13 @@ class QCPRange;
 class QCustomPlot;
 class SqpRange;
 class Variable;
+class VisualizationZoneWidget;
 
 namespace Ui {
 class VisualizationGraphWidget;
 } // namespace Ui
 
-class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
+class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
     Q_OBJECT
 
     friend class QCustomPlotSynchronizer;
@@ -31,6 +33,8 @@ public:
     explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
     virtual ~VisualizationGraphWidget();
 
+    VisualizationZoneWidget *parentZoneWidget() const noexcept;
+
     /// If acquisition isn't enable, requestDataLoading signal cannot be emit
     void enableAcquisition(bool enable);
 
@@ -39,6 +43,9 @@ public:
     /// Removes a variable from the graph
     void removeVariable(std::shared_ptr<Variable> variable) noexcept;
 
+    /// Returns the list of all variables used in the graph
+    QList<std::shared_ptr<Variable> > variables() const;
+
     void setYRange(const SqpRange &range);
     SqpRange graphRange() const noexcept;
     void setGraphRange(const SqpRange &range);
@@ -49,6 +56,9 @@ public:
     bool contains(const Variable &variable) const override;
     QString name() const override;
 
+    // VisualisationDragWidget
+    QMimeData *mimeData() const override;
+    bool isDragAllowed() const override;
 
 signals:
     void synchronize(const SqpRange &range, const SqpRange &oldRange);
diff --git a/gui/include/Visualization/VisualizationTabWidget.h b/gui/include/Visualization/VisualizationTabWidget.h
index c3623e2..4df7113 100644
--- a/gui/include/Visualization/VisualizationTabWidget.h
+++ b/gui/include/Visualization/VisualizationTabWidget.h
@@ -6,6 +6,7 @@
 #include <Common/spimpl.h>
 
 #include <QLoggingCategory>
+#include <QMimeData>
 #include <QWidget>
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
@@ -27,14 +28,33 @@ public:
     /// Add a zone widget
     void addZone(VisualizationZoneWidget *zoneWidget);
 
+    void insertZone(int index, VisualizationZoneWidget *zoneWidget);
+
     /**
      * Creates a zone using a variable. The variable will be displayed in a new graph of the new
-     * zone.
+     * zone. The zone is added at the end.
      * @param variable the variable for which to create the zone
      * @return the pointer to the created zone
      */
     VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
 
+    /**
+     * Creates a zone using a list of variables. The variables will be displayed in a new graph of
+     * the new zone. The zone is inserted at the specified index.
+     * @param variables the variables for which to create the zone
+     * @param index The index where the zone should be inserted in the layout
+     * @return the pointer to the created zone
+     */
+    VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
+                                        int index);
+
+    /**
+     * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
+     * @param index The index where the zone should be inserted in the layout
+     * @return the pointer to the created zone
+     */
+    VisualizationZoneWidget *createEmptyZone(int index);
+
     // IVisualizationWidget interface
     void accept(IVisualizationWidgetVisitor *visitor) override;
     bool canDrop(const Variable &variable) const override;
@@ -52,6 +72,9 @@ private:
 
     class VisualizationTabWidgetPrivate;
     spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
+
+private slots:
+    void dropMimeData(int index, const QMimeData *mimeData);
 };
 
 #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H
diff --git a/gui/include/Visualization/VisualizationZoneWidget.h b/gui/include/Visualization/VisualizationZoneWidget.h
index 02aa6ba..3700489 100644
--- a/gui/include/Visualization/VisualizationZoneWidget.h
+++ b/gui/include/Visualization/VisualizationZoneWidget.h
@@ -2,6 +2,7 @@
 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
 
 #include "Visualization/IVisualizationWidget.h"
+#include "Visualization/VisualizationDragWidget.h"
 
 #include <QLoggingCategory>
 #include <QWidget>
@@ -14,34 +15,61 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
 
 namespace Ui {
 class VisualizationZoneWidget;
-} // Ui
+} // namespace Ui
 
 class Variable;
 class VisualizationGraphWidget;
 
-class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
+class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
     Q_OBJECT
 
 public:
     explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
     virtual ~VisualizationZoneWidget();
 
-    /// Add a graph widget
+    /// Adds a graph widget
     void addGraph(VisualizationGraphWidget *graphWidget);
 
+    /// Inserts a graph widget
+    void insertGraph(int index, VisualizationGraphWidget *graphWidget);
+
     /**
      * Creates a graph using a variable. The variable will be displayed in the new graph.
+     * The graph is added at the end.
      * @param variable the variable for which to create the graph
      * @return the pointer to the created graph
      */
     VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
 
+    /**
+     * Creates a graph using a variable. The variable will be displayed in the new graph.
+     * The graph is inserted at the specified index.
+     * @param variable the variable for which to create the graph
+     * @param index The index where the graph should be inserted in the layout
+     * @return the pointer to the created graph
+     */
+    VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
+
+    /**
+     * Creates a graph using a list of variables. The variables will be displayed in the new graph.
+     * The graph is inserted at the specified index.
+     * @param variables List of variables to be added to the graph
+     * @param index The index where the graph should be inserted in the layout
+     * @return the pointer to the created graph
+     */
+    VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
+                                          int index);
+
     // IVisualizationWidget interface
     void accept(IVisualizationWidgetVisitor *visitor) override;
     bool canDrop(const Variable &variable) const override;
     bool contains(const Variable &variable) const override;
     QString name() const override;
 
+    // VisualisationDragWidget
+    QMimeData *mimeData() const override;
+    bool isDragAllowed() const override;
+
 protected:
     void closeEvent(QCloseEvent *event) override;
 
@@ -55,6 +83,8 @@ private slots:
     void onVariableAdded(std::shared_ptr<Variable> variable);
     /// Slot called when a variable is about to be removed from a graph contained in the zone
     void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
+
+    void dropMimeData(int index, const QMimeData *mimeData);
 };
 
 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
diff --git a/gui/src/DragDropHelper.cpp b/gui/src/DragDropHelper.cpp
new file mode 100644
index 0000000..9db14fe
--- /dev/null
+++ b/gui/src/DragDropHelper.cpp
@@ -0,0 +1,230 @@
+#include "DragDropHelper.h"
+#include "SqpApplication.h"
+#include "Visualization/VisualizationDragWidget.h"
+
+#include <QDir>
+#include <QDragEnterEvent>
+#include <QDragMoveEvent>
+#include <QScrollArea>
+#include <QScrollBar>
+#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;
+
+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);
+        }
+    }
+};
+
+
+DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
+{
+}
+
+DragDropHelper::~DragDropHelper()
+{
+    QFile::remove(impl->m_ImageTempUrl);
+}
+
+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);
+}
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index 4968eb0..09ee43b 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -2,6 +2,7 @@
 
 #include <Data/IDataProvider.h>
 #include <DataSource/DataSourceController.h>
+#include <DragDropHelper.h>
 #include <Network/NetworkController.h>
 #include <QThread>
 #include <Time/TimeController.h>
@@ -18,7 +19,8 @@ public:
               m_NetworkController{std::make_unique<NetworkController>()},
               m_TimeController{std::make_unique<TimeController>()},
               m_VariableController{std::make_unique<VariableController>()},
-              m_VisualizationController{std::make_unique<VisualizationController>()}
+              m_VisualizationController{std::make_unique<VisualizationController>()},
+              m_DragDropHelper{std::make_unique<DragDropHelper>()}
     {
         // /////////////////////////////// //
         // Connections between controllers //
@@ -82,6 +84,8 @@ public:
     QThread m_NetworkControllerThread;
     QThread m_VariableControllerThread;
     QThread m_VisualizationControllerThread;
+
+    std::unique_ptr<DragDropHelper> m_DragDropHelper;
 };
 
 
@@ -148,3 +152,8 @@ VisualizationController &SqpApplication::visualizationController() noexcept
 {
     return *impl->m_VisualizationController;
 }
+
+DragDropHelper &SqpApplication::dragDropHelper() noexcept
+{
+    return *impl->m_DragDropHelper;
+}
diff --git a/gui/src/Visualization/VisualizationDragDropContainer.cpp b/gui/src/Visualization/VisualizationDragDropContainer.cpp
new file mode 100644
index 0000000..e128e8d
--- /dev/null
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -0,0 +1,302 @@
+#include "Visualization/VisualizationDragDropContainer.h"
+#include "DragDropHelper.h"
+#include "SqpApplication.h"
+#include "Visualization/VisualizationDragWidget.h"
+
+#include <QDrag>
+#include <QDragEnterEvent>
+#include <QVBoxLayout>
+
+#include <cmath>
+#include <memory>
+
+struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
+
+    QVBoxLayout *m_Layout;
+    QStringList m_AcceptedMimeTypes;
+    QStringList m_MergeAllowedMimeTypes;
+
+    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)) {
+                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::startDrag(VisualizationDragWidget *dragWidget,
+                                               const QPoint &dragPosition)
+{
+    auto &helper = sqpApp->dragDropHelper();
+
+    // 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
+    drag->exec(Qt::MoveAction | Qt::CopyAction);
+}
+
+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 (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
+                }
+
+                helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
+            }
+            else {
+                helper.insertPlaceHolder(impl->m_Layout, 0);
+            }
+        }
+    }
+    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;
+        if (isInternal) {
+            // Only if the drag is started from the visualization
+            // Show 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);
+            }
+        }
+    }
+
+    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 (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                        dropIndex += 1; // Correction of the index if the drop occurs in the same
+                                        // container
+                    }
+
+                    if (dropIndex != placeHolderIndex) {
+                        helper.insertPlaceHolder(impl->m_Layout, dropIndex);
+                    }
+                }
+                else if (canMerge) {
+                    // drop on the middle -> merge
+                    if (impl->hasPlaceHolder()) {
+                        helper.removePlaceHolder();
+                    }
+                }
+            }
+        }
+    }
+    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) {
+            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
+            }
+
+            dragWidget->setVisible(true);
+
+            event->acceptProposedAction();
+
+            helper.removePlaceHolder();
+
+            emit dropOccured(droppedIndex, event->mimeData());
+        }
+    }
+    else {
+        event->ignore();
+    }
+
+    QWidget::dropEvent(event);
+}
diff --git a/gui/src/Visualization/VisualizationDragWidget.cpp b/gui/src/Visualization/VisualizationDragWidget.cpp
new file mode 100644
index 0000000..57f7074
--- /dev/null
+++ b/gui/src/Visualization/VisualizationDragWidget.cpp
@@ -0,0 +1,53 @@
+#include "Visualization/VisualizationDragWidget.h"
+#include "Visualization/VisualizationDragDropContainer.h"
+
+#include <QApplication>
+#include <QMouseEvent>
+
+struct VisualizationDragWidget::VisualizationDragWidgetPrivate {
+
+    QPoint m_DragStartPosition;
+    bool m_DragStartPositionValid = false;
+
+    explicit VisualizationDragWidgetPrivate() {}
+};
+
+VisualizationDragWidget::VisualizationDragWidget(QWidget *parent)
+        : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
+{
+}
+
+void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton) {
+        impl->m_DragStartPosition = event->pos();
+    }
+
+    impl->m_DragStartPositionValid = isDragAllowed();
+
+    QWidget::mousePressEvent(event);
+}
+
+void VisualizationDragWidget::mouseMoveEvent(QMouseEvent *event)
+{
+    if (!impl->m_DragStartPositionValid || !isDragAllowed()) {
+        return;
+    }
+
+    if (!(event->buttons() & Qt::LeftButton)) {
+        return;
+    }
+
+    if (!event->modifiers().testFlag(Qt::AltModifier)) {
+        return;
+    }
+
+    if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
+        < QApplication::startDragDistance()) {
+        return;
+    }
+
+    emit dragDetected(this, impl->m_DragStartPosition);
+
+    QWidget::mouseMoveEvent(event);
+}
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 50d0562..cc42944 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -3,10 +3,12 @@
 #include "Visualization/VisualizationDefs.h"
 #include "Visualization/VisualizationGraphHelper.h"
 #include "Visualization/VisualizationGraphRenderingDelegate.h"
+#include "Visualization/VisualizationZoneWidget.h"
 #include "ui_VisualizationGraphWidget.h"
 
 #include <Data/ArrayData.h>
 #include <Data/IDataSeries.h>
+#include <DragDropHelper.h>
 #include <Settings/SqpSettingsDefs.h>
 #include <SqpApplication.h>
 #include <Variable/Variable.h>
@@ -47,7 +49,7 @@ struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
 };
 
 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
-        : QWidget{parent},
+        : VisualizationDragWidget{parent},
           ui{new Ui::VisualizationGraphWidget},
           impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
 {
@@ -92,6 +94,16 @@ VisualizationGraphWidget::~VisualizationGraphWidget()
     delete ui;
 }
 
+VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
+{
+    auto parent = parentWidget();
+    while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
+        parent = parent->parentWidget();
+    }
+
+    return qobject_cast<VisualizationZoneWidget *>(parent);
+}
+
 void VisualizationGraphWidget::enableAcquisition(bool enable)
 {
     impl->m_DoAcquisition = enable;
@@ -152,6 +164,17 @@ void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable
     ui->widget->replot();
 }
 
+QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
+{
+    auto variables = QList<std::shared_ptr<Variable> >{};
+    for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
+         it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
+        variables << it->first;
+    }
+
+    return variables;
+}
+
 void VisualizationGraphWidget::setYRange(const SqpRange &range)
 {
     ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
@@ -206,6 +229,19 @@ QString VisualizationGraphWidget::name() const
     return impl->m_Name;
 }
 
+QMimeData *VisualizationGraphWidget::mimeData() const
+{
+    auto mimeData = new QMimeData;
+    mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+
+    return mimeData;
+}
+
+bool VisualizationGraphWidget::isDragAllowed() const
+{
+    return true;
+}
+
 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
 {
     Q_UNUSED(event);
@@ -284,6 +320,8 @@ void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
 {
     // Handles plot rendering when mouse is moving
     impl->m_RenderingDelegate->onMouseMove(event);
+
+    VisualizationDragWidget::mouseMoveEvent(event);
 }
 
 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
@@ -307,6 +345,10 @@ void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
 {
     impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
+
+    plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
+
+    VisualizationDragWidget::mousePressEvent(event);
 }
 
 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 84751e9..15f61b2 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -2,8 +2,14 @@
 #include "Visualization/IVisualizationWidgetVisitor.h"
 #include "ui_VisualizationTabWidget.h"
 
+#include "Visualization/VisualizationGraphWidget.h"
 #include "Visualization/VisualizationZoneWidget.h"
 
+#include "Variable/VariableController.h"
+
+#include "DragDropHelper.h"
+#include "SqpApplication.h"
+
 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
 
 namespace {
@@ -55,27 +61,53 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
 {
     ui->setupUi(this);
 
+    ui->dragDropContainer->setAcceptedMimeTypes(
+        {DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+            &VisualizationTabWidget::dropMimeData);
+    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)
 {
-    tabLayout().addWidget(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)
 {
-    auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};
-    this->addZone(zoneWidget);
+    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(variable);
+    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;
 }
@@ -125,5 +157,63 @@ void VisualizationTabWidget::closeEvent(QCloseEvent *event)
 
 QLayout &VisualizationTabWidget::tabLayout() const noexcept
 {
-    return *ui->scrollAreaWidgetContents->layout();
+    return *ui->dragDropContainer->layout();
+}
+
+void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
+{
+    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);
+        }
+        else {
+            // The graph is empty, create an empty zone and move the graph inside
+
+            auto parentZoneWidget = graphWidget->parentZoneWidget();
+
+            parentDragDropContainer->layout()->removeWidget(graphWidget);
+
+            auto zoneWidget = 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);
+    }
 }
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 7d1998a..45355c5 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -9,10 +9,13 @@
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
+#include <DragDropHelper.h>
 #include <QUuid>
 #include <SqpApplication.h>
 #include <cmath>
 
+#include <QLayout>
+
 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
 
 namespace {
@@ -66,7 +69,7 @@ struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
 };
 
 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
-        : QWidget{parent},
+        : VisualizationDragWidget{parent},
           ui{new Ui::VisualizationZoneWidget},
           impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
 {
@@ -74,6 +77,10 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
 
     ui->zoneNameLabel->setText(name);
 
+    ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
+    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);
@@ -94,13 +101,27 @@ void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
     // Synchronize new graph with others in the zone
     impl->m_Synchronizer->addGraph(*graphWidget);
 
-    ui->visualizationZoneFrame->layout()->addWidget(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)
 {
-    auto graphWidget = new VisualizationGraphWidget{
-        defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
+    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
@@ -113,7 +134,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                                                      const SqpRange &oldGraphRange) {
 
         auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
-        auto frameLayout = ui->visualizationZoneFrame->layout();
+        auto frameLayout = ui->dragDropContainer->layout();
         for (auto i = 0; i < frameLayout->count(); ++i) {
             auto graphChild
                 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
@@ -203,7 +224,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     auto range = SqpRange{};
 
     // Apply visitor to graph children
-    auto layout = ui->visualizationZoneFrame->layout();
+    auto layout = ui->dragDropContainer->layout();
     if (layout->count() > 0) {
         // Case of a new graph in a existant zone
         if (auto visualizationGraphWidget
@@ -216,7 +237,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
         range = variable->range();
     }
 
-    this->addGraph(graphWidget);
+    this->insertGraph(index, graphWidget);
 
     graphWidget->addVariable(variable, range);
 
@@ -240,6 +261,21 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     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) {
@@ -248,7 +284,7 @@ void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
         // Apply visitor to graph children: widgets different from graphs are not visited (no
         // action)
         processGraphs(
-            *ui->visualizationZoneFrame->layout(),
+            *ui->dragDropContainer->layout(),
             [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
 
         visitor->visitLeave(this);
@@ -276,10 +312,23 @@ QString VisualizationZoneWidget::name() const
     return ui->zoneNameLabel->text();
 }
 
+QMimeData *VisualizationZoneWidget::mimeData() const
+{
+    auto mimeData = new QMimeData;
+    mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
+
+    return mimeData;
+}
+
+bool VisualizationZoneWidget::isDragAllowed() const
+{
+    return true;
+}
+
 void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
 {
     // Closes graphs in the zone
-    processGraphs(*ui->visualizationZoneFrame->layout(),
+    processGraphs(*ui->dragDropContainer->layout(),
                   [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
 
     // Delete synchronization group from variable controller
@@ -302,3 +351,60 @@ void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variabl
                               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(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);
+        }
+        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());
+                    }
+                }
+            }
+
+            ui->dragDropContainer->insertDragWidget(index, graphWidget);
+        }
+    }
+}
diff --git a/gui/ui/Visualization/VisualizationTabWidget.ui b/gui/ui/Visualization/VisualizationTabWidget.ui
index 60b3e1c..afdd13e 100644
--- a/gui/ui/Visualization/VisualizationTabWidget.ui
+++ b/gui/ui/Visualization/VisualizationTabWidget.ui
@@ -62,12 +62,23 @@
        <property name="bottomMargin">
         <number>0</number>
        </property>
+       <item>
+        <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
+       </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>VisualizationDragDropContainer</class>
+   <extends>QWidget</extends>
+   <header>Visualization/VisualizationDragDropContainer.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/gui/ui/Visualization/VisualizationZoneWidget.ui b/gui/ui/Visualization/VisualizationZoneWidget.ui
index 79d6be0..9746ca6 100644
--- a/gui/ui/Visualization/VisualizationZoneWidget.ui
+++ b/gui/ui/Visualization/VisualizationZoneWidget.ui
@@ -107,11 +107,22 @@
       <property name="bottomMargin">
        <number>0</number>
       </property>
+      <item>
+       <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
+      </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>VisualizationDragDropContainer</class>
+   <extends>QWidget</extends>
+   <header>Visualization/VisualizationDragDropContainer.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>