From 756d7fefd6f4c229929eb3e70c10d7abb2249dce 2017-11-07 10:19:32
From: leroux <aleroux@itlink.fr>
Date: 2017-11-07 10:19:32
Subject: [PATCH] Merge pull request #323 from SciQLop-fork develop

 Develop

---

diff --git a/core/include/DataSource/DataSourceController.h b/core/include/DataSource/DataSourceController.h
index 13e89a2..cbf2d67 100644
--- a/core/include/DataSource/DataSourceController.h
+++ b/core/include/DataSource/DataSourceController.h
@@ -64,8 +64,11 @@ public:
      */
     void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
 
-    QByteArray mimeDataForProductsData(const QVariantList &productsData) const;
-    QVariantList productsDataForMimeData(const QByteArray &mimeData) const;
+    /// Returns the MIME data associated to a list of product meta data
+    static QByteArray mimeDataForProductsData(const QVariantList &productsData);
+
+    /// Returns the list of meta data contained in a MIME data
+    static QVariantList productsDataForMimeData(const QByteArray &mimeData);
 
 public slots:
     /// Manage init/end of the controller
diff --git a/core/include/Time/TimeController.h b/core/include/Time/TimeController.h
index 6f1f1fb..7c38e2c 100644
--- a/core/include/Time/TimeController.h
+++ b/core/include/Time/TimeController.h
@@ -23,6 +23,12 @@ public:
 
     SqpRange dateTime() const noexcept;
 
+    /// Returns the MIME data associated to a time range
+    static QByteArray mimeDataForTimeRange(const SqpRange &timeRange);
+
+    /// Returns the time range contained in a MIME data
+    static SqpRange timeRangeForMimeData(const QByteArray &mimeData);
+
 signals:
     /// Signal emitted to notify that time parameters has beed updated
     void timeUpdated(SqpRange time);
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index b198dcd..984e738 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -68,7 +68,10 @@ public:
      */
     void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
 
+    /// Returns the MIME data associated to a list of variables
     QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;
+
+    /// Returns the list of variables contained in a MIME data
     QList<std::shared_ptr<Variable> > variablesForMimeData(const QByteArray &mimeData) const;
 
     static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
diff --git a/core/meson.build b/core/meson.build
index a275a3b..2256757 100644
--- a/core/meson.build
+++ b/core/meson.build
@@ -3,7 +3,6 @@ core_moc_headers = [
   'include/Data/IDataProvider.h',
   'include/DataSource/DataSourceController.h',
   'include/DataSource/DataSourceItemAction.h',
-  'include/DataSource/DataSourceWidget.h',
   'include/Network/NetworkController.h',
   'include/Time/TimeController.h',
   'include/Variable/Variable.h',
@@ -32,7 +31,6 @@ core_sources = [
   'src/DataSource/DataSourceController.cpp',
   'src/DataSource/DataSourceItem.cpp',
   'src/DataSource/DataSourceItemAction.cpp',
-  'src/DataSource/DataSourceWidget.cpp',
   'src/Network/NetworkController.cpp',
   'src/Plugin/PluginManager.cpp',
   'src/Settings/SqpSettingsDefs.cpp',
diff --git a/core/src/DataSource/DataSourceController.cpp b/core/src/DataSource/DataSourceController.cpp
index 6d42abf..81adfb3 100644
--- a/core/src/DataSource/DataSourceController.cpp
+++ b/core/src/DataSource/DataSourceController.cpp
@@ -139,7 +139,7 @@ void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
     }
 }
 
-QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData) const
+QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData)
 {
     QByteArray encodedData;
     QDataStream stream{&encodedData, QIODevice::WriteOnly};
@@ -149,7 +149,7 @@ QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &pro
     return encodedData;
 }
 
-QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData) const
+QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData)
 {
     QDataStream stream{mimeData};
 
@@ -174,7 +174,7 @@ void DataSourceController::finalize()
 
 void DataSourceController::requestVariable(const QVariantHash &productData)
 {
-    DataSourceItem *sourceItem = impl->findDataSourceItem(productData);
+    auto sourceItem = impl->findDataSourceItem(productData);
 
     if (sourceItem) {
         auto sourceName = sourceItem->rootItem().name();
diff --git a/core/src/DataSource/DataSourceItem.cpp b/core/src/DataSource/DataSourceItem.cpp
index a1fe8e7..35972b7 100644
--- a/core/src/DataSource/DataSourceItem.cpp
+++ b/core/src/DataSource/DataSourceItem.cpp
@@ -131,8 +131,7 @@ DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursiv
         }
 
         if (recursive) {
-            auto foundItem = child->findItem(data, true);
-            if (foundItem) {
+            if (auto foundItem = child->findItem(data, true)) {
                 return foundItem;
             }
         }
diff --git a/core/src/Time/TimeController.cpp b/core/src/Time/TimeController.cpp
index fee9f73..66b9591 100644
--- a/core/src/Time/TimeController.cpp
+++ b/core/src/Time/TimeController.cpp
@@ -1,5 +1,7 @@
 #include "Time/TimeController.h"
 
+#include <QDataStream>
+
 Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
 
 struct TimeController::TimeControllerPrivate {
@@ -18,6 +20,26 @@ SqpRange TimeController::dateTime() const noexcept
     return impl->m_DateTime;
 }
 
+QByteArray TimeController::mimeDataForTimeRange(const SqpRange &timeRange)
+{
+    QByteArray encodedData;
+    QDataStream stream{&encodedData, QIODevice::WriteOnly};
+
+    stream << timeRange.m_TStart << timeRange.m_TEnd;
+
+    return encodedData;
+}
+
+SqpRange TimeController::timeRangeForMimeData(const QByteArray &mimeData)
+{
+    QDataStream stream{mimeData};
+
+    SqpRange timeRange;
+    stream >> timeRange.m_TStart >> timeRange.m_TEnd;
+
+    return timeRange;
+}
+
 void TimeController::onTimeToUpdate(SqpRange dateTime)
 {
     impl->m_DateTime = dateTime;
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index 9ef8378..f85f179 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -8,7 +8,9 @@
 
 #include <Data/IDataSeries.h>
 
-#include <QDataStream>
+#include <DataSource/DataSourceController.h>
+#include <Time/TimeController.h>
+
 #include <QMimeData>
 #include <QSize>
 #include <unordered_map>
@@ -278,7 +280,7 @@ Qt::DropActions VariableModel::supportedDragActions() const
 
 QStringList VariableModel::mimeTypes() const
 {
-    return {MIME_TYPE_VARIABLE_LIST};
+    return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
 }
 
 QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
@@ -287,17 +289,31 @@ QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
 
     QList<std::shared_ptr<Variable> > variableList;
 
+
+    SqpRange firstTimeRange;
     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()) {
+
+                if (variableList.isEmpty()) {
+                    // Gets the range of the first variable
+                    firstTimeRange = std::move(variable->range());
+                }
+
                 variableList << variable;
             }
         }
     }
 
-    auto encodedData = impl->m_VariableController->mimeDataForVariables(variableList);
-    mimeData->setData(MIME_TYPE_VARIABLE_LIST, encodedData);
+    auto variablesEncodedData = impl->m_VariableController->mimeDataForVariables(variableList);
+    mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
+
+    if (variableList.count() == 1) {
+        // No time range MIME data if multiple variables are dragged
+        auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
+        mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
+    }
 
     return mimeData;
 }
@@ -312,13 +328,12 @@ bool VariableModel::canDropMimeData(const QMimeData *data, Qt::DropAction action
 bool VariableModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                  const QModelIndex &parent)
 {
-    bool dropDone = false;
+    auto dropDone = false;
 
     if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
-        QDataStream stream(data->data(MIME_TYPE_PRODUCT_LIST));
 
-        QVariantList productList;
-        stream >> productList;
+        auto productList
+            = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
 
         for (auto metaData : productList) {
             emit requestVariable(metaData.toHash());
diff --git a/core/tests/meson.build b/core/tests/meson.build
index 6847e97..8020245 100644
--- a/core/tests/meson.build
+++ b/core/tests/meson.build
@@ -14,10 +14,18 @@ tests = [
   [['Variable/TestVariableSync.cpp'],'test_variable_sync','Variable synchronization test']
 ]
 
+amdatest_sources = [
+  'Data/DataSeriesBuilders.h',
+  'Data/DataSeriesBuilders.cpp',
+  'Data/DataSeriesUtils.h',
+  'Data/DataSeriesUtils.cpp'
+]
+
 foreach unit_test : tests
   test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
   test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
-                          dependencies : [sciqlop_core, qt5test])
+                          dependencies : [sciqlop_core, qt5test],
+						  sources : [amdatest_sources])
   test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])])
 endforeach
 
diff --git a/gui/include/DataSource/DataSourceTreeWidget.h b/gui/include/DataSource/DataSourceTreeWidget.h
index 08043ba..43141e3 100644
--- a/gui/include/DataSource/DataSourceTreeWidget.h
+++ b/gui/include/DataSource/DataSourceTreeWidget.h
@@ -9,6 +9,7 @@ public:
 
 protected:
     QMimeData *mimeData(const QList<QTreeWidgetItem *> items) const override;
+    void startDrag(Qt::DropActions supportedActions) override;
 };
 
 #endif // SCIQLOP_DATASOURCETREEWIDGET_H
diff --git a/gui/include/DragDropHelper.h b/gui/include/DragAndDrop/DragDropHelper.h
similarity index 78%
rename from gui/include/DragDropHelper.h
rename to gui/include/DragAndDrop/DragDropHelper.h
index 871b84d..c557cb5 100644
--- a/gui/include/DragDropHelper.h
+++ b/gui/include/DragAndDrop/DragDropHelper.h
@@ -7,6 +7,7 @@
 
 class QVBoxLayout;
 class QScrollArea;
+class QTabBar;
 class VisualizationDragWidget;
 class VisualizationDragDropContainer;
 class QMimeData;
@@ -25,6 +26,8 @@ public:
     static const QString MIME_TYPE_GRAPH;
     static const QString MIME_TYPE_ZONE;
 
+    enum class PlaceHolderType { Default, Graph, Zone };
+
     DragDropHelper();
     virtual ~DragDropHelper();
 
@@ -40,7 +43,8 @@ public:
     VisualizationDragWidget *getCurrentDragWidget() const;
 
     QWidget &placeHolder() const;
-    void insertPlaceHolder(QVBoxLayout *layout, int index);
+    void insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+                           const QString &topLabelText);
     void removePlaceHolder();
     bool isPlaceHolderSet() const;
 
@@ -51,35 +55,17 @@ public:
     void addDragDropScrollArea(QScrollArea *scrollArea);
     void removeDragDropScrollArea(QScrollArea *scrollArea);
 
+    void addDragDropTabBar(QTabBar *tabBar);
+    void removeDragDropTabBar(QTabBar *tabBar);
+
     QUrl imageTemporaryUrl(const QImage &image) const;
 
+    void setHightlightedDragWidget(VisualizationDragWidget *dragWidget);
+    VisualizationDragWidget *getHightlightedDragWidget() const;
+
 private:
     class DragDropHelperPrivate;
     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/DragAndDrop/DragDropScroller.h b/gui/include/DragAndDrop/DragDropScroller.h
new file mode 100644
index 0000000..eb84baf
--- /dev/null
+++ b/gui/include/DragAndDrop/DragDropScroller.h
@@ -0,0 +1,32 @@
+#ifndef SCIQLOP_DRAGDROPSCROLLER_H
+#define SCIQLOP_DRAGDROPSCROLLER_H
+
+#include <Common/spimpl.h>
+#include <QScrollArea>
+
+/**
+ * @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_DRAGDROPSCROLLER_H
diff --git a/gui/include/DragAndDrop/DragDropTabSwitcher.h b/gui/include/DragAndDrop/DragDropTabSwitcher.h
new file mode 100644
index 0000000..1665d46
--- /dev/null
+++ b/gui/include/DragAndDrop/DragDropTabSwitcher.h
@@ -0,0 +1,29 @@
+#ifndef SCIQLOP_DRAGDROPTABSWITCHER_H
+#define SCIQLOP_DRAGDROPTABSWITCHER_H
+
+#include <Common/spimpl.h>
+
+#include <QLoggingCategory>
+#include <QTabBar>
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropTabSwitcher)
+
+class DragDropTabSwitcher : public QObject {
+    Q_OBJECT
+
+public:
+    DragDropTabSwitcher(QObject *parent = nullptr);
+
+    void addTabBar(QTabBar *tabBar);
+    void removeTabBar(QTabBar *tabBar);
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *event);
+
+private:
+    class DragDropTabSwitcherPrivate;
+    spimpl::unique_impl_ptr<DragDropTabSwitcherPrivate> impl;
+};
+
+
+#endif // SCIQLOP_DRAGDROPTABSWITCHER_H
diff --git a/gui/include/TimeWidget/TimeWidget.h b/gui/include/TimeWidget/TimeWidget.h
index 575ebd7..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
@@ -16,6 +18,9 @@ public:
     explicit TimeWidget(QWidget *parent = 0);
     virtual ~TimeWidget();
 
+    void setTimeRange(SqpRange time);
+    SqpRange timeRange() const;
+
 signals:
     /// Signal emitted when the time parameters has beed updated
     void timeUpdated(SqpRange time);
@@ -24,9 +29,19 @@ public slots:
     /// slot called when time parameters update has ben requested
     void onTimeUpdateRequested();
 
+protected:
+    void dragEnterEvent(QDragEnterEvent *event) override;
+    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/Variable/VariableInspectorTableView.h b/gui/include/Variable/VariableInspectorTableView.h
new file mode 100644
index 0000000..42bc9f1
--- /dev/null
+++ b/gui/include/Variable/VariableInspectorTableView.h
@@ -0,0 +1,14 @@
+#ifndef SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H
+#define SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H
+
+#include <QTableView>
+
+class VariableInspectorTableView : public QTableView {
+public:
+    VariableInspectorTableView(QWidget *parent = nullptr);
+
+protected:
+    void startDrag(Qt::DropActions supportedActions);
+};
+
+#endif // SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
index 6abfbc3..d100bff 100644
--- a/gui/include/Visualization/VisualizationDragDropContainer.h
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -2,24 +2,28 @@
 #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
 
 #include <Common/spimpl.h>
+#include <QFrame>
 #include <QLoggingCategory>
 #include <QMimeData>
 #include <QVBoxLayout>
-#include <QWidget>
 
 #include <functional>
 
+#include <DragAndDrop/DragDropHelper.h>
+
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
 
 class VisualizationDragWidget;
 
-class VisualizationDragDropContainer : public QWidget {
+class VisualizationDragDropContainer : public QFrame {
     Q_OBJECT
 
 signals:
-    void dropOccured(int dropIndex, const QMimeData *mimeData);
+    void dropOccuredInContainer(int dropIndex, const QMimeData *mimeData);
+    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);
@@ -27,13 +31,15 @@ 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;
 
     void setAcceptMimeDataFunction(AcceptMimeDataFunction fun);
 
+    void setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+                            const QString &placeHolderText = QString());
+
 protected:
     void dragEnterEvent(QDragEnterEvent *event);
     void dragLeaveEvent(QDragLeaveEvent *event);
diff --git a/gui/include/Visualization/VisualizationDragWidget.h b/gui/include/Visualization/VisualizationDragWidget.h
index 3552cef..15924d3 100644
--- a/gui/include/Visualization/VisualizationDragWidget.h
+++ b/gui/include/Visualization/VisualizationDragWidget.h
@@ -13,6 +13,7 @@ public:
 
     virtual QMimeData *mimeData() const = 0;
     virtual bool isDragAllowed() const = 0;
+    virtual void highlightForMerge(bool highlighted) { Q_UNUSED(highlighted); };
 
 protected:
     virtual void mousePressEvent(QMouseEvent *event) override;
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index b0e85c7..a012cb7 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -59,6 +59,7 @@ public:
     // VisualisationDragWidget
     QMimeData *mimeData() const override;
     bool isDragAllowed() const override;
+    void highlightForMerge(bool highlighted) override;
 
 signals:
     void synchronize(const SqpRange &range, const SqpRange &oldRange);
diff --git a/gui/include/Visualization/VisualizationZoneWidget.h b/gui/include/Visualization/VisualizationZoneWidget.h
index 3700489..f364645 100644
--- a/gui/include/Visualization/VisualizationZoneWidget.h
+++ b/gui/include/Visualization/VisualizationZoneWidget.h
@@ -85,6 +85,7 @@ private slots:
     void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
 
     void dropMimeData(int index, const QMimeData *mimeData);
+    void dropMimeDataOnGraph(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
 };
 
 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
diff --git a/gui/meson.build b/gui/meson.build
index c57ee52..6520ba3 100644
--- a/gui/meson.build
+++ b/gui/meson.build
@@ -1,13 +1,17 @@
 
 gui_moc_headers = [
   'include/DataSource/DataSourceWidget.h',
+  'include/DataSource/DataSourceTreeWidget.h',
   'include/Settings/SqpSettingsDialog.h',
   'include/Settings/SqpSettingsGeneralWidget.h',
   'include/SidePane/SqpSidePane.h',
   'include/SqpApplication.h',
-  'include/DragDropHelper.h',
+  'include/DragAndDrop/DragDropHelper.h',
+  'include/DragAndDrop/DragDropScroller.h',
+  'include/DragAndDrop/DragDropTabSwitcher.h',
   'include/TimeWidget/TimeWidget.h',
   'include/Variable/VariableInspectorWidget.h',
+  'include/Variable/VariableInspectorTableView.h',
   'include/Variable/RenameVariableDialog.h',
   'include/Visualization/qcustomplot.h',
   'include/Visualization/VisualizationGraphWidget.h',
@@ -41,17 +45,21 @@ gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
 
 gui_sources = [
   'src/SqpApplication.cpp',
-  'src/DragDropHelper.cpp',
+  'src/DragAndDrop/DragDropHelper.cpp',
+  'src/DragAndDrop/DragDropScroller.cpp',
+  'src/DragAndDrop/DragDropTabSwitcher.cpp',
   'src/Common/ColorUtils.cpp',
   'src/Common/VisualizationDef.cpp',
   'src/DataSource/DataSourceTreeWidgetItem.cpp',
   'src/DataSource/DataSourceTreeWidgetHelper.cpp',
   'src/DataSource/DataSourceWidget.cpp',
+  'src/DataSource/DataSourceTreeWidget.cpp',
   'src/Settings/SqpSettingsDialog.cpp',
   'src/Settings/SqpSettingsGeneralWidget.cpp',
   'src/SidePane/SqpSidePane.cpp',
   'src/TimeWidget/TimeWidget.cpp',
   'src/Variable/VariableInspectorWidget.cpp',
+  'src/Variable/VariableInspectorTableView.cpp',
   'src/Variable/VariableMenuHeaderWidget.cpp',
   'src/Variable/RenameVariableDialog.cpp',
   'src/Visualization/VisualizationGraphHelper.cpp',
diff --git a/gui/src/DataSource/DataSourceTreeWidget.cpp b/gui/src/DataSource/DataSourceTreeWidget.cpp
index 2e39d7e..24f7f00 100644
--- a/gui/src/DataSource/DataSourceTreeWidget.cpp
+++ b/gui/src/DataSource/DataSourceTreeWidget.cpp
@@ -4,6 +4,7 @@
 #include "DataSource/DataSourceItem.h"
 #include "DataSource/DataSourceTreeWidgetItem.h"
 
+#include "DragAndDrop/DragDropHelper.h"
 #include "SqpApplication.h"
 
 #include <QMimeData>
@@ -35,3 +36,10 @@ QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) 
 
     return mimeData;
 }
+
+void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions)
+{
+    // Resets the drag&drop operations before it's starting
+    sqpApp->dragDropHelper().resetDragAndDrop();
+    QTreeWidget::startDrag(supportedActions);
+}
diff --git a/gui/src/DragAndDrop/DragDropHelper.cpp b/gui/src/DragAndDrop/DragDropHelper.cpp
new file mode 100644
index 0000000..dd2b000
--- /dev/null
+++ b/gui/src/DragAndDrop/DragDropHelper.cpp
@@ -0,0 +1,275 @@
+#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropScroller.h"
+#include "DragAndDrop/DragDropTabSwitcher.h"
+#include "SqpApplication.h"
+#include "Visualization/VisualizationDragDropContainer.h"
+#include "Visualization/VisualizationDragWidget.h"
+#include "Visualization/VisualizationWidget.h"
+#include "Visualization/operations/FindVariableOperation.h"
+
+#include "Variable/Variable.h"
+#include "Variable/VariableController.h"
+
+#include "Common/MimeTypesDef.h"
+#include "Common/VisualizationDef.h"
+
+#include <QDir>
+#include <QLabel>
+#include <QUrl>
+#include <QVBoxLayout>
+
+
+Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
+
+
+struct DragDropHelper::DragDropHelperPrivate {
+
+    VisualizationDragWidget *m_CurrentDragWidget = nullptr;
+    std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
+    QLabel *m_PlaceHolderLabel;
+    QWidget *m_PlaceBackground;
+    std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
+    std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = 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.
+
+    VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
+
+    QMetaObject::Connection m_DragWidgetDestroyedConnection;
+    QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
+
+    explicit DragDropHelperPrivate()
+            : m_PlaceHolder{std::make_unique<QWidget>()},
+              m_DragDropScroller{std::make_unique<DragDropScroller>()},
+              m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
+    {
+
+        auto layout = new QVBoxLayout{m_PlaceHolder.get()};
+        layout->setSpacing(0);
+        layout->setContentsMargins(0, 0, 0, 0);
+
+        m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
+        m_PlaceHolderLabel->setMinimumHeight(25);
+        layout->addWidget(m_PlaceHolderLabel);
+
+        m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
+        m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+        layout->addWidget(m_PlaceBackground);
+
+        sqpApp->installEventFilter(m_DragDropScroller.get());
+        sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
+
+        m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
+    }
+
+    void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
+    {
+        if (m_CurrentDragWidget) {
+            m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
+            m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
+        }
+        else {
+            // Configuration of the placeHolder when there is no dragWidget
+            // (for instance with a drag from a variable)
+
+            m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
+            m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+        }
+
+        switch (type) {
+            case DragDropHelper::PlaceHolderType::Graph:
+                m_PlaceBackground->setStyleSheet(
+                    "background-color: #BBD5EE; border: 1px solid #2A7FD4");
+                break;
+            case DragDropHelper::PlaceHolderType::Zone:
+            case DragDropHelper::PlaceHolderType::Default:
+                m_PlaceBackground->setStyleSheet(
+                    "background-color: #BBD5EE; border: 2px solid #2A7FD4");
+                m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
+                break;
+        }
+
+        m_PlaceHolderLabel->setText(topLabelText);
+        m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
+    }
+};
+
+
+DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
+
+DragDropHelper::~DragDropHelper()
+{
+    QFile::remove(impl->m_ImageTempUrl);
+}
+
+void DragDropHelper::resetDragAndDrop()
+{
+    setCurrentDragWidget(nullptr);
+    impl->m_HighlightedDragWidget = nullptr;
+}
+
+void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
+{
+    if (impl->m_CurrentDragWidget) {
+
+        QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
+    }
+
+    if (dragWidget) {
+        // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
+        impl->m_DragWidgetDestroyedConnection
+            = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
+                               [this]() { impl->m_CurrentDragWidget = nullptr; });
+    }
+
+    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, PlaceHolderType type,
+                                       const QString &topLabelText)
+{
+    removePlaceHolder();
+    impl->preparePlaceHolder(type, topLabelText);
+    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);
+}
+
+void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
+{
+    impl->m_DragDropTabSwitcher->addTabBar(tabBar);
+}
+
+void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
+{
+    impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
+}
+
+QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
+{
+    image.save(impl->m_ImageTempUrl);
+    return QUrl::fromLocalFile(impl->m_ImageTempUrl);
+}
+
+void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
+{
+    if (impl->m_HighlightedDragWidget) {
+        impl->m_HighlightedDragWidget->highlightForMerge(false);
+        QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
+    }
+
+    if (dragWidget) {
+        dragWidget->highlightForMerge(true);
+
+        // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
+        impl->m_DragWidgetDestroyedConnection
+            = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
+                               [this]() { impl->m_HighlightedDragWidget = nullptr; });
+    }
+
+    impl->m_HighlightedDragWidget = dragWidget;
+}
+
+VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
+{
+    return impl->m_HighlightedDragWidget;
+}
+
+bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
+                                                   VisualizationDragDropContainer *dropContainer)
+{
+    if (!mimeData || !dropContainer) {
+        qCWarning(LOG_DragDropHelper()) << QObject::tr(
+            "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
+        Q_ASSERT(false);
+        return false;
+    }
+
+    auto result = false;
+
+    if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+        auto variables = sqpApp->variableController().variablesForMimeData(
+            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+
+        if (variables.count() == 1) {
+
+            auto variable = variables.first();
+            if (variable->dataSeries() != nullptr) {
+
+                // Check that the variable is not already in a graph
+
+                auto parent = dropContainer->parentWidget();
+                while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
+                    parent = parent->parentWidget(); // Search for the top level VisualizationWidget
+                }
+
+                if (parent) {
+                    auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
+
+                    FindVariableOperation findVariableOperation{variable};
+                    visualizationWidget->accept(&findVariableOperation);
+                    auto variableContainers = findVariableOperation.result();
+                    if (variableContainers.empty()) {
+                        result = true;
+                    }
+                    else {
+                        // result = false: the variable already exist in the visualisation
+                    }
+                }
+                else {
+                    qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                        "DragDropHelper::checkMimeDataForVisualization, the parent "
+                        "VisualizationWidget cannot be found. Cannot check if the variable is "
+                        "already used or not.");
+                }
+            }
+            else {
+                // result = false: the variable is not fully loaded
+            }
+        }
+        else {
+            // result = false: cannot drop multiple variables in the visualisation
+        }
+    }
+    else {
+        // Other MIME data
+        // no special rules, accepted by default
+        result = true;
+    }
+
+    return result;
+}
diff --git a/gui/src/DragDropHelper.cpp b/gui/src/DragAndDrop/DragDropScroller.cpp
similarity index 67%
rename from gui/src/DragDropHelper.cpp
rename to gui/src/DragAndDrop/DragDropScroller.cpp
index a98ab82..0e8ac8e 100644
--- a/gui/src/DragDropHelper.cpp
+++ b/gui/src/DragAndDrop/DragDropScroller.cpp
@@ -1,35 +1,19 @@
-#include "DragDropHelper.h"
-#include "SqpApplication.h"
-#include "Visualization/VisualizationDragDropContainer.h"
-#include "Visualization/VisualizationDragWidget.h"
-#include "Visualization/VisualizationWidget.h"
-#include "Visualization/operations/FindVariableOperation.h"
+#include "DragAndDrop/DragDropScroller.h"
 
-#include "Variable/VariableController.h"
-
-#include "Common/MimeTypesDef.h"
-#include "Common/VisualizationDef.h"
-
-#include <QDir>
 #include <QDragEnterEvent>
 #include <QDragMoveEvent>
-#include <QScrollArea>
 #include <QScrollBar>
 #include <QTimer>
-#include <QVBoxLayout>
 
 const int SCROLL_SPEED = 5;
 const int SCROLL_ZONE_SIZE = 50;
 
-Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
-
 struct DragDropScroller::DragDropScrollerPrivate {
 
     QList<QScrollArea *> m_ScrollAreas;
     QScrollArea *m_CurrentScrollArea = nullptr;
     std::unique_ptr<QTimer> m_Timer = nullptr;
 
-
     enum class ScrollDirection { up, down, unknown };
     ScrollDirection m_Direction = ScrollDirection::unknown;
 
@@ -139,157 +123,3 @@ void DragDropScroller::onTimer()
             impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
     }
 }
-
-struct DragDropHelper::DragDropHelperPrivate {
-
-    VisualizationDragWidget *m_CurrentDragWidget = nullptr;
-    std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
-    std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
-    QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
-                            // QTemporaryFile to have a name which is not generated.
-
-    explicit DragDropHelperPrivate()
-            : m_PlaceHolder{std::make_unique<QWidget>()},
-              m_DragDropScroller{std::make_unique<DragDropScroller>()}
-    {
-        m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
-        sqpApp->installEventFilter(m_DragDropScroller.get());
-
-
-        m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
-    }
-
-    void preparePlaceHolder() const
-    {
-        if (m_CurrentDragWidget) {
-            m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
-            m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
-        }
-        else {
-            // Configuration of the placeHolder when there is no dragWidget
-            // (for instance with a drag from a variable)
-
-            m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
-            m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-        }
-    }
-};
-
-
-DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
-{
-}
-
-DragDropHelper::~DragDropHelper()
-{
-    QFile::remove(impl->m_ImageTempUrl);
-}
-
-void DragDropHelper::resetDragAndDrop()
-{
-    setCurrentDragWidget(nullptr);
-}
-
-void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
-{
-    impl->m_CurrentDragWidget = dragWidget;
-}
-
-VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
-{
-    return impl->m_CurrentDragWidget;
-}
-
-
-QWidget &DragDropHelper::placeHolder() const
-{
-    return *impl->m_PlaceHolder;
-}
-
-void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index)
-{
-    removePlaceHolder();
-    impl->preparePlaceHolder();
-    layout->insertWidget(index, impl->m_PlaceHolder.get());
-    impl->m_PlaceHolder->show();
-}
-
-void DragDropHelper::removePlaceHolder()
-{
-    auto parentWidget = impl->m_PlaceHolder->parentWidget();
-    if (parentWidget) {
-        parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
-        impl->m_PlaceHolder->setParent(nullptr);
-        impl->m_PlaceHolder->hide();
-    }
-}
-
-bool DragDropHelper::isPlaceHolderSet() const
-{
-    return impl->m_PlaceHolder->parentWidget();
-}
-
-void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
-{
-    impl->m_DragDropScroller->addScrollArea(scrollArea);
-}
-
-void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
-{
-    impl->m_DragDropScroller->removeScrollArea(scrollArea);
-}
-
-QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
-{
-    image.save(impl->m_ImageTempUrl);
-    return QUrl::fromLocalFile(impl->m_ImageTempUrl);
-}
-
-bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
-                                                   VisualizationDragDropContainer *dropContainer)
-{
-    if (!mimeData || !dropContainer) {
-        qCWarning(LOG_DragDropHelper()) << QObject::tr(
-            "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
-        Q_ASSERT(false);
-    }
-
-    auto result = true;
-
-    if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
-        auto variables = sqpApp->variableController().variablesForMimeData(
-            mimeData->data(MIME_TYPE_VARIABLE_LIST));
-
-        if (variables.count() == 1) {
-            // Check that the viariable is not already in a graph
-
-            // Search for the top level VisualizationWidget
-            auto parent = dropContainer->parentWidget();
-            while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
-                parent = parent->parentWidget();
-            }
-
-            if (parent) {
-                auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
-
-                FindVariableOperation findVariableOperation{variables.first()};
-                visualizationWidget->accept(&findVariableOperation);
-                auto variableContainers = findVariableOperation.result();
-                if (!variableContainers.empty()) {
-                    result = false;
-                }
-            }
-            else {
-                qCWarning(LOG_DragDropHelper()) << QObject::tr(
-                    "DragDropHelper::checkMimeDataForVisualization, the parent "
-                    "VisualizationWidget cannot be found.");
-                result = false;
-            }
-        }
-        else {
-            result = false;
-        }
-    }
-
-    return result;
-}
diff --git a/gui/src/DragAndDrop/DragDropTabSwitcher.cpp b/gui/src/DragAndDrop/DragDropTabSwitcher.cpp
new file mode 100644
index 0000000..ce42b3a
--- /dev/null
+++ b/gui/src/DragAndDrop/DragDropTabSwitcher.cpp
@@ -0,0 +1,180 @@
+#include "DragAndDrop/DragDropTabSwitcher.h"
+
+#include <QAbstractButton>
+#include <QDragEnterEvent>
+#include <QDragMoveEvent>
+#include <QTimer>
+
+#include "SqpApplication.h"
+
+Q_LOGGING_CATEGORY(LOG_DragDropTabSwitcher, "DragDropTabSwitcher")
+
+const int CHANGE_TAB_INTERVAL = 400; // time necessary over a tab to accept the switch
+const int SCROLL_BUTTON_AUTO_CLICK_INTERVAL
+    = 500; // time between 2 auto clicks on a scroll button of the tab bar
+
+struct DragDropTabSwitcher::DragDropTabSwitcherPrivate {
+
+    QList<QTabBar *> m_TabBarList;
+    QTabBar *m_CurrentTabBar = nullptr;
+
+    int m_HoveredTabIndex = -1;
+    std::unique_ptr<QTimer> m_TabSwitchTimer = nullptr;
+
+    QAbstractButton *m_HoveredScrollButton = nullptr;
+    std::unique_ptr<QTimer> m_ScrollButtonsTimer = nullptr;
+
+    explicit DragDropTabSwitcherPrivate()
+            : m_TabSwitchTimer{std::make_unique<QTimer>()},
+              m_ScrollButtonsTimer{std::make_unique<QTimer>()}
+    {
+        m_TabSwitchTimer->setSingleShot(true);
+        m_TabSwitchTimer->setInterval(CHANGE_TAB_INTERVAL);
+        QObject::connect(m_TabSwitchTimer.get(), &QTimer::timeout, [this]() {
+            if (m_CurrentTabBar) {
+                m_CurrentTabBar->setCurrentIndex(m_HoveredTabIndex);
+            }
+            else {
+                qCWarning(LOG_DragDropTabSwitcher()) << "DragDropTabSwitcherPrivate::timeout: "
+                                                        "Cannot select a new tab: unknown current "
+                                                        "tab bar.";
+            }
+        });
+
+        m_ScrollButtonsTimer->setInterval(SCROLL_BUTTON_AUTO_CLICK_INTERVAL);
+        QObject::connect(m_ScrollButtonsTimer.get(), &QTimer::timeout, [this]() {
+            if (m_HoveredScrollButton) {
+                m_HoveredScrollButton->animateClick();
+            }
+            else {
+                qCWarning(LOG_DragDropTabSwitcher())
+                    << "DragDropTabSwitcherPrivate::timeoutScroll: "
+                       "Unknown scroll button";
+            }
+        });
+    }
+
+    bool isScrollTabButton(QAbstractButton *button, QTabBar *tabBar)
+    {
+        auto isNextOrPreviousTabButton = true;
+
+        if (tabBar->isAncestorOf(button)) {
+            for (auto i = 0; i < tabBar->count(); ++i) {
+                if (tabBar->tabButton(i, QTabBar::RightSide) == button
+                    || tabBar->tabButton(i, QTabBar::LeftSide) == button) {
+                    isNextOrPreviousTabButton = false;
+                    break;
+                }
+            }
+        }
+        else {
+            isNextOrPreviousTabButton = false;
+        }
+
+        return isNextOrPreviousTabButton;
+    }
+
+    QAbstractButton *tabScrollButtonAt(const QPoint &pos, QTabBar *tabBar)
+    {
+
+        auto globalPos = tabBar->mapToGlobal(pos);
+
+        auto widgetUnderMouse = sqpApp->widgetAt(globalPos);
+        if (auto btn = qobject_cast<QAbstractButton *>(widgetUnderMouse)) {
+
+            if (isScrollTabButton(btn, tabBar)) {
+                return btn;
+            }
+        }
+
+        return nullptr;
+    }
+};
+
+DragDropTabSwitcher::DragDropTabSwitcher(QObject *parent)
+        : QObject(parent), impl{spimpl::make_unique_impl<DragDropTabSwitcherPrivate>()}
+{
+}
+
+void DragDropTabSwitcher::addTabBar(QTabBar *tabBar)
+{
+    impl->m_TabBarList << tabBar;
+    tabBar->setAcceptDrops(true);
+}
+
+void DragDropTabSwitcher::removeTabBar(QTabBar *tabBar)
+{
+    impl->m_TabBarList.removeAll(tabBar);
+    tabBar->setAcceptDrops(false);
+}
+
+bool DragDropTabSwitcher::eventFilter(QObject *obj, QEvent *event)
+{
+    if (event->type() == QEvent::DragMove) {
+
+        if (impl->m_CurrentTabBar) {
+
+            QWidget *w = static_cast<QWidget *>(obj);
+            if (!impl->m_CurrentTabBar->isAncestorOf(w)) {
+                return false;
+            }
+
+            auto moveEvent = static_cast<QDragMoveEvent *>(event);
+
+            auto scrollButton = impl->tabScrollButtonAt(moveEvent->pos(), impl->m_CurrentTabBar);
+
+            if (!scrollButton) {
+
+                auto tabIndex = impl->m_CurrentTabBar->tabAt(moveEvent->pos());
+                if (tabIndex >= 0 && tabIndex != impl->m_CurrentTabBar->currentIndex()) {
+                    // The mouse is over an unselected tab
+                    if (!impl->m_TabSwitchTimer->isActive()
+                        || tabIndex != impl->m_HoveredTabIndex) {
+                        impl->m_HoveredTabIndex = tabIndex;
+                        impl->m_TabSwitchTimer->start();
+                    }
+                    else {
+                        // do nothing, timer already running
+                    }
+                }
+                else {
+                    impl->m_TabSwitchTimer->stop();
+                }
+
+                impl->m_ScrollButtonsTimer->stop();
+            }
+            else {
+                // The mouse is over a scroll button
+                // click it in a loop with a timer
+                if (!impl->m_ScrollButtonsTimer->isActive()
+                    || impl->m_HoveredScrollButton != scrollButton) {
+                    impl->m_HoveredScrollButton = scrollButton;
+                    impl->m_ScrollButtonsTimer->start();
+                }
+            }
+        }
+    }
+    else if (event->type() == QEvent::DragEnter) {
+        QWidget *w = static_cast<QWidget *>(obj);
+
+        for (auto tabBar : impl->m_TabBarList) {
+            if (w == tabBar) {
+                auto enterEvent = static_cast<QDragEnterEvent *>(event);
+                enterEvent->acceptProposedAction();
+                enterEvent->setDropAction(Qt::IgnoreAction);
+                impl->m_CurrentTabBar = tabBar;
+                break;
+            }
+        }
+    }
+    else if (event->type() == QEvent::DragLeave || event->type() == QEvent::Drop) {
+        if (impl->m_CurrentTabBar) {
+            impl->m_HoveredTabIndex = -1;
+            impl->m_TabSwitchTimer->stop();
+            impl->m_CurrentTabBar = nullptr;
+            impl->m_ScrollButtonsTimer->stop();
+        }
+    }
+
+    return false;
+}
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index 7b200c1..aa0e813 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -2,7 +2,7 @@
 
 #include <Data/IDataProvider.h>
 #include <DataSource/DataSourceController.h>
-#include <DragDropHelper.h>
+#include <DragAndDrop/DragDropHelper.h>
 #include <Network/NetworkController.h>
 #include <QThread>
 #include <Time/TimeController.h>
diff --git a/gui/src/TimeWidget/TimeWidget.cpp b/gui/src/TimeWidget/TimeWidget.cpp
index 08801fe..050eae3 100644
--- a/gui/src/TimeWidget/TimeWidget.cpp
+++ b/gui/src/TimeWidget/TimeWidget.cpp
@@ -2,10 +2,29 @@
 #include "ui_TimeWidget.h"
 
 #include <Common/DateUtils.h>
+#include <Common/MimeTypesDef.h>
+
+#include <DragAndDrop/DragDropHelper.h>
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 
-TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
+#include <QDrag>
+#include <QDragEnterEvent>
+#include <QDropEvent>
+#include <QMimeData>
+
+
+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);
 
@@ -41,10 +60,97 @@ TimeWidget::~TimeWidget()
     delete ui;
 }
 
-void TimeWidget::onTimeUpdateRequested()
+void TimeWidget::setTimeRange(SqpRange time)
+{
+    auto startDateTime = DateUtils::dateTime(time.m_TStart);
+    auto endDateTime = DateUtils::dateTime(time.m_TEnd);
+
+    ui->startDateTimeEdit->setDateTime(startDateTime);
+    ui->endDateTimeEdit->setDateTime(endDateTime);
+}
+
+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));
 }
+
+void TimeWidget::dragEnterEvent(QDragEnterEvent *event)
+{
+    if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
+        event->acceptProposedAction();
+        setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
+    }
+    else {
+        event->ignore();
+    }
+}
+
+void TimeWidget::dragLeaveEvent(QDragLeaveEvent *event)
+{
+    setStyleSheet(QString());
+}
+
+void TimeWidget::dropEvent(QDropEvent *event)
+{
+    if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
+        auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
+        auto timeRange = TimeController::timeRangeForMimeData(mimeData);
+
+        setTimeRange(timeRange);
+    }
+    else {
+        event->ignore();
+    }
+
+    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/Variable/VariableInspectorTableView.cpp b/gui/src/Variable/VariableInspectorTableView.cpp
new file mode 100644
index 0000000..9d752a1
--- /dev/null
+++ b/gui/src/Variable/VariableInspectorTableView.cpp
@@ -0,0 +1,13 @@
+#include "Variable/VariableInspectorTableView.h"
+
+#include "DragAndDrop/DragDropHelper.h"
+#include "SqpApplication.h"
+
+VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent) {}
+
+void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
+{
+    // Resets the drag&drop operations before it's starting
+    sqpApp->dragDropHelper().resetDragAndDrop();
+    QTableView::startDrag(supportedActions);
+}
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index 138fe12..849bec7 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -12,7 +12,7 @@
 #include <QStyledItemDelegate>
 #include <QWidgetAction>
 
-#include <DragDropHelper.h>
+#include <DragAndDrop/DragDropHelper.h>
 #include <SqpApplication.h>
 
 Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
@@ -152,11 +152,6 @@ 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 e957a28..714d369 100644
--- a/gui/src/Visualization/VisualizationDragDropContainer.cpp
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -1,5 +1,5 @@
 #include "Visualization/VisualizationDragDropContainer.h"
-#include "DragDropHelper.h"
+#include "DragAndDrop/DragDropHelper.h"
 #include "SqpApplication.h"
 #include "Visualization/VisualizationDragWidget.h"
 
@@ -17,11 +17,15 @@ Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropCon
 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     QVBoxLayout *m_Layout;
-    QStringList m_AcceptedMimeTypes;
-    QStringList m_MergeAllowedMimeTypes;
+    QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
+    QString m_PlaceHolderText;
+    DragDropHelper::PlaceHolderType m_PlaceHolderType = DragDropHelper::PlaceHolderType::Graph;
+
     VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
         = [](auto mimeData) { return true; };
 
+    int m_MinContainerHeight = 0;
+
     explicit VisualizationDragDropContainerPrivate(QWidget *widget)
     {
         m_Layout = new QVBoxLayout(widget);
@@ -30,7 +34,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;
             }
@@ -39,10 +43,38 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
         return false;
     }
 
-    bool allowMergeMimeData(const QMimeData *data) const
+    bool allowMergeForMimeData(const QMimeData *data) const
+    {
+        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 (const auto &type : m_MergeAllowedMimeTypes) {
-            if (data->hasFormat(type)) {
+        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;
             }
         }
@@ -55,7 +87,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
         return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
     }
 
-    VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
+    VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
     {
         VisualizationDragWidget *dragWidget = nullptr;
 
@@ -74,15 +106,29 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     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()));
+        return container->isAncestorOf(sqpApp->widgetAt(QCursor::pos()));
+    }
+
+    int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
+    {
+        auto nbGraph = 0;
+        for (auto child : parent->children()) {
+            if (qobject_cast<VisualizationDragWidget *>(child)) {
+                if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
+                    nbGraph += 1;
+                }
+            }
+        }
+
+        return nbGraph;
     }
+
+    void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
+                                 const VisualizationDragDropContainer *container);
 };
 
 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
-        : QWidget{parent},
+        : QFrame{parent},
           impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
 {
     setAcceptDrops(true);
@@ -105,26 +151,15 @@ 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
 {
-    auto nbGraph = 0;
-    for (auto child : children()) {
-        if (qobject_cast<VisualizationDragWidget *>(child)) {
-            nbGraph += 1;
-        }
-    }
-
-    return nbGraph;
+    return impl->countDragWidget(this);
 }
 
 void VisualizationDragDropContainer::setAcceptMimeDataFunction(
@@ -133,6 +168,13 @@ void VisualizationDragDropContainer::setAcceptMimeDataFunction(
     impl->m_AcceptMimeDataFun = fun;
 }
 
+void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+                                                        const QString &placeHolderText)
+{
+    impl->m_PlaceHolderType = type;
+    impl->m_PlaceHolderText = placeHolderText;
+}
+
 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                const QPoint &dragPosition)
 {
@@ -159,9 +201,14 @@ void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidg
 
         if (impl->cursorIsInContainer(this)) {
             auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
-            helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
+            helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
+                                     impl->m_PlaceHolderText);
             dragWidget->setVisible(false);
         }
+        else {
+            // The drag starts directly outside the drop zone
+            // do not add the placeHolder
+        }
 
         // Note: The exec() is blocking on windows but not on linux and macOS
         drag->exec(Qt::MoveAction | Qt::CopyAction);
@@ -185,7 +232,7 @@ void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
 
             if (dragWidget) {
                 // If the drag&drop is internal to the visualization, entering the container hide
-                // the dragWidget which was hidden by the dragLeaveEvent
+                // the dragWidget which was made visible by the dragLeaveEvent
                 auto parentWidget
                     = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                 if (parentWidget) {
@@ -193,26 +240,9 @@ void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
                 }
             }
 
-            auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
-
-            if (dragWidgetHovered) {
-                auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
-
-                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);
-            }
-            else {
-                helper.insertPlaceHolder(impl->m_Layout, 0);
-            }
+            auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+            auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+            impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
         }
         else {
             // do nothing
@@ -233,6 +263,8 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
 
     if (!impl->cursorIsInContainer(this)) {
         helper.removePlaceHolder();
+        helper.setHightlightedDragWidget(nullptr);
+        impl->m_MinContainerHeight = 0;
 
         auto dragWidget = helper.getCurrentDragWidget();
         if (dragWidget) {
@@ -258,105 +290,164 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *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 = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
+        auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+        impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
+    }
+    else {
+        event->ignore();
+    }
 
-                auto dropIndex = floor(event->pos().y() / graphHeight);
-                auto zoneSize = qMin(graphHeight / 3.0, 150.0);
+    QWidget::dragMoveEvent(event);
+}
 
-                auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
-                auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
+void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
+{
+    auto &helper = sqpApp->dragDropHelper();
 
-                auto &helper = sqpApp->dragDropHelper();
-                auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
+    if (impl->acceptMimeData(event->mimeData())) {
+        auto dragWidget = helper.getCurrentDragWidget();
+        if (impl->hasPlaceHolder()) {
+            // drop where the placeHolder is located
 
-                if (isOnTop || isOnBottom) {
-                    if (isOnBottom) {
-                        dropIndex += 1;
-                    }
+            auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+            if (canInsert) {
+                auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
 
-                    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 (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 (dropIndex != placeHolderIndex) {
-                        helper.insertPlaceHolder(impl->m_Layout, dropIndex);
-                    }
-                }
-                else if (canMerge) {
-                    // drop on the middle -> merge
-                    if (impl->hasPlaceHolder()) {
-                        helper.removePlaceHolder();
-                    }
+                    dragWidget->setVisible(true);
                 }
+
+                event->acceptProposedAction();
+
+                helper.removePlaceHolder();
+
+                emit dropOccuredInContainer(droppedIndex, event->mimeData());
             }
             else {
-                qCWarning(LOG_VisualizationDragDropContainer())
-                    << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
-                          "container");
+                qCWarning(LOG_VisualizationDragDropContainer()) << tr(
+                    "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
+                    "the insertion is forbidden.");
+                Q_ASSERT(false);
             }
         }
-        else {
-            // No hovered drag widget, the mouse is probably hover the placeHolder
-            // Do nothing
+        else if (helper.getHightlightedDragWidget()) {
+            // drop on the highlighted widget
+
+            auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+            if (canMerge) {
+                event->acceptProposedAction();
+                emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
+            }
+            else {
+                qCWarning(LOG_VisualizationDragDropContainer())
+                    << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
+                          "the merge is forbidden.");
+                Q_ASSERT(false);
+            }
         }
     }
     else {
         event->ignore();
     }
 
-    QWidget::dragMoveEvent(event);
+    sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
+    impl->m_MinContainerHeight = 0;
+
+    QWidget::dropEvent(event);
 }
 
-void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
+
+void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
+    const QPoint &pos, bool canInsert, bool canMerge,
+    const VisualizationDragDropContainer *container)
 {
-    if (impl->acceptMimeData(event->mimeData())) {
-        auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
-        if (impl->hasPlaceHolder()) {
-            auto &helper = sqpApp->dragDropHelper();
+    auto &helper = sqpApp->dragDropHelper();
 
-            auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
+    auto absPos = container->mapToGlobal(pos);
+    auto isOnPlaceHolder = sqpApp->widgetAt(absPos) == &(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 (countDragWidget(container, true) == 0) {
+        // Drop on an empty container, just add the placeHolder at the top
+        helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
+    }
+    else if (!isOnPlaceHolder) {
+        auto nbDragWidget = countDragWidget(container);
+        if (nbDragWidget > 0) {
 
-                dragWidget->setVisible(true);
+            if (m_MinContainerHeight == 0) {
+                m_MinContainerHeight = container->size().height();
             }
 
-            event->acceptProposedAction();
+            m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
+            auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
+
+            auto posY = pos.y();
+            auto dropIndex = floor(posY / graphHeight);
+            auto zoneSize = qMin(graphHeight / 4.0, 75.0);
+
+
+            auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
+            auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
+
+            auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
+
+            auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
 
-            helper.removePlaceHolder();
+            if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
+                if (isOnBottom) {
+                    dropIndex += 1;
+                }
 
-            emit dropOccured(droppedIndex, event->mimeData());
+                if (helper.getCurrentDragWidget()) {
+                    auto dragWidgetIndex = 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) {
+                    helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
+                                             m_PlaceHolderText);
+                }
+
+                helper.setHightlightedDragWidget(nullptr);
+            }
+            else if (canMerge && dragWidgetHovered) {
+                // drop on the middle -> merge
+                if (hasPlaceHolder()) {
+                    helper.removePlaceHolder();
+                }
+
+                helper.setHightlightedDragWidget(dragWidgetHovered);
+            }
+            else {
+                qCWarning(LOG_VisualizationDragDropContainer())
+                    << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
+                          "action.");
+                Q_ASSERT(false);
+            }
         }
         else {
             qCWarning(LOG_VisualizationDragDropContainer())
-                << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
-                      "placeHolder is not found.");
-            Q_ASSERT(false);
+                << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
+                      "found in the "
+                      "container");
         }
     }
     else {
-        event->ignore();
+        // the mouse is hover the placeHolder
+        // Do nothing
     }
-
-    QWidget::dropEvent(event);
 }
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 14dfe20..ba0672b 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -9,9 +9,10 @@
 #include <Common/MimeTypesDef.h>
 #include <Data/ArrayData.h>
 #include <Data/IDataSeries.h>
-#include <DragDropHelper.h>
+#include <DragAndDrop/DragDropHelper.h>
 #include <Settings/SqpSettingsDefs.h>
 #include <SqpApplication.h>
+#include <Time/TimeController.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
@@ -235,6 +236,9 @@ QMimeData *VisualizationGraphWidget::mimeData() const
     auto mimeData = new QMimeData;
     mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
 
+    auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
+    mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
+
     return mimeData;
 }
 
@@ -243,6 +247,18 @@ bool VisualizationGraphWidget::isDragAllowed() const
     return true;
 }
 
+void VisualizationGraphWidget::highlightForMerge(bool highlighted)
+{
+    if (highlighted) {
+        plot().setBackground(QBrush(QColor("#BBD5EE")));
+    }
+    else {
+        plot().setBackground(QBrush(Qt::white));
+    }
+
+    plot().update();
+}
+
 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
 {
     Q_UNUSED(event);
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 2bdce7f..9c6d8ab 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -9,7 +9,7 @@
 
 #include "Common/MimeTypesDef.h"
 
-#include "DragDropHelper.h"
+#include "DragAndDrop/DragDropHelper.h"
 #include "SqpApplication.h"
 
 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
@@ -68,14 +68,23 @@ 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::dropOccured, this,
-            &VisualizationTabWidget::dropMimeData);
+    ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
+    ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 5);
+    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/VisualizationWidget.cpp b/gui/src/Visualization/VisualizationWidget.cpp
index b215461..39f3370 100644
--- a/gui/src/Visualization/VisualizationWidget.cpp
+++ b/gui/src/Visualization/VisualizationWidget.cpp
@@ -11,6 +11,9 @@
 
 #include "ui_VisualizationWidget.h"
 
+#include "DragAndDrop/DragDropHelper.h"
+#include "SqpApplication.h"
+
 #include <QToolButton>
 
 Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
@@ -67,12 +70,15 @@ VisualizationWidget::VisualizationWidget(QWidget *parent)
     connect(addTabViewButton, &QToolButton::clicked, addTabView);
     connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
 
+    sqpApp->dragDropHelper().addDragDropTabBar(ui->tabWidget->tabBar());
+
     // Adds default tab
     addTabView();
 }
 
 VisualizationWidget::~VisualizationWidget()
 {
+    sqpApp->dragDropHelper().removeDragDropTabBar(ui->tabWidget->tabBar());
     delete ui;
 }
 
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 171e6c2..0a911cb 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -10,12 +10,13 @@
 #include "Common/VisualizationDef.h"
 
 #include <Data/SqpRange.h>
+#include <Time/TimeController.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
 #include <Visualization/operations/FindVariableOperation.h>
 
-#include <DragDropHelper.h>
+#include <DragAndDrop/DragDropHelper.h>
 #include <QUuid>
 #include <SqpApplication.h>
 #include <cmath>
@@ -71,6 +72,21 @@ struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
     QUuid m_SynchronisationGroupId;
     std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
 
+    // Returns the first graph in the zone or nullptr if there is no graph inside
+    VisualizationGraphWidget *firstGraph(const VisualizationZoneWidget *zoneWidget) const
+    {
+        VisualizationGraphWidget *firstGraph = nullptr;
+        auto layout = zoneWidget->ui->dragDropContainer->layout();
+        if (layout->count() > 0) {
+            if (auto visualizationGraphWidget
+                = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                firstGraph = visualizationGraphWidget;
+            }
+        }
+
+        return firstGraph;
+    }
+
     void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
     void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                        VisualizationZoneWidget *zoneWidget);
@@ -85,13 +101,22 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
 
     ui->zoneNameLabel->setText(name);
 
-    ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
+    ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Graph);
+    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);
     });
-    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
             &VisualizationZoneWidget::dropMimeData);
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
+            &VisualizationZoneWidget::dropMimeDataOnGraph);
 
     // 'Close' options : widget is deleted when closed
     setAttribute(Qt::WA_DeleteOnClose);
@@ -234,15 +259,9 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
             &VisualizationZoneWidget::onVariableAboutToBeRemoved);
 
     auto range = SqpRange{};
-
-    // Apply visitor to graph children
-    auto layout = ui->dragDropContainer->layout();
-    if (layout->count() > 0) {
+    if (auto firstGraph = impl->firstGraph(this)) {
         // Case of a new graph in a existant zone
-        if (auto visualizationGraphWidget
-            = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
-            range = visualizationGraphWidget->graphRange();
-        }
+        range = firstGraph->graphRange();
     }
     else {
         // Case of a new graph as the first of the zone
@@ -380,6 +399,35 @@ void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
     }
 }
 
+void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
+                                                  const QMimeData *mimeData)
+{
+    auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
+    if (!graphWidget) {
+        qCWarning(LOG_VisualizationZoneWidget())
+            << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
+                  "drop aborted");
+        Q_ASSERT(false);
+        return;
+    }
+
+    if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+        auto variables = sqpApp->variableController().variablesForMimeData(
+            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+        for (const auto &var : variables) {
+            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.");
+    }
+}
+
 void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
     int index, VisualizationZoneWidget *zoneWidget)
 {
diff --git a/gui/ui/TimeWidget/TimeWidget.ui b/gui/ui/TimeWidget/TimeWidget.ui
index afc7200..9f074ba 100644
--- a/gui/ui/TimeWidget/TimeWidget.ui
+++ b/gui/ui/TimeWidget/TimeWidget.ui
@@ -16,9 +16,15 @@
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
+  <property name="acceptDrops">
+   <bool>true</bool>
+  </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
+  <property name="styleSheet">
+   <string notr="true">b</string>
+  </property>
   <layout class="QHBoxLayout" name="horizontalLayout_2">
    <item>
     <widget class="QLabel" name="label">
diff --git a/gui/ui/Variable/VariableInspectorWidget.ui b/gui/ui/Variable/VariableInspectorWidget.ui
index 66b9377..6f8e92a 100644
--- a/gui/ui/Variable/VariableInspectorWidget.ui
+++ b/gui/ui/Variable/VariableInspectorWidget.ui
@@ -15,7 +15,7 @@
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
-    <widget class="QTableView" name="tableView">
+    <widget class="VariableInspectorTableView" name="tableView">
      <property name="acceptDrops">
       <bool>true</bool>
      </property>
@@ -35,6 +35,13 @@
    </item>
   </layout>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>VariableInspectorTableView</class>
+   <extends>QTableView</extends>
+   <header>Variable/VariableInspectorTableView.h</header>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/gui/ui/Visualization/VisualizationTabWidget.ui b/gui/ui/Visualization/VisualizationTabWidget.ui
index afdd13e..3710bf7 100644
--- a/gui/ui/Visualization/VisualizationTabWidget.ui
+++ b/gui/ui/Visualization/VisualizationTabWidget.ui
@@ -63,7 +63,11 @@
         <number>0</number>
        </property>
        <item>
-        <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
+        <widget class="VisualizationDragDropContainer" name="dragDropContainer">
+         <property name="lineWidth">
+          <number>0</number>
+         </property>
+        </widget>
        </item>
       </layout>
      </widget>
@@ -74,7 +78,7 @@
  <customwidgets>
   <customwidget>
    <class>VisualizationDragDropContainer</class>
-   <extends>QWidget</extends>
+   <extends>QFrame</extends>
    <header>Visualization/VisualizationDragDropContainer.h</header>
    <container>1</container>
   </customwidget>
diff --git a/gui/ui/Visualization/VisualizationZoneWidget.ui b/gui/ui/Visualization/VisualizationZoneWidget.ui
index 9746ca6..4cd71e7 100644
--- a/gui/ui/Visualization/VisualizationZoneWidget.ui
+++ b/gui/ui/Visualization/VisualizationZoneWidget.ui
@@ -78,7 +78,7 @@
     </widget>
    </item>
    <item>
-    <widget class="QFrame" name="visualizationZoneFrame">
+    <widget class="VisualizationDragDropContainer" name="dragDropContainer">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
        <horstretch>0</horstretch>
@@ -107,9 +107,6 @@
       <property name="bottomMargin">
        <number>0</number>
       </property>
-      <item>
-       <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
-      </item>
      </layout>
     </widget>
    </item>
@@ -118,7 +115,7 @@
  <customwidgets>
   <customwidget>
    <class>VisualizationDragDropContainer</class>
-   <extends>QWidget</extends>
+   <extends>QFrame</extends>
    <header>Visualization/VisualizationDragDropContainer.h</header>
    <container>1</container>
   </customwidget>