HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r889:756d7fefd6f4

Merge pull request from SciQLop-fork develop...

leroux -

r889:756d7fefd6f4

parent child

Context file:

r889:756d7fefd6f4

Expand all files

gui/include/DragAndDrop/DragDropScroller.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef SCIQLOP_DRAGDROPSCROLLER_H
	2	#define SCIQLOP_DRAGDROPSCROLLER_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QScrollArea>
	6
	7	/**
	8	* @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
	9	* @note A QScrollArea inside an other QScrollArea is not fully supported.
	10	*/
	11	class DragDropScroller : public QObject {
	12	Q_OBJECT
	13
	14	public:
	15	DragDropScroller(QObject *parent = nullptr);
	16
	17	void addScrollArea(QScrollArea *scrollArea);
	18	void removeScrollArea(QScrollArea *scrollArea);
	19
	20	protected:
	21	bool eventFilter(QObject obj, QEvent event);
	22
	23	private:
	24	class DragDropScrollerPrivate;
	25	spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
	26
	27	private slots:
	28	void onTimer();
	29	};
	30
	31
	32	#endif // SCIQLOP_DRAGDROPSCROLLER_H

gui/include/DragAndDrop/DragDropTabSwitcher.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef SCIQLOP_DRAGDROPTABSWITCHER_H
	2	#define SCIQLOP_DRAGDROPTABSWITCHER_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QTabBar>
	8
	9	Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropTabSwitcher)
	10
	11	class DragDropTabSwitcher : public QObject {
	12	Q_OBJECT
	13
	14	public:
	15	DragDropTabSwitcher(QObject *parent = nullptr);
	16
	17	void addTabBar(QTabBar *tabBar);
	18	void removeTabBar(QTabBar *tabBar);
	19
	20	protected:
	21	bool eventFilter(QObject obj, QEvent event);
	22
	23	private:
	24	class DragDropTabSwitcherPrivate;
	25	spimpl::unique_impl_ptr<DragDropTabSwitcherPrivate> impl;
	26	};
	27
	28
	29	#endif // SCIQLOP_DRAGDROPTABSWITCHER_H

gui/include/Variable/VariableInspectorTableView.h created 644 +14 0

@@ -0,0 +1,14
	1	#ifndef SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H
	2	#define SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H
	3
	4	#include <QTableView>
	5
	6	class VariableInspectorTableView : public QTableView {
	7	public:
	8	VariableInspectorTableView(QWidget *parent = nullptr);
	9
	10	protected:
	11	void startDrag(Qt::DropActions supportedActions);
	12	};
	13
	14	#endif // SCIQLOP_VARIABLEINSPECTORTABLEVIEW_H

gui/src/DragAndDrop/DragDropHelper.cpp created 644 +275 0

@@ -0,0 +1,275
	1	#include "DragAndDrop/DragDropHelper.h"
	2	#include "DragAndDrop/DragDropScroller.h"
	3	#include "DragAndDrop/DragDropTabSwitcher.h"
	4	#include "SqpApplication.h"
	5	#include "Visualization/VisualizationDragDropContainer.h"
	6	#include "Visualization/VisualizationDragWidget.h"
	7	#include "Visualization/VisualizationWidget.h"
	8	#include "Visualization/operations/FindVariableOperation.h"
	9
	10	#include "Variable/Variable.h"
	11	#include "Variable/VariableController.h"
	12
	13	#include "Common/MimeTypesDef.h"
	14	#include "Common/VisualizationDef.h"
	15
	16	#include <QDir>
	17	#include <QLabel>
	18	#include <QUrl>
	19	#include <QVBoxLayout>
	20
	21
	22	Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
	23
	24
	25	struct DragDropHelper::DragDropHelperPrivate {
	26
	27	VisualizationDragWidget *m_CurrentDragWidget = nullptr;
	28	std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
	29	QLabel *m_PlaceHolderLabel;
	30	QWidget *m_PlaceBackground;
	31	std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
	32	std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
	33	QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
	34	// QTemporaryFile to have a name which is not generated.
	35
	36	VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
	37
	38	QMetaObject::Connection m_DragWidgetDestroyedConnection;
	39	QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
	40
	41	explicit DragDropHelperPrivate()
	42	: m_PlaceHolder{std::make_unique<QWidget>()},
	43	m_DragDropScroller{std::make_unique<DragDropScroller>()},
	44	m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
	45	{
	46
	47	auto layout = new QVBoxLayout{m_PlaceHolder.get()};
	48	layout->setSpacing(0);
	49	layout->setContentsMargins(0, 0, 0, 0);
	50
	51	m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
	52	m_PlaceHolderLabel->setMinimumHeight(25);
	53	layout->addWidget(m_PlaceHolderLabel);
	54
	55	m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
	56	m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	57	layout->addWidget(m_PlaceBackground);
	58
	59	sqpApp->installEventFilter(m_DragDropScroller.get());
	60	sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
	61
	62	m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
	63	}
	64
	65	void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
	66	{
	67	if (m_CurrentDragWidget) {
	68	m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
	69	m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
	70	}
	71	else {
	72	// Configuration of the placeHolder when there is no dragWidget
	73	// (for instance with a drag from a variable)
	74
	75	m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
	76	m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	77	}
	78
	79	switch (type) {
	80	case DragDropHelper::PlaceHolderType::Graph:
	81	m_PlaceBackground->setStyleSheet(
	82	"background-color: #BBD5EE; border: 1px solid #2A7FD4");
	83	break;
	84	case DragDropHelper::PlaceHolderType::Zone:
	85	case DragDropHelper::PlaceHolderType::Default:
	86	m_PlaceBackground->setStyleSheet(
	87	"background-color: #BBD5EE; border: 2px solid #2A7FD4");
	88	m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
	89	break;
	90	}
	91
	92	m_PlaceHolderLabel->setText(topLabelText);
	93	m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
	94	}
	95	};
	96
	97
	98	DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
	99
	100	DragDropHelper::~DragDropHelper()
	101	{
	102	QFile::remove(impl->m_ImageTempUrl);
	103	}
	104
	105	void DragDropHelper::resetDragAndDrop()
	106	{
	107	setCurrentDragWidget(nullptr);
	108	impl->m_HighlightedDragWidget = nullptr;
	109	}
	110
	111	void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
	112	{
	113	if (impl->m_CurrentDragWidget) {
	114
	115	QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
	116	}
	117
	118	if (dragWidget) {
	119	// ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
	120	impl->m_DragWidgetDestroyedConnection
	121	= QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
	122	[this]() { impl->m_CurrentDragWidget = nullptr; });
	123	}
	124
	125	impl->m_CurrentDragWidget = dragWidget;
	126	}
	127
	128	VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
	129	{
	130	return impl->m_CurrentDragWidget;
	131	}
	132
	133	QWidget &DragDropHelper::placeHolder() const
	134	{
	135	return *impl->m_PlaceHolder;
	136	}
	137
	138	void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
	139	const QString &topLabelText)
	140	{
	141	removePlaceHolder();
	142	impl->preparePlaceHolder(type, topLabelText);
	143	layout->insertWidget(index, impl->m_PlaceHolder.get());
	144	impl->m_PlaceHolder->show();
	145	}
	146
	147	void DragDropHelper::removePlaceHolder()
	148	{
	149	auto parentWidget = impl->m_PlaceHolder->parentWidget();
	150	if (parentWidget) {
	151	parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
	152	impl->m_PlaceHolder->setParent(nullptr);
	153	impl->m_PlaceHolder->hide();
	154	}
	155	}
	156
	157	bool DragDropHelper::isPlaceHolderSet() const
	158	{
	159	return impl->m_PlaceHolder->parentWidget();
	160	}
	161
	162	void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
	163	{
	164	impl->m_DragDropScroller->addScrollArea(scrollArea);
	165	}
	166
	167	void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
	168	{
	169	impl->m_DragDropScroller->removeScrollArea(scrollArea);
	170	}
	171
	172	void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
	173	{
	174	impl->m_DragDropTabSwitcher->addTabBar(tabBar);
	175	}
	176
	177	void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
	178	{
	179	impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
	180	}
	181
	182	QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
	183	{
	184	image.save(impl->m_ImageTempUrl);
	185	return QUrl::fromLocalFile(impl->m_ImageTempUrl);
	186	}
	187
	188	void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
	189	{
	190	if (impl->m_HighlightedDragWidget) {
	191	impl->m_HighlightedDragWidget->highlightForMerge(false);
	192	QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
	193	}
	194
	195	if (dragWidget) {
	196	dragWidget->highlightForMerge(true);
	197
	198	// ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
	199	impl->m_DragWidgetDestroyedConnection
	200	= QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
	201	[this]() { impl->m_HighlightedDragWidget = nullptr; });
	202	}
	203
	204	impl->m_HighlightedDragWidget = dragWidget;
	205	}
	206
	207	VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
	208	{
	209	return impl->m_HighlightedDragWidget;
	210	}
	211
	212	bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
	213	VisualizationDragDropContainer *dropContainer)
	214	{
	215	if (!mimeData \|\| !dropContainer) {
	216	qCWarning(LOG_DragDropHelper()) << QObject::tr(
	217	"DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
	218	Q_ASSERT(false);
	219	return false;
	220	}
	221
	222	auto result = false;
	223
	224	if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
	225	auto variables = sqpApp->variableController().variablesForMimeData(
	226	mimeData->data(MIME_TYPE_VARIABLE_LIST));
	227
	228	if (variables.count() == 1) {
	229
	230	auto variable = variables.first();
	231	if (variable->dataSeries() != nullptr) {
	232
	233	// Check that the variable is not already in a graph
	234
	235	auto parent = dropContainer->parentWidget();
	236	while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
	237	parent = parent->parentWidget(); // Search for the top level VisualizationWidget
	238	}
	239
	240	if (parent) {
	241	auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
	242
	243	FindVariableOperation findVariableOperation{variable};
	244	visualizationWidget->accept(&findVariableOperation);
	245	auto variableContainers = findVariableOperation.result();
	246	if (variableContainers.empty()) {
	247	result = true;
	248	}
	249	else {
	250	// result = false: the variable already exist in the visualisation
	251	}
	252	}
	253	else {
	254	qCWarning(LOG_DragDropHelper()) << QObject::tr(
	255	"DragDropHelper::checkMimeDataForVisualization, the parent "
	256	"VisualizationWidget cannot be found. Cannot check if the variable is "
	257	"already used or not.");
	258	}
	259	}
	260	else {
	261	// result = false: the variable is not fully loaded
	262	}
	263	}
	264	else {
	265	// result = false: cannot drop multiple variables in the visualisation
	266	}
	267	}
	268	else {
	269	// Other MIME data
	270	// no special rules, accepted by default
	271	result = true;
	272	}
	273
	274	return result;
	275	}

gui/src/DragAndDrop/DragDropTabSwitcher.cpp created 644 +180 0

@@ -0,0 +1,180
	1	#include "DragAndDrop/DragDropTabSwitcher.h"
	2
	3	#include <QAbstractButton>
	4	#include <QDragEnterEvent>
	5	#include <QDragMoveEvent>
	6	#include <QTimer>
	7
	8	#include "SqpApplication.h"
	9
	10	Q_LOGGING_CATEGORY(LOG_DragDropTabSwitcher, "DragDropTabSwitcher")
	11
	12	const int CHANGE_TAB_INTERVAL = 400; // time necessary over a tab to accept the switch
	13	const int SCROLL_BUTTON_AUTO_CLICK_INTERVAL
	14	= 500; // time between 2 auto clicks on a scroll button of the tab bar
	15
	16	struct DragDropTabSwitcher::DragDropTabSwitcherPrivate {
	17
	18	QList<QTabBar *> m_TabBarList;
	19	QTabBar *m_CurrentTabBar = nullptr;
	20
	21	int m_HoveredTabIndex = -1;
	22	std::unique_ptr<QTimer> m_TabSwitchTimer = nullptr;
	23
	24	QAbstractButton *m_HoveredScrollButton = nullptr;
	25	std::unique_ptr<QTimer> m_ScrollButtonsTimer = nullptr;
	26
	27	explicit DragDropTabSwitcherPrivate()
	28	: m_TabSwitchTimer{std::make_unique<QTimer>()},
	29	m_ScrollButtonsTimer{std::make_unique<QTimer>()}
	30	{
	31	m_TabSwitchTimer->setSingleShot(true);
	32	m_TabSwitchTimer->setInterval(CHANGE_TAB_INTERVAL);
	33	QObject::connect(m_TabSwitchTimer.get(), &QTimer::timeout, [this]() {
	34	if (m_CurrentTabBar) {
	35	m_CurrentTabBar->setCurrentIndex(m_HoveredTabIndex);
	36	}
	37	else {
	38	qCWarning(LOG_DragDropTabSwitcher()) << "DragDropTabSwitcherPrivate::timeout: "
	39	"Cannot select a new tab: unknown current "
	40	"tab bar.";
	41	}
	42	});
	43
	44	m_ScrollButtonsTimer->setInterval(SCROLL_BUTTON_AUTO_CLICK_INTERVAL);
	45	QObject::connect(m_ScrollButtonsTimer.get(), &QTimer::timeout, [this]() {
	46	if (m_HoveredScrollButton) {
	47	m_HoveredScrollButton->animateClick();
	48	}
	49	else {
	50	qCWarning(LOG_DragDropTabSwitcher())
	51	<< "DragDropTabSwitcherPrivate::timeoutScroll: "
	52	"Unknown scroll button";
	53	}
	54	});
	55	}
	56
	57	bool isScrollTabButton(QAbstractButton button, QTabBar tabBar)
	58	{
	59	auto isNextOrPreviousTabButton = true;
	60
	61	if (tabBar->isAncestorOf(button)) {
	62	for (auto i = 0; i < tabBar->count(); ++i) {
	63	if (tabBar->tabButton(i, QTabBar::RightSide) == button
	64	\|\| tabBar->tabButton(i, QTabBar::LeftSide) == button) {
	65	isNextOrPreviousTabButton = false;
	66	break;
	67	}
	68	}
	69	}
	70	else {
	71	isNextOrPreviousTabButton = false;
	72	}
	73
	74	return isNextOrPreviousTabButton;
	75	}
	76
	77	QAbstractButton tabScrollButtonAt(const QPoint &pos, QTabBar tabBar)
	78	{
	79
	80	auto globalPos = tabBar->mapToGlobal(pos);
	81
	82	auto widgetUnderMouse = sqpApp->widgetAt(globalPos);
	83	if (auto btn = qobject_cast<QAbstractButton *>(widgetUnderMouse)) {
	84
	85	if (isScrollTabButton(btn, tabBar)) {
	86	return btn;
	87	}
	88	}
	89
	90	return nullptr;
	91	}
	92	};
	93
	94	DragDropTabSwitcher::DragDropTabSwitcher(QObject *parent)
	95	: QObject(parent), impl{spimpl::make_unique_impl<DragDropTabSwitcherPrivate>()}
	96	{
	97	}
	98
	99	void DragDropTabSwitcher::addTabBar(QTabBar *tabBar)
	100	{
	101	impl->m_TabBarList << tabBar;
	102	tabBar->setAcceptDrops(true);
	103	}
	104
	105	void DragDropTabSwitcher::removeTabBar(QTabBar *tabBar)
	106	{
	107	impl->m_TabBarList.removeAll(tabBar);
	108	tabBar->setAcceptDrops(false);
	109	}
	110
	111	bool DragDropTabSwitcher::eventFilter(QObject obj, QEvent event)
	112	{
	113	if (event->type() == QEvent::DragMove) {
	114
	115	if (impl->m_CurrentTabBar) {
	116
	117	QWidget w = static_cast<QWidget >(obj);
	118	if (!impl->m_CurrentTabBar->isAncestorOf(w)) {
	119	return false;
	120	}
	121
	122	auto moveEvent = static_cast<QDragMoveEvent *>(event);
	123
	124	auto scrollButton = impl->tabScrollButtonAt(moveEvent->pos(), impl->m_CurrentTabBar);
	125
	126	if (!scrollButton) {
	127
	128	auto tabIndex = impl->m_CurrentTabBar->tabAt(moveEvent->pos());
	129	if (tabIndex >= 0 && tabIndex != impl->m_CurrentTabBar->currentIndex()) {
	130	// The mouse is over an unselected tab
	131	if (!impl->m_TabSwitchTimer->isActive()
	132	\|\| tabIndex != impl->m_HoveredTabIndex) {
	133	impl->m_HoveredTabIndex = tabIndex;
	134	impl->m_TabSwitchTimer->start();
	135	}
	136	else {
	137	// do nothing, timer already running
	138	}
	139	}
	140	else {
	141	impl->m_TabSwitchTimer->stop();
	142	}
	143
	144	impl->m_ScrollButtonsTimer->stop();
	145	}
	146	else {
	147	// The mouse is over a scroll button
	148	// click it in a loop with a timer
	149	if (!impl->m_ScrollButtonsTimer->isActive()
	150	\|\| impl->m_HoveredScrollButton != scrollButton) {
	151	impl->m_HoveredScrollButton = scrollButton;
	152	impl->m_ScrollButtonsTimer->start();
	153	}
	154	}
	155	}
	156	}
	157	else if (event->type() == QEvent::DragEnter) {
	158	QWidget w = static_cast<QWidget >(obj);
	159
	160	for (auto tabBar : impl->m_TabBarList) {
	161	if (w == tabBar) {
	162	auto enterEvent = static_cast<QDragEnterEvent *>(event);
	163	enterEvent->acceptProposedAction();
	164	enterEvent->setDropAction(Qt::IgnoreAction);
	165	impl->m_CurrentTabBar = tabBar;
	166	break;
	167	}
	168	}
	169	}
	170	else if (event->type() == QEvent::DragLeave \|\| event->type() == QEvent::Drop) {
	171	if (impl->m_CurrentTabBar) {
	172	impl->m_HoveredTabIndex = -1;
	173	impl->m_TabSwitchTimer->stop();
	174	impl->m_CurrentTabBar = nullptr;
	175	impl->m_ScrollButtonsTimer->stop();
	176	}
	177	}
	178
	179	return false;
	180	}

gui/src/Variable/VariableInspectorTableView.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "Variable/VariableInspectorTableView.h"
	2
	3	#include "DragAndDrop/DragDropHelper.h"
	4	#include "SqpApplication.h"
	5
	6	VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent) {}
	7
	8	void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
	9	{
	10	// Resets the drag&drop operations before it's starting
	11	sqpApp->dragDropHelper().resetDragAndDrop();
	12	QTableView::startDrag(supportedActions);
	13	}

core/include/DataSource/DataSourceController.h +5 -2

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
             class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
             class SCIQLOP_CORE_EXPORT DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataSourceItem the structure of the data source. It must be not null to be registered
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
                 /**
                  * Sets the data provider used to retrieve data from of a data source. The controller takes
                  * ownership of the provider.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataProvider the provider of the data source
                  * @sa registerDataSource()
                  */
                 void setDataProvider(const QUuid &dataSourceUid,
                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
                 /**
                  * Loads an item (product) as a variable in SciQlop
                  * @param dataSourceUid the unique id of the data source containing the item. It is used to get
                  * the data provider associated to the data source, and pass it to for the variable creation
                  * @param productItem the item to load
                  */
                 void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
-                QByteArray mimeDataForProductsData(const QVariantList &productsData) const;
+                /// Returns the MIME data associated to a list of product meta data
-                QVariantList productsDataForMimeData(const QByteArray &mimeData) const;
+                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
                 void initialize();
                 void finalize();
                 void requestVariable(const QVariantHash &productData);
             signals:
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(DataSourceItem *dataSourceItem);
                 /**
                  * Signal emitted when a variable creation is asked for a product
                  * @param variableName the name of the variable
                  * @param variableMetadata the metadata of the variable
                  * @param variableProvider the provider that will be used to retrieve the data of the variable
                  * (can be null)
                  */
                 void variableCreationRequested(const QString &variableName,
                                                const QVariantHash &variableMetadata,
                                                std::shared_ptr<IDataProvider> variableProvider);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/include/Time/TimeController.h +6 0

             #ifndef SCIQLOP_TIMECONTROLLER_H
             #define SCIQLOP_TIMECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
             /**
              * @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT TimeController : public QObject {
                 Q_OBJECT
             public:
                 explicit TimeController(QObject *parent = 0);
                 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);
             public slots:
                 /// Slot called when a new dateTime has been defined.
                 void onTimeToUpdate(SqpRange dateTime);
                 /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                 void onTimeNotify();
             private:
                 class TimeControllerPrivate;
                 spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
             };
             #endif // SCIQLOP_TIMECONTROLLER_H

core/include/Variable/VariableController.h +3 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/AcquisitionDataPacket.h>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * Possible types of zoom operation
              */
             enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
                 /**
                  * Clones the variable passed in parameter and adds the duplicate to the controller
                  * @param variable the variable to duplicate
                  * @return the duplicate created, nullptr if the variable couldn't be created
                  */
                 std::shared_ptr<Variable> cloneVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variable passed in parameter.
                  *
                  * Delete a variable includes:
                  * - the deletion of the various references to the variable in SciQlop
                  * - the deletion of the model variable
                  * - the deletion of the provider associated with the variable
                  * - removing the cache associated with the variable
                  *
                  * @param variable the variable to delete from the controller.
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variables passed in parameter.
                  * @param variables the variables to delete from the controller.
                  * @sa deleteVariable()
                  */
                 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);
             signals:
                 /// Signal emitted when a variable is about to be deleted from the controller
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
                 /// Signal emitted when a sub range of the cacheRange of the variable can be displayed
                 void updateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
             public slots:
                 /// Request the data loading of the variable whithin range
                 void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
                                           bool synchronise);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param metadata the metadata of the new variable
                  * @param provider the data provider for the new variable
                  * @return the pointer to the new variable or nullptr if the creation failed
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
                                                          std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpRange &dateTime);
                 void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                     const SqpRange &cacheRangeRequested,
                                     QVector<AcquisitionDataPacket> dataAcquired);
                 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
                 /// Cancel the current request for the variable
                 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
                 void onAbortAcquisitionRequested(QUuid vIdentifier);
                 // synchronization group methods
                 void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
                 void onRemoveSynchronizationGroupId(QUuid synchronizationGroupId);
                 void onAddSynchronized(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
                 /// Desynchronizes the variable of the group whose identifier is passed in parameter
                 /// @remarks the method does nothing if the variable is not part of the group
                 void desynchronize(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/meson.build 0 -2

             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',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableCacheStrategy.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
               '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',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/DataSource/DataSourceController.cpp +3 -3

             #include "DataSource/DataSourceController.h"
             #include "DataSource/DataSourceItem.h"
             #include <Data/IDataProvider.h>
             #include <QMutex>
             #include <QThread>
             #include <QDataStream>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             namespace {
             /**
              * Builds the metadata of the variable that will be generated from the loading of an item
              * @param dataSourceItem the data source item from which to generate the metadata
              * @return the metadata of the variable
              */
             QVariantHash variableMetadata(const DataSourceItem &dataSourceItem)
             {
                 // Variable metadata contains...
                 // ... all metadata of the item
                 auto result = dataSourceItem.data();
                 // ... and the name of the plugin, recovered from root item
                 result.insert(QStringLiteral("plugin"), dataSourceItem.rootItem().name());
                 return result;
             }
             } // namespace
             class DataSourceController::DataSourceControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 /// Data sources registered
                 QHash<QUuid, QString> m_DataSources;
                 /// Data sources structures
                 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
                 /// Data providers registered
                 /// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
                 /// continue to live without necessarily the data source controller
                 std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
                 // Search for the first datasource item matching the specified data
                 DataSourceItem *findDataSourceItem(const QVariantHash &data)
                 {
                     DataSourceItem *sourceItem = nullptr;
                     for (const auto &item : m_DataSourceItems) {
                         sourceItem = item.second->findItem(data, true);
                         if (sourceItem) {
                             break;
                         }
                     }
                     return sourceItem;
                 }
             };
             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
                                                     << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
                                                     << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
             {
                 auto dataSourceUid = QUuid::createUuid();
                 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
                 return dataSourceUid;
             }
             void DataSourceController::setDataSourceItem(
                 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
                 if (!dataSourceItem) {
                     qCWarning(LOG_DataSourceController())
                         << tr("Data source item can't be registered (null item)");
                     return;
                 }
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     // The data provider is implicitly converted to a shared_ptr
                     impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                     // Retrieves the data source item to emit the signal with it
                     auto it = impl->m_DataSourceItems.find(dataSourceUid);
                     if (it != impl->m_DataSourceItems.end()) {
                         emit dataSourceItemSet(it->second.get());
                     }
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
                                                                 "data source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
             void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
                                                        std::unique_ptr<IDataProvider> dataProvider) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
                                                                 "source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
             void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
                                                        const DataSourceItem &productItem) noexcept
             {
                 if (productItem.type() == DataSourceItemType::PRODUCT
                     || productItem.type() == DataSourceItemType::COMPONENT) {
                     /// Retrieves the data provider of the data source (if any)
                     auto it = impl->m_DataProviders.find(dataSourceUid);
                     auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
                     emit variableCreationRequested(productItem.name(), variableMetadata(productItem),
                                                    dataProvider);
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
                 }
             }
-            QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData) const
+            QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData)
             {
                 QByteArray encodedData;
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << productsData;
                 return encodedData;
             }
-            QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData) const
+            QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData)
             {
                 QDataStream stream{mimeData};
                 QVariantList productList;
                 stream >> productList;
                 return productList;
             }
             void DataSourceController::initialize()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
                                                     << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::requestVariable(const QVariantHash &productData)
             {
-                DataSourceItem *sourceItem = impl->findDataSourceItem(productData);
+                auto sourceItem = impl->findDataSourceItem(productData);
                 if (sourceItem) {
                     auto sourceName = sourceItem->rootItem().name();
                     auto sourceId = impl->m_DataSources.key(sourceName);
                     loadProductItem(sourceId, *sourceItem);
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("requestVariable, product data not found");
                 }
             }
             void DataSourceController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/DataSource/DataSourceItem.cpp +1 -2

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
             const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVariantHash data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QVariantHash m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
                     : DataSourceItem{type, QVariantHash{{NAME_DATA_KEY, name}}}
             {
             }
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 auto result = QVector<DataSourceItemAction *>{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(const QString &key) const noexcept
             {
                 return impl->m_Data.value(key);
             }
             QVariantHash DataSourceItem::data() const noexcept
             {
                 return impl->m_Data;
             }
             bool DataSourceItem::isRoot() const noexcept
             {
                 return impl->m_Parent == nullptr;
             }
             QString DataSourceItem::name() const noexcept
             {
                 return data(NAME_DATA_KEY).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             const DataSourceItem &DataSourceItem::rootItem() const noexcept
             {
                 return isRoot() ? *this : parentItem()->rootItem();
             }
             void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
             {
                 auto it = impl->m_Data.constFind(key);
                 if (append && it != impl->m_Data.constEnd()) {
                     // Case of an existing value to which we want to add to the new value
                     if (it->canConvert<QVariantList>()) {
                         auto variantList = it->value<QVariantList>();
                         variantList.append(value);
                         impl->m_Data.insert(key, variantList);
                     }
                     else {
                         impl->m_Data.insert(key, QVariantList{*it, value});
                     }
                 }
                 else {
                     // Other cases :
                     // - new value in map OR
                     // - replacement of an existing value (not appending)
                     impl->m_Data.insert(key, value);
                 }
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }
             DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursive)
             {
                 for (const auto &child : impl->m_Children) {
                     if (child->impl->m_Data == data) {
                         return child.get();
                     }
                     if (recursive) {
-                        auto foundItem = child->findItem(data, true);
+                        if (auto foundItem = child->findItem(data, true)) {
-                        if (foundItem) {
                             return foundItem;
                         }
                     }
                 }
                 return nullptr;
             }
             bool DataSourceItem::operator==(const DataSourceItem &other)
             {
                 // Compares items' attributes
                 if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
                     // Compares contents of items' children
                     return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
                                       std::cbegin(other.impl->m_Children),
                                       [](const auto &itemChild, const auto &otherChild) {
                                           return *itemChild == *otherChild;
                                       });
                 }
                 else {
                     return false;
                 }
             }
             bool DataSourceItem::operator!=(const DataSourceItem &other)
             {
                 return !(*this == other);
             }

core/src/Time/TimeController.cpp +22 0

             #include "Time/TimeController.h"
+            #include <QDataStream>
             Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
             struct TimeController::TimeControllerPrivate {
                 SqpRange m_DateTime;
             };
             TimeController::TimeController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<TimeControllerPrivate>()}
             {
                 qCDebug(LOG_TimeController()) << tr("TimeController construction");
             }
             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;
             }
             void TimeController::onTimeNotify()
             {
                 emit timeUpdated(impl->m_DateTime);
             }

core/src/Variable/VariableModel.cpp +23 -8

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

core/tests/meson.build +9 -1

             tests = [
               [['Common/TestStringUtils.cpp'],'test_string_utils','StringUtils test'],
               [['Data/TestScalarSeries.cpp'],'test_scalar','ScalarSeries test'],
               [['Data/TestSpectrogramSeries.cpp'],'test_spectrogram','SpectrogramSeries test'],
               [['Data/TestVectorSeries.cpp'],'test_vector','VectorSeries test'],
               [['Data/TestOneDimArrayData.cpp'],'test_1d','One Dim Array test'],
               [['Data/TestOptionalAxis.cpp'],'test_optional_axis','OptionalAxis test'],
               [['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
               [['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
               [['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
               [['Variable/TestVariable.cpp'],'test_variable','Variable test'],
               [['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

gui/include/DataSource/DataSourceTreeWidget.h +1 0

             #ifndef SCIQLOP_DATASOURCETREEWIDGET_H
             #define SCIQLOP_DATASOURCETREEWIDGET_H
             #include <QTreeWidget>
             class DataSourceTreeWidget : public QTreeWidget {
             public:
                 DataSourceTreeWidget(QWidget *parent);
             protected:
                 QMimeData *mimeData(const QList<QTreeWidgetItem *> items) const override;
+                void startDrag(Qt::DropActions supportedActions) override;
             };
             #endif // SCIQLOP_DATASOURCETREEWIDGET_H

gui/include/DragAndDrop/DragDropHelper.h ~~gui/include/DragDropHelper.h~~ renamed +11 -25

             #ifndef SCIQLOP_DRAGDROPHELPER_H
             #define SCIQLOP_DRAGDROPHELPER_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class QVBoxLayout;
             class QScrollArea;
+            class QTabBar;
             class VisualizationDragWidget;
             class VisualizationDragDropContainer;
             class QMimeData;
             Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
             /**
              * @brief Helper class for drag&drop operations.
              * @note The helper is accessible from the sqpApp singleton and  has the same life as the whole
              * application (like a controller). But contrary to a controller, it doesn't live in a thread and
              * can interect with the gui.
              * @see SqpApplication
              */
             class DragDropHelper {
             public:
                 static const QString MIME_TYPE_GRAPH;
                 static const QString MIME_TYPE_ZONE;
+                enum class PlaceHolderType { Default, Graph, Zone };
                 DragDropHelper();
                 virtual ~DragDropHelper();
                 /// Resets some internal variables. Must be called before any new drag&drop operation.
                 void resetDragAndDrop();
                 /// Sets the visualization widget currently being drag on the visualization.
                 void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
                 /// Returns the visualization widget currently being drag on the visualization.
                 /// Can be null if a new visualization widget is intended to be created by the drag&drop
                 /// operation.
                 VisualizationDragWidget *getCurrentDragWidget() const;
                 QWidget &placeHolder() const;
-                void insertPlaceHolder(QVBoxLayout *layout, int index);
+                void insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+                                       const QString &topLabelText);
                 void removePlaceHolder();
                 bool isPlaceHolderSet() const;
                 /// Checks if the specified mime data is valid for a drop in the visualization
                 bool checkMimeDataForVisualization(const QMimeData *mimeData,
                                                    VisualizationDragDropContainer *dropContainer);
                 void addDragDropScrollArea(QScrollArea *scrollArea);
                 void removeDragDropScrollArea(QScrollArea *scrollArea);
+                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

gui/include/TimeWidget/TimeWidget.h +15 0

             #ifndef SCIQLOP_TIMEWIDGET_H
             #define SCIQLOP_TIMEWIDGET_H
             #include <QWidget>
             #include <Data/SqpRange.h>
+            #include <Common/spimpl.h>
             namespace Ui {
             class TimeWidget;
             } // Ui
             class TimeWidget : public QWidget {
                 Q_OBJECT
             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);
             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

gui/include/Visualization/VisualizationDragDropContainer.h +11 -5

             #ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
             #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);
                 void addDragWidget(VisualizationDragWidget *dragWidget);
                 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
-                void setAcceptedMimeTypes(const QStringList &mimeTypes);
+                void addAcceptedMimeType(const QString &mimeType, DropBehavior behavior);
-                void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
                 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);
                 void dragMoveEvent(QDragMoveEvent *event);
                 void dropEvent(QDropEvent *event);
             private:
                 class VisualizationDragDropContainerPrivate;
                 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
             private slots:
                 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
             };
             #endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H

gui/include/Visualization/VisualizationDragWidget.h +1 0

             #ifndef SCIQLOP_VISUALIZATIONDRAGWIDGET_H
             #define SCIQLOP_VISUALIZATIONDRAGWIDGET_H
             #include <Common/spimpl.h>
             #include <QMimeData>
             #include <QWidget>
             class VisualizationDragWidget : public QWidget {
                 Q_OBJECT
             public:
                 VisualizationDragWidget(QWidget *parent = nullptr);
                 virtual QMimeData *mimeData() const = 0;
                 virtual bool isDragAllowed() const = 0;
+                virtual void highlightForMerge(bool highlighted) { Q_UNUSED(highlighted); };
             protected:
                 virtual void mousePressEvent(QMouseEvent *event) override;
                 virtual void mouseMoveEvent(QMouseEvent *event) override;
             private:
                 class VisualizationDragWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
             signals:
                 void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
             };
             #endif // SCIQLOP_VISUALIZATIONDRAGWIDGET_H

gui/include/Visualization/VisualizationGraphWidget.h +1 0

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class QCustomPlot;
             class SqpRange;
             class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 friend class VisualizationGraphRenderingDelegate;
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 VisualizationZoneWidget *parentZoneWidget() const noexcept;
                 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
                 void enableAcquisition(bool enable);
                 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// Returns the list of all variables used in the graph
                 QList<std::shared_ptr<Variable> > variables() const;
                 void setYRange(const SqpRange &range);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData() const override;
                 bool isDragAllowed() const override;
+                void highlightForMerge(bool highlighted) override;
             signals:
                 void synchronize(const SqpRange &range, const SqpRange &oldRange);
                 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
                                         bool synchronise);
                 /// Signal emitted when the variable is about to be removed from the graph
                 void variableAboutToBeRemoved(std::shared_ptr<Variable> var);
                 /// Signal emitted when the variable has been added to the graph
                 void variableAdded(std::shared_ptr<Variable> var);
             protected:
                 void closeEvent(QCloseEvent *event) override;
                 void enterEvent(QEvent *event) override;
                 void leaveEvent(QEvent *event) override;
                 QCustomPlot &plot() noexcept;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 /// Rescale the X axe to range parameter
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse move was made
                 void onMouseMove(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 /// Slot called when a mouse press was made, to activate the calibration of a graph
                 void onMousePress(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                 void onMouseRelease(QMouseEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
                 void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +1 0

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // namespace Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /// Inserts a graph widget
                 void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variable the variable for which to create the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
                 /**
                  * Creates a graph using a list of variables. The variables will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variables List of variables to be added to the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
                                                       int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData() const override;
                 bool isDragAllowed() const override;
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 Ui::VisualizationZoneWidget *ui;
                 class VisualizationZoneWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             private slots:
                 void onVariableAdded(std::shared_ptr<Variable> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
                 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
                 void dropMimeData(int index, const QMimeData *mimeData);
+                void dropMimeDataOnGraph(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/meson.build +10 -2

             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',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             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',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/DataSource/DataSourceTreeWidget.cpp +8 0

             #include "DataSource/DataSourceTreeWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "DataSource/DataSourceController.h"
             #include "DataSource/DataSourceItem.h"
             #include "DataSource/DataSourceTreeWidgetItem.h"
+            #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             #include <QMimeData>
             DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) {}
             QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) const
             {
                 auto mimeData = new QMimeData;
                 // Basic check to ensure the item are correctly typed
                 Q_ASSERT(items.isEmpty() || dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr);
                 QVariantList productData;
                 for (auto item : items) {
                     auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item);
                     auto dataSource = dataSourceTreeItem->data();
                     if (dataSource->type() == DataSourceItemType::COMPONENT
                         || dataSource->type() == DataSourceItemType::PRODUCT) {
                         auto metaData = dataSource->data();
                         productData << metaData;
                     }
                 }
                 auto encodedData = sqpApp->dataSourceController().mimeDataForProductsData(productData);
                 mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData);
                 return mimeData;
             }
+            void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions)
+            {
+                // Resets the drag&drop operations before it's starting
+                sqpApp->dragDropHelper().resetDragAndDrop();
+                QTreeWidget::startDrag(supportedActions);
+            }

gui/src/DragAndDrop/DragDropScroller.cpp ~~gui/src/DragDropHelper.cpp~~ renamed +1 -171

-            #include "DragDropHelper.h"
+            #include "DragAndDrop/DragDropScroller.h"
-            #include "SqpApplication.h"
-            #include "Visualization/VisualizationDragDropContainer.h"
-            #include "Visualization/VisualizationDragWidget.h"
-            #include "Visualization/VisualizationWidget.h"
-            #include "Visualization/operations/FindVariableOperation.h"
-            #include "Variable/VariableController.h"
-            #include "Common/MimeTypesDef.h"
-            #include "Common/VisualizationDef.h"
-            #include <QDir>
             #include <QDragEnterEvent>
             #include <QDragMoveEvent>
-            #include <QScrollArea>
             #include <QScrollBar>
             #include <QTimer>
-            #include <QVBoxLayout>
             const int SCROLL_SPEED = 5;
             const int SCROLL_ZONE_SIZE = 50;
-            Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
             struct DragDropScroller::DragDropScrollerPrivate {
                 QList<QScrollArea *> m_ScrollAreas;
                 QScrollArea *m_CurrentScrollArea = nullptr;
                 std::unique_ptr<QTimer> m_Timer = nullptr;
                 enum class ScrollDirection { up, down, unknown };
                 ScrollDirection m_Direction = ScrollDirection::unknown;
                 explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
                 {
                     m_Timer->setInterval(0);
                 }
             };
             DragDropScroller::DragDropScroller(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
             {
                 connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
             }
             void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_ScrollAreas << scrollArea;
                 scrollArea->viewport()->setAcceptDrops(true);
             }
             void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_ScrollAreas.removeAll(scrollArea);
                 scrollArea->viewport()->setAcceptDrops(false);
             }
             bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
             {
                 if (event->type() == QEvent::DragMove) {
                     auto w = static_cast<QWidget *>(obj);
                     if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
                         auto moveEvent = static_cast<QDragMoveEvent *>(event);
                         auto pos = moveEvent->pos();
                         if (impl->m_CurrentScrollArea->viewport() != w) {
                             auto globalPos = w->mapToGlobal(moveEvent->pos());
                             pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
                         }
                         auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
                                                          - SCROLL_ZONE_SIZE;
                         auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
                         if (!isInTopZone && !isInBottomZone) {
                             impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                             impl->m_Timer->stop();
                         }
                         else if (!impl->m_Timer->isActive()) {
                             impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
                                                             : DragDropScrollerPrivate::ScrollDirection::down;
                             impl->m_Timer->start();
                         }
                     }
                 }
                 else if (event->type() == QEvent::DragEnter) {
                     auto w = static_cast<QWidget *>(obj);
                     for (auto scrollArea : impl->m_ScrollAreas) {
                         if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
                             auto enterEvent = static_cast<QDragEnterEvent *>(event);
                             enterEvent->acceptProposedAction();
                             enterEvent->setDropAction(Qt::IgnoreAction);
                             impl->m_CurrentScrollArea = scrollArea;
                             break;
                         }
                     }
                 }
                 else if (event->type() == QEvent::DragLeave) {
                     if (impl->m_CurrentScrollArea) {
                         if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
                                  .contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
                             impl->m_CurrentScrollArea = nullptr;
                             impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                             impl->m_Timer->stop();
                         }
                     }
                 }
                 else if (event->type() == QEvent::Drop) {
                     if (impl->m_CurrentScrollArea) {
                         impl->m_CurrentScrollArea = nullptr;
                         impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                         impl->m_Timer->stop();
                     }
                 }
                 return false;
             }
             void DragDropScroller::onTimer()
             {
                 if (impl->m_CurrentScrollArea) {
                     auto mvt = 0;
                     switch (impl->m_Direction) {
                         case DragDropScrollerPrivate::ScrollDirection::up:
                             mvt = SCROLL_SPEED;
                             break;
                         case DragDropScrollerPrivate::ScrollDirection::down:
                             mvt = -SCROLL_SPEED;
                             break;
                         default:
                             break;
                     }
                     impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
                         impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
                 }
             }
-            struct DragDropHelper::DragDropHelperPrivate {
-                VisualizationDragWidget *m_CurrentDragWidget = nullptr;
-                std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
-                std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
-                QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
-                                        // QTemporaryFile to have a name which is not generated.
-                explicit DragDropHelperPrivate()
-                        : m_PlaceHolder{std::make_unique<QWidget>()},
-                          m_DragDropScroller{std::make_unique<DragDropScroller>()}
-                    m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
-                    sqpApp->installEventFilter(m_DragDropScroller.get());
-                    m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
-                void preparePlaceHolder() const
-                    if (m_CurrentDragWidget) {
-                        m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
-                        m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
-                    else {
-                        // 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;

gui/src/SqpApplication.cpp +1 -1

             #include "SqpApplication.h"
             #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>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
                           m_DragDropHelper{std::make_unique<DragDropHelper>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
                 std::unique_ptr<DragDropHelper> m_DragDropHelper;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }
             DragDropHelper &SqpApplication::dragDropHelper() noexcept
             {
                 return *impl->m_DragDropHelper;
             }

gui/src/TimeWidget/TimeWidget.cpp +109 -3

@@ -1,50 +1,156
1	#include "TimeWidget/TimeWidget.h"	1	#include "TimeWidget/TimeWidget.h"
2	#include "ui_TimeWidget.h"	2	#include "ui_TimeWidget.h"
3		3
4	#include <Common/DateUtils.h>	4	#include <Common/DateUtils.h>
		5	#include <Common/MimeTypesDef.h>
		6
		7	#include <DragAndDrop/DragDropHelper.h>
5	#include <SqpApplication.h>	8	#include <SqpApplication.h>
6	#include <Time/TimeController.h>	9	#include <Time/TimeController.h>
7		10
8	TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}	11	#include <QDrag>
		12	#include <QDragEnterEvent>
		13	#include <QDropEvent>
		14	#include <QMimeData>
		15
		16
		17	struct TimeWidget::TimeWidgetPrivate {
		18
		19	explicit TimeWidgetPrivate() {}
		20
		21	QPoint m_DragStartPosition;
		22	};
		23
		24	TimeWidget::TimeWidget(QWidget *parent)
		25	: QWidget{parent},
		26	ui{new Ui::TimeWidget},
		27	impl{spimpl::make_unique_impl<TimeWidgetPrivate>()}
9	{	28	{
10	ui->setupUi(this);	29	ui->setupUi(this);
11		30
12	ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));	31	ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));
13		32
14	// Connection	33	// Connection
15	connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,	34	connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
16	&TimeWidget::onTimeUpdateRequested);	35	&TimeWidget::onTimeUpdateRequested);
17		36
18	connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,	37	connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
19	&TimeWidget::onTimeUpdateRequested);	38	&TimeWidget::onTimeUpdateRequested);
20		39
21		40
22	connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),	41	connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),
23	&TimeController::onTimeNotify);	42	&TimeController::onTimeNotify);
24		43
25	// Initialisation	44	// Initialisation
26	auto endDateTime = QDateTime::currentDateTimeUtc();	45	auto endDateTime = QDateTime::currentDateTimeUtc();
27	auto startDateTime = endDateTime.addSecs(-3600); // one hour before	46	auto startDateTime = endDateTime.addSecs(-3600); // one hour before
28		47
29	ui->startDateTimeEdit->setDateTime(startDateTime);	48	ui->startDateTimeEdit->setDateTime(startDateTime);
30	ui->endDateTimeEdit->setDateTime(endDateTime);	49	ui->endDateTimeEdit->setDateTime(endDateTime);
31		50
32	auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),	51	auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),
33	DateUtils::secondsSinceEpoch(endDateTime)};	52	DateUtils::secondsSinceEpoch(endDateTime)};
34		53
35	sqpApp->timeController().onTimeToUpdate(dateTime);	54	sqpApp->timeController().onTimeToUpdate(dateTime);
36	}	55	}
37		56
38		57
39	TimeWidget::~TimeWidget()	58	TimeWidget::~TimeWidget()
40	{	59	{
41	delete ui;	60	delete ui;
42	}	61	}
43		62
44	void TimeWidget::~~onTimeUpdateRequested~~()	63	void TimeWidget::setTimeRange(SqpRange time)
		64	{
		65	auto startDateTime = DateUtils::dateTime(time.m_TStart);
		66	auto endDateTime = DateUtils::dateTime(time.m_TEnd);
		67
		68	ui->startDateTimeEdit->setDateTime(startDateTime);
		69	ui->endDateTimeEdit->setDateTime(endDateTime);
		70	}
		71
		72	SqpRange TimeWidget::timeRange() const
45	{	73	{
46	~~auto~~ ~~dateTime~~ = SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),	74	return SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
47	DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};	75	DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
		76	}
48		77
		78	void TimeWidget::onTimeUpdateRequested()
		79	{
		80	auto dateTime = timeRange();
49	emit timeUpdated(std::move(dateTime));	81	emit timeUpdated(std::move(dateTime));
50	}	82	}
		83
		84	void TimeWidget::dragEnterEvent(QDragEnterEvent *event)
		85	{
		86	if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
		87	event->acceptProposedAction();
		88	setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
		89	}
		90	else {
		91	event->ignore();
		92	}
		93	}
		94
		95	void TimeWidget::dragLeaveEvent(QDragLeaveEvent *event)
		96	{
		97	setStyleSheet(QString());
		98	}
		99
		100	void TimeWidget::dropEvent(QDropEvent *event)
		101	{
		102	if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
		103	auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
		104	auto timeRange = TimeController::timeRangeForMimeData(mimeData);
		105
		106	setTimeRange(timeRange);
		107	}
		108	else {
		109	event->ignore();
		110	}
		111
		112	setStyleSheet(QString());
		113	}
		114
		115
		116	void TimeWidget::mousePressEvent(QMouseEvent *event)
		117	{
		118	if (event->button() == Qt::LeftButton) {
		119	impl->m_DragStartPosition = event->pos();
		120	}
		121
		122	QWidget::mousePressEvent(event);
		123	}
		124
		125	void TimeWidget::mouseMoveEvent(QMouseEvent *event)
		126	{
		127	if (!(event->buttons() & Qt::LeftButton)) {
		128	return;
		129	}
		130
		131	if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
		132	< QApplication::startDragDistance()) {
		133	return;
		134	}
		135
		136	// Note: The management of the drag object is done by Qt
		137	auto drag = new QDrag{this};
		138
		139	auto mimeData = new QMimeData;
		140	auto timeData = TimeController::mimeDataForTimeRange(timeRange());
		141	mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
		142
		143	drag->setMimeData(mimeData);
		144
		145	auto pixmap = QPixmap(size());
		146	render(&pixmap);
		147	drag->setPixmap(pixmap);
		148	drag->setHotSpot(impl->m_DragStartPosition);
		149
		150	sqpApp->dragDropHelper().resetDragAndDrop();
		151
		152	// Note: The exec() is blocking on windows but not on linux and macOS
		153	drag->exec(Qt::MoveAction \| Qt::CopyAction);
		154
		155	QWidget::mouseMoveEvent(event);
		156	}

gui/src/Variable/VariableInspectorWidget.cpp +1 -6

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

gui/src/Visualization/VisualizationDragDropContainer.cpp +195 -104

             #include "Visualization/VisualizationDragDropContainer.h"
-            #include "DragDropHelper.h"
+            #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Common/VisualizationDef.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
-                QStringList m_AcceptedMimeTypes;
+                QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
-                QStringList m_MergeAllowedMimeTypes;
+                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);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 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;
                         }
                     }
                     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) {
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
-                        if (data->hasFormat(type)) {
+                         ++it) {
+                        if (data->hasFormat(it.key())
+                            && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
+                                || it.value()
+                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
                     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;
                     for (auto child : parent->children()) {
                         auto widget = qobject_cast<VisualizationDragWidget *>(child);
                         if (widget && widget->isVisible()) {
                             if (widget->frameGeometry().contains(pos)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 bool cursorIsInContainer(QWidget *container) const
                 {
-                    auto adustNum = 18; // to be safe, in case of scrollbar on the side
+                    return container->isAncestorOf(sqpApp->widgetAt(QCursor::pos()));
-                    auto containerRect = QRect(QPoint(), container->contentsRect().size())
-                                             .adjusted(adustNum, adustNum, -adustNum, -adustNum);
-                    return containerRect.contains(container->mapFromGlobal(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);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
-            void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
+            void VisualizationDragDropContainer::addAcceptedMimeType(
+                const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
             {
-                impl->m_AcceptedMimeTypes = mimeTypes;
+                impl->m_AcceptedMimeTypes[mimeType] = behavior;
-            void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
-                impl->m_MergeAllowedMimeTypes = mimeTypes;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
-                auto nbGraph = 0;
+                return impl->countDragWidget(this);
-                for (auto child : children()) {
-                    if (qobject_cast<VisualizationDragWidget *>(child)) {
-                        nbGraph += 1;
-                return nbGraph;
             }
             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
             {
                 impl->m_AcceptMimeDataFun = fun;
             }
+            void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+                                                                    const QString &placeHolderText)
+            {
+                impl->m_PlaceHolderType = type;
+                impl->m_PlaceHolderText = placeHolderText;
+            }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 drag->setHotSpot(dragPosition);
                 auto mimeData = dragWidget->mimeData();
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap(dragWidget->size());
                 dragWidget->render(&pixmap);
                 drag->setPixmap(pixmap);
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
                     helper.setCurrentDragWidget(dragWidget);
                     if (impl->cursorIsInContainer(this)) {
                         auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
-                        helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
+                        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);
                 }
                 else {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
                 }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
                     auto &helper = sqpApp->dragDropHelper();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
                         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) {
                                 dragWidget->setVisible(false);
                             }
                         }
-                        auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
+                        auto canMerge = impl->allowMergeForMimeData(event->mimeData());
+                        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
-                        if (dragWidgetHovered) {
+                        impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
-                            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);
                     }
                     else {
                         // do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
                 auto &helper = sqpApp->dragDropHelper();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
+                    helper.setHightlightedDragWidget(nullptr);
+                    impl->m_MinContainerHeight = 0;
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (dragWidget) {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
                         if (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
                 else {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
                 }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
-                    auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
+                    auto canMerge = impl->allowMergeForMimeData(event->mimeData());
-                    if (dragWidgetHovered) {
+                    auto canInsert = impl->allowInsertForMimeData(event->mimeData());
-                        auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                    impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
+                }
-                        auto nbDragWidget = countDragWidget();
+                else {
-                        if (nbDragWidget > 0) {
+                    event->ignore();
-                            auto graphHeight = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
-                            auto dropIndex = floor(event->pos().y() / graphHeight);
-                            auto zoneSize = qMin(graphHeight / 3.0, 150.0);
-                            auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
+                QWidget::dragMoveEvent(event);
-                            auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
+            void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
+            {
                 auto &helper = sqpApp->dragDropHelper();
-                            auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
-                            if (isOnTop || isOnBottom) {
+                if (impl->acceptMimeData(event->mimeData())) {
-                                if (isOnBottom) {
+                    auto dragWidget = helper.getCurrentDragWidget();
-                                    dropIndex += 1;
+                    if (impl->hasPlaceHolder()) {
+                        // drop where the placeHolder is located
-                                if (helper.getCurrentDragWidget()) {
+                        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
-                                    auto dragWidgetIndex
+                        if (canInsert) {
-                                        = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                            auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
-                                    if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                            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)
-                                        dropIndex += 1;
+                                    droppedIndex -= 1;
                                 }
-                                if (dropIndex != placeHolderIndex) {
+                                dragWidget->setVisible(true);
-                                    helper.insertPlaceHolder(impl->m_Layout, dropIndex);
                             }
-                            else if (canMerge) {
-                                // drop on the middle -> merge
+                            event->acceptProposedAction();
-                                if (impl->hasPlaceHolder()) {
                             helper.removePlaceHolder();
+                            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->allowMergeForMimeData(event->mimeData());
+                        if (canMerge) {
+                            event->acceptProposedAction();
+                            emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
+                        }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
-                                << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
+                                << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
-                                      "container");
+                                      "the merge is forbidden.");
+                            Q_ASSERT(false);
                         }
                     }
-                    else {
-                        // No hovered drag widget, the mouse is probably hover the placeHolder
-                        // Do nothing
                 }
                 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 droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
+                auto absPos = container->mapToGlobal(pos);
+                auto isOnPlaceHolder = sqpApp->widgetAt(absPos) == &(helper.placeHolder());
-                        if (dragWidget) {
+                if (countDragWidget(container, true) == 0) {
-                            auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
+                    // Drop on an empty container, just add the placeHolder at the top
-                            if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
+                    helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
+                }
+                else if (!isOnPlaceHolder) {
+                    auto nbDragWidget = countDragWidget(container);
+                    if (nbDragWidget > 0) {
+                        if (m_MinContainerHeight == 0) {
+                            m_MinContainerHeight = container->size().height();
+                        }
+                        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);
+                        if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
+                            if (isOnBottom) {
+                                dropIndex += 1;
+                            }
+                            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)
-                                droppedIndex -= 1;
+                                    dropIndex += 1;
                                 }
-                            dragWidget->setVisible(true);
                             }
-                        event->acceptProposedAction();
+                            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();
+                            }
-                        emit dropOccured(droppedIndex, event->mimeData());
+                            helper.setHightlightedDragWidget(dragWidgetHovered);
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
-                            << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
+                                << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
-                                  "placeHolder is not found.");
+                                      "action.");
                             Q_ASSERT(false);
                         }
                     }
                     else {
-                    event->ignore();
+                        qCWarning(LOG_VisualizationDragDropContainer())
+                            << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
+                                  "found in the "
+                                  "container");
+                    }
+                }
+                else {
+                    // the mouse is hover the placeHolder
+                    // Do nothing
                 }
-                QWidget::dropEvent(event);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +17 -1

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #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>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 // Set axes properties according to the units of the data series
                 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                 auto xAxisUnit = Unit{};
                 auto valuesUnit = Unit{};
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     xAxisUnit = dataSeries->xAxisUnit();
                     valuesUnit = dataSeries->valuesUnit();
                     dataSeries->unlock();
                 }
                 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(const SqpRange &range)
             {
                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             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;
             }
             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);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
                 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

gui/src/Visualization/VisualizationTabWidget.cpp +14 -5

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
-            #include "DragDropHelper.h"
+            #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
-                ui->dragDropContainer->setAcceptedMimeTypes(
+                ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
-                    {MIME_TYPE_GRAPH, MIME_TYPE_ZONE, MIME_TYPE_VARIABLE_LIST});
+                ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 5);
-                connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+                ui->dragDropContainer->addAcceptedMimeType(
-                        &VisualizationTabWidget::dropMimeData);
+                    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
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 if (!variables.isEmpty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         graphWidget->parentZoneWidget()->close();
                     }
                     else {
                         // Close the graph
                         graphWidget->close();
                     }
                     tabWidget->createZone(variables, index);
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
                         parentZoneWidget->close();
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }

gui/src/Visualization/VisualizationWidget.cpp +6 0

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/operations/RescaleAxeOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
+            #include "DragAndDrop/DragDropHelper.h"
+            #include "SqpApplication.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                     auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                              ui->tabWidget};
                     auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                     if (ui->tabWidget->count() == 1) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
                     if (widget) {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 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;
             }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
                     for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
                             = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationWidget::canDrop(const Variable &variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
             bool VisualizationWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(
                 QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 // Menu is generated only if there is a single variable
                 if (variables.size() == 1) {
                     if (auto variable = variables.first()) {
                         // Gets the containers of the variable
                         FindVariableOperation findVariableOperation{variable};
                         accept(&findVariableOperation);
                         auto variableContainers = findVariableOperation.result();
                         // Generates the actions that make it possible to visualize the variable
                         GenerateVariableMenuOperation generateVariableMenuOperation{
                             menu, variable, std::move(variableContainers)};
                         accept(&generateVariableMenuOperation);
                     }
                     else {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "selected");
                 }
             }
             void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
             {
                 // Calls the operation of removing all references to the variable in the visualization
                 auto removeVariableOperation = RemoveVariableOperation{variable};
                 accept(&removeVariableOperation);
             }
             void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
                                                      const SqpRange &range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation{variable, range};
                 accept(&rescaleVariableOperation);
             }
             void VisualizationWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes tabs in the widget
                 for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                     if (auto visualizationTabWidget
                         = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                         visualizationTabWidget->close();
                     }
                 }
                 QWidget::closeEvent(event);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +59 -11

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "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>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
+                // 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);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
-                ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, 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);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
+                if (auto firstGraph = impl->firstGraph(this)) {
-                // Apply visitor to graph children
-                auto layout = ui->dragDropContainer->layout();
-                if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
-                    if (auto visualizationGraphWidget
+                    range = firstGraph->graphRange();
-                        = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
-                        range = visualizationGraphWidget->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 // get y using variable range
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     auto valuesBounds
                         = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
                     auto end = dataSeries->cend();
                     if (valuesBounds.first != end && valuesBounds.second != end) {
                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
                         auto minValue = rangeValue(valuesBounds.first->minValue());
                         auto maxValue = rangeValue(valuesBounds.second->maxValue());
                         graphWidget->setYRange(SqpRange{minValue, maxValue});
                     }
                     dataSeries->unlock();
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
+            void VisualizationZoneWidget::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)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         previousParentZoneWidget->close();
                     }
                     else {
                         // Close the graph
                         graphWidget->close();
                     }
                     // Creates the new graph in the zone
                     zoneWidget->createGraph(variables, index);
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }

gui/ui/TimeWidget/TimeWidget.ui +6 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>TimeWidget</class>
              <widget class="QWidget" name="TimeWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>716</width>
                 <height>48</height>
                </rect>
               </property>
               <property name="sizePolicy">
                <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
                 <horstretch>0</horstretch>
                 <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">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="text">
                   <string>TStart :</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QDateTimeEdit" name="startDateTimeEdit">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="displayFormat">
                   <string>dd/MM/yyyy HH:mm:ss:zzz</string>
                  </property>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
                  <property name="timeSpec">
                   <enum>Qt::UTC</enum>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QLabel" name="label_2">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="text">
                   <string>TEnd :</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QDateTimeEdit" name="endDateTimeEdit">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="displayFormat">
                   <string>dd/MM/yyyy HH:mm:ss:zzz</string>
                  </property>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
                  <property name="timeSpec">
                   <enum>Qt::UTC</enum>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QToolButton" name="applyToolButton">
                  <property name="text">
                   <string>...</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

gui/ui/Variable/VariableInspectorWidget.ui +8 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VariableInspectorWidget</class>
              <widget class="QWidget" name="VariableInspectorWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Variables</string>
               </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>
                  <property name="dragEnabled">
                   <bool>true</bool>
                  </property>
                  <property name="dragDropMode">
                   <enum>QAbstractItemView::DragDrop</enum>
                  </property>
                  <property name="sortingEnabled">
                   <bool>true</bool>
                  </property>
                  <attribute name="horizontalHeaderStretchLastSection">
                   <bool>true</bool>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
+             <customwidgets>
+              <customwidget>
+               <class>VariableInspectorTableView</class>
+               <extends>QTableView</extends>
+               <header>Variable/VariableInspectorTableView.h</header>
+              </customwidget>
+             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationTabWidget.ui +6 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationTabWidget</class>
              <widget class="QWidget" name="VisualizationTabWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <widget class="QScrollArea" name="scrollArea">
                  <property name="frameShape">
                   <enum>QFrame::NoFrame</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Sunken</enum>
                  </property>
                  <property name="widgetResizable">
                   <bool>true</bool>
                  </property>
                  <widget class="QWidget" name="scrollAreaWidgetContents">
                   <property name="geometry">
                    <rect>
                     <x>0</x>
                     <y>0</y>
                     <width>400</width>
                     <height>300</height>
                    </rect>
                   </property>
                   <layout class="QVBoxLayout" name="verticalLayout_3">
                    <property name="spacing">
                     <number>3</number>
                    </property>
                    <property name="leftMargin">
                     <number>0</number>
                    </property>
                    <property name="topMargin">
                     <number>0</number>
                    </property>
                    <property name="rightMargin">
                     <number>0</number>
                    </property>
                    <property name="bottomMargin">
                     <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>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>VisualizationDragDropContainer</class>
-               <extends>QWidget</extends>
+               <extends>QFrame</extends>
                <header>Visualization/VisualizationDragDropContainer.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +2 -5

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationZoneWidget</class>
              <widget class="QWidget" name="VisualizationZoneWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_2">
                <property name="spacing">
                 <number>0</number>
                </property>
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <widget class="QWidget" name="infobar" native="true">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <layout class="QHBoxLayout" name="horizontalLayout">
                   <property name="spacing">
                    <number>0</number>
                   </property>
                   <property name="leftMargin">
                    <number>0</number>
                   </property>
                   <property name="topMargin">
                    <number>0</number>
                   </property>
                   <property name="rightMargin">
                    <number>0</number>
                   </property>
                   <property name="bottomMargin">
                    <number>0</number>
                   </property>
                   <item>
                    <widget class="QLabel" name="zoneNameLabel">
                     <property name="styleSheet">
                      <string notr="true">color: rgb(127, 127, 127);
             </string>
                     </property>
                     <property name="text">
                      <string>TextLabel</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QToolButton" name="closeButton">
                     <property name="styleSheet">
                      <string notr="true">background-color: transparent;</string>
                     </property>
                     <property name="text">
                      <string>Close</string>
                     </property>
                    </widget>
                   </item>
                  </layout>
                 </widget>
                </item>
                <item>
-                <widget class="QFrame" name="visualizationZoneFrame">
+                <widget class="VisualizationDragDropContainer" name="dragDropContainer">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="frameShape">
                   <enum>QFrame::Box</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Raised</enum>
                  </property>
                  <property name="lineWidth">
                   <number>1</number>
                  </property>
                  <layout class="QVBoxLayout" name="verticalLayout">
                   <property name="leftMargin">
                    <number>0</number>
                   </property>
                   <property name="topMargin">
                    <number>0</number>
                   </property>
                   <property name="rightMargin">
                    <number>0</number>
                   </property>
                   <property name="bottomMargin">
                    <number>0</number>
                   </property>
-                  <item>
-                   <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
-                  </item>
                  </layout>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>VisualizationDragDropContainer</class>
-               <extends>QWidget</extends>
+               <extends>QFrame</extends>
                <header>Visualization/VisualizationDragDropContainer.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

General Comments 0

Write
Preview

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

No TODOs yet

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

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