diff --git a/gui/include/TimeWidget/TimeWidget.h b/gui/include/TimeWidget/TimeWidget.h
index 561d5f2..379c0a9 100644
--- a/gui/include/TimeWidget/TimeWidget.h
+++ b/gui/include/TimeWidget/TimeWidget.h
@@ -5,6 +5,8 @@
 
 #include <Data/SqpRange.h>
 
+#include <Common/spimpl.h>
+
 namespace Ui {
 class TimeWidget;
 } // Ui
@@ -17,6 +19,7 @@ public:
     virtual ~TimeWidget();
 
     void setTimeRange(SqpRange time);
+    SqpRange timeRange() const;
 
 signals:
     /// Signal emitted when the time parameters has beed updated
@@ -31,9 +34,14 @@ protected:
     void dragLeaveEvent(QDragLeaveEvent *event) override;
     void dropEvent(QDropEvent *event) override;
 
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
 
 private:
     Ui::TimeWidget *ui;
+
+    class TimeWidgetPrivate;
+    spimpl::unique_impl_ptr<TimeWidgetPrivate> impl;
 };
 
 #endif // SCIQLOP_ SQPSIDEPANE_H
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
index 1b60794..911c650 100644
--- a/gui/include/Visualization/VisualizationDragDropContainer.h
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -21,6 +21,7 @@ signals:
     void dropOccuredOnWidget(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
 
 public:
+    enum class DropBehavior { Inserted, Merged, InsertedAndMerged };
     using AcceptMimeDataFunction = std::function<bool(const QMimeData *mimeData)>;
 
     VisualizationDragDropContainer(QWidget *parent = nullptr);
@@ -28,8 +29,7 @@ public:
     void addDragWidget(VisualizationDragWidget *dragWidget);
     void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
 
-    void setAcceptedMimeTypes(const QStringList &mimeTypes);
-    void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
+    void addAcceptedMimeType(const QString &mimeType, DropBehavior behavior);
 
     int countDragWidget() const;
 
diff --git a/gui/src/TimeWidget/TimeWidget.cpp b/gui/src/TimeWidget/TimeWidget.cpp
index e5017af..9d095ee 100644
--- a/gui/src/TimeWidget/TimeWidget.cpp
+++ b/gui/src/TimeWidget/TimeWidget.cpp
@@ -4,14 +4,27 @@
 #include <Common/DateUtils.h>
 #include <Common/MimeTypesDef.h>
 
+#include <DragDropHelper.h>
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 
+#include <QDrag>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QMimeData>
 
-TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
+
+struct TimeWidget::TimeWidgetPrivate {
+
+    explicit TimeWidgetPrivate() {}
+
+    QPoint m_DragStartPosition;
+};
+
+TimeWidget::TimeWidget(QWidget *parent)
+        : QWidget{parent},
+          ui{new Ui::TimeWidget},
+          impl{spimpl::make_unique_impl<TimeWidgetPrivate>()}
 {
     ui->setupUi(this);
 
@@ -56,11 +69,15 @@ void TimeWidget::setTimeRange(SqpRange time)
     ui->endDateTimeEdit->setDateTime(endDateTime);
 }
 
-void TimeWidget::onTimeUpdateRequested()
+SqpRange TimeWidget::timeRange() const
 {
-    auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
-                             DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
+    return SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
+                    DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
+}
 
+void TimeWidget::onTimeUpdateRequested()
+{
+    auto dateTime = timeRange();
     emit timeUpdated(std::move(dateTime));
 }
 
@@ -94,3 +111,46 @@ void TimeWidget::dropEvent(QDropEvent *event)
 
     setStyleSheet(QString());
 }
+
+
+void TimeWidget::mousePressEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton) {
+        impl->m_DragStartPosition = event->pos();
+    }
+
+    QWidget::mousePressEvent(event);
+}
+
+void TimeWidget::mouseMoveEvent(QMouseEvent *event)
+{
+    if (!(event->buttons() & Qt::LeftButton)) {
+        return;
+    }
+
+    if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
+        < QApplication::startDragDistance()) {
+        return;
+    }
+
+    // Note: The management of the drag object is done by Qt
+    auto drag = new QDrag{this};
+
+    auto mimeData = new QMimeData;
+    auto timeData = TimeController::mimeDataForTimeRange(timeRange());
+    mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
+
+    drag->setMimeData(mimeData);
+
+    auto pixmap = QPixmap(size());
+    render(&pixmap);
+    drag->setPixmap(pixmap);
+    drag->setHotSpot(impl->m_DragStartPosition);
+
+    sqpApp->dragDropHelper().resetDragAndDrop();
+
+    // Note: The exec() is blocking on windows but not on linux and macOS
+    drag->exec(Qt::MoveAction | Qt::CopyAction);
+
+    QWidget::mouseMoveEvent(event);
+}
diff --git a/gui/src/Visualization/VisualizationDragDropContainer.cpp b/gui/src/Visualization/VisualizationDragDropContainer.cpp
index 25e8deb..3687b53 100644
--- a/gui/src/Visualization/VisualizationDragDropContainer.cpp
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -17,10 +17,11 @@ Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropCon
 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     QVBoxLayout *m_Layout;
-    QStringList m_AcceptedMimeTypes;
-    QStringList m_MergeAllowedMimeTypes;
+    QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
+
     VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
         = [](auto mimeData) { return true; };
+
     int m_MinContainerHeight = 0;
 
     explicit VisualizationDragDropContainerPrivate(QWidget *widget)
@@ -31,7 +32,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     bool acceptMimeData(const QMimeData *data) const
     {
-        for (const auto &type : m_AcceptedMimeTypes) {
+        for (const auto &type : m_AcceptedMimeTypes.keys()) {
             if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                 return true;
             }
@@ -40,10 +41,38 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
         return false;
     }
 
-    bool allowMergeMimeData(const QMimeData *data) const
+    bool allowMergeForMimeData(const QMimeData *data) const
     {
-        for (const auto &type : m_MergeAllowedMimeTypes) {
-            if (data->hasFormat(type)) {
+        bool result = false;
+        for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+             ++it) {
+
+            if (data->hasFormat(it.key())
+                && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
+                    || it.value()
+                           == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
+                result = true;
+            }
+            else if (data->hasFormat(it.key())
+                     && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
+                // Merge is forbidden if the mime data contain an acceptable type which cannot be
+                // merged
+                result = false;
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    bool allowInsertForMimeData(const QMimeData *data) const
+    {
+        for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+             ++it) {
+            if (data->hasFormat(it.key())
+                && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
+                    || it.value()
+                           == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                 return true;
             }
         }
@@ -90,7 +119,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
         return nbGraph;
     }
 
-    void findPlaceHolderPosition(const QPoint &pos, bool canMerge,
+    void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
                                  const VisualizationDragDropContainer *container);
 };
 
@@ -118,14 +147,10 @@ void VisualizationDragDropContainer::insertDragWidget(int index,
             &VisualizationDragDropContainer::startDrag);
 }
 
-void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
-{
-    impl->m_AcceptedMimeTypes = mimeTypes;
-}
-
-void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
+void VisualizationDragDropContainer::addAcceptedMimeType(
+    const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
 {
-    impl->m_MergeAllowedMimeTypes = mimeTypes;
+    impl->m_AcceptedMimeTypes[mimeType] = behavior;
 }
 
 int VisualizationDragDropContainer::countDragWidget() const
@@ -203,8 +228,9 @@ void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
                 }
             }
 
-            auto canMerge = impl->allowMergeMimeData(event->mimeData());
-            impl->findPlaceHolderPosition(event->pos(), canMerge, this);
+            auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+            auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+            impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
         }
         else {
             // do nothing
@@ -252,8 +278,9 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
 {
     if (impl->acceptMimeData(event->mimeData())) {
-        auto canMerge = impl->allowMergeMimeData(event->mimeData());
-        impl->findPlaceHolderPosition(event->pos(), canMerge, this);
+        auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+        impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
     }
     else {
         event->ignore();
@@ -271,30 +298,39 @@ void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
         if (impl->hasPlaceHolder()) {
             // drop where the placeHolder is located
 
-            auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
+            auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+            if (canInsert) {
+                auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
 
-            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;
-                }
+                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();
+                event->acceptProposedAction();
 
-            helper.removePlaceHolder();
+                helper.removePlaceHolder();
 
-            emit dropOccuredInContainer(droppedIndex, event->mimeData());
+                emit dropOccuredInContainer(droppedIndex, event->mimeData());
+            }
+            else {
+                qCWarning(LOG_VisualizationDragDropContainer()) << tr(
+                    "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
+                    "the insertion is forbidden.");
+                Q_ASSERT(false);
+            }
         }
         else if (helper.getHightlightedDragWidget()) {
             // drop on the highlighted widget
 
-            auto canMerge = impl->allowMergeMimeData(event->mimeData());
+            auto canMerge = impl->allowMergeForMimeData(event->mimeData());
             if (canMerge) {
                 event->acceptProposedAction();
                 emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
@@ -319,7 +355,8 @@ void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
 
 
 void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
-    const QPoint &pos, bool canMerge, const VisualizationDragDropContainer *container)
+    const QPoint &pos, bool canInsert, bool canMerge,
+    const VisualizationDragDropContainer *container)
 {
     auto &helper = sqpApp->dragDropHelper();
 
@@ -345,7 +382,7 @@ void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
 
             auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
 
-            if (isOnTop || isOnBottom || !canMerge) {
+            if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
                 if (isOnBottom) {
                     dropIndex += 1;
                 }
@@ -374,14 +411,20 @@ void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
 
                 helper.setHightlightedDragWidget(dragWidgetHovered);
             }
+            else {
+                qCWarning(LOG_VisualizationDragDropContainer())
+                    << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
+                          "action.");
+                Q_ASSERT(false);
+            }
         }
         else {
-            qCWarning(LOG_VisualizationDragDropContainer())
-                << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
-                      "container");
+            qCWarning(LOG_VisualizationDragDropContainer()) << tr(
+                "VisualizationDragDropContainer::findPlaceHolderPosition, no widget found in the "
+                "container");
         }
     }
-    else if (!hasPlaceHolder()) {
+    else if (!hasPlaceHolder() && canInsert) {
         // Drop on an empty container, just add the placeHolder at the top
         helper.insertPlaceHolder(m_Layout, 0);
     }
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 2856324..dce0bcc 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -68,14 +68,21 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
 {
     ui->setupUi(this);
 
-    ui->dragDropContainer->setAcceptedMimeTypes(
-        {MIME_TYPE_GRAPH, MIME_TYPE_ZONE, MIME_TYPE_VARIABLE_LIST});
-    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
-            &VisualizationTabWidget::dropMimeData);
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
+
     ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
         return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                       ui->dragDropContainer);
     });
+
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
+            &VisualizationTabWidget::dropMimeData);
+
     sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
 
     // Widget is deleted when closed
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 01fef79..07f14c3 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -101,8 +101,12 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
 
     ui->zoneNameLabel->setText(name);
 
-    ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
-    ui->dragDropContainer->setMergeAllowedMimeTypes({MIME_TYPE_VARIABLE_LIST});
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
+    ui->dragDropContainer->addAcceptedMimeType(
+        MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
     ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
         return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                       ui->dragDropContainer);
@@ -343,11 +347,6 @@ QMimeData *VisualizationZoneWidget::mimeData() const
     auto mimeData = new QMimeData;
     mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
 
-    if (const auto firstGraph = impl->firstGraph(this)) {
-        auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
-        mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
-    }
-
     return mimeData;
 }
 
@@ -418,6 +417,10 @@ void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragW
             graphWidget->addVariable(var, graphWidget->graphRange());
         }
     }
+    else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
+        auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
+        graphWidget->setGraphRange(range);
+    }
     else {
         qCWarning(LOG_VisualizationZoneWidget())
             << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");