HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r847:6af9a63cc3d0

Merge pull request from SciQLop-fork develop...

leroux -

r847:6af9a63cc3d0

parent child

Context file:

r847:6af9a63cc3d0

Collapse all files

gui/include/DragDropHelper.h created 644 +65 0

@@ -0,0 +1,65
	1	#ifndef SCIQLOP_DRAGDROPHELPER_H
	2	#define SCIQLOP_DRAGDROPHELPER_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QWidget>
	6
	7	class QVBoxLayout;
	8	class QScrollArea;
	9	class VisualizationDragWidget;
	10	class QMimeData;
	11
	12	/**
	13	* @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
	14	* @note A QScrollArea inside an other QScrollArea is not fully supported.
	15	*/
	16	class DragDropScroller : public QObject {
	17	Q_OBJECT
	18
	19	public:
	20	DragDropScroller(QObject *parent = nullptr);
	21
	22	void addScrollArea(QScrollArea *scrollArea);
	23	void removeScrollArea(QScrollArea *scrollArea);
	24
	25	protected:
	26	bool eventFilter(QObject obj, QEvent event);
	27
	28	private:
	29	class DragDropScrollerPrivate;
	30	spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
	31
	32	private slots:
	33	void onTimer();
	34	};
	35
	36	/**
	37	* @brief Helper class for drag&drop operations.
	38	*/
	39	class DragDropHelper {
	40	public:
	41	static const QString MIME_TYPE_GRAPH;
	42	static const QString MIME_TYPE_ZONE;
	43
	44	DragDropHelper();
	45	virtual ~DragDropHelper();
	46
	47	void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
	48	VisualizationDragWidget *getCurrentDragWidget() const;
	49
	50	QWidget &placeHolder() const;
	51	void insertPlaceHolder(QVBoxLayout *layout, int index);
	52	void removePlaceHolder();
	53	bool isPlaceHolderSet() const;
	54
	55	void addDragDropScrollArea(QScrollArea *scrollArea);
	56	void removeDragDropScrollArea(QScrollArea *scrollArea);
	57
	58	QUrl imageTemporaryUrl(const QImage &image) const;
	59
	60	private:
	61	class DragDropHelperPrivate;
	62	spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
	63	};
	64
	65	#endif // SCIQLOP_DRAGDROPHELPER_H

gui/include/Visualization/VisualizationDragDropContainer.h created 644 +42 0

@@ -0,0 +1,42
	1	#ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
	2	#define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QMimeData>
	6	#include <QVBoxLayout>
	7	#include <QWidget>
	8
	9	class VisualizationDragWidget;
	10
	11	class VisualizationDragDropContainer : public QWidget {
	12	Q_OBJECT
	13
	14	signals:
	15	void dropOccured(int dropIndex, const QMimeData *mimeData);
	16
	17	public:
	18	VisualizationDragDropContainer(QWidget *parent = nullptr);
	19
	20	void addDragWidget(VisualizationDragWidget *dragWidget);
	21	void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
	22
	23	void setAcceptedMimeTypes(const QStringList &mimeTypes);
	24	void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
	25
	26	int countDragWidget() const;
	27
	28	protected:
	29	void dragEnterEvent(QDragEnterEvent *event);
	30	void dragLeaveEvent(QDragLeaveEvent *event);
	31	void dragMoveEvent(QDragMoveEvent *event);
	32	void dropEvent(QDropEvent *event);
	33
	34	private:
	35	class VisualizationDragDropContainerPrivate;
	36	spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
	37
	38	private slots:
	39	void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
	40	};
	41
	42	#endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H

gui/include/Visualization/VisualizationDragWidget.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef SCIQLOP_VISUALIZATIONDRAGWIDGET_H
	2	#define SCIQLOP_VISUALIZATIONDRAGWIDGET_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QMimeData>
	6	#include <QWidget>
	7
	8	class VisualizationDragWidget : public QWidget {
	9	Q_OBJECT
	10
	11	public:
	12	VisualizationDragWidget(QWidget *parent = nullptr);
	13
	14	virtual QMimeData *mimeData() const = 0;
	15	virtual bool isDragAllowed() const = 0;
	16
	17	protected:
	18	virtual void mousePressEvent(QMouseEvent *event) override;
	19	virtual void mouseMoveEvent(QMouseEvent *event) override;
	20
	21	private:
	22	class VisualizationDragWidgetPrivate;
	23	spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
	24
	25	signals:
	26	void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
	27	};
	28
	29	#endif // SCIQLOP_VISUALIZATIONDRAGWIDGET_H

gui/src/DragDropHelper.cpp created 644 +230 0

@@ -0,0 +1,230
	1	#include "DragDropHelper.h"
	2	#include "SqpApplication.h"
	3	#include "Visualization/VisualizationDragWidget.h"
	4
	5	#include <QDir>
	6	#include <QDragEnterEvent>
	7	#include <QDragMoveEvent>
	8	#include <QScrollArea>
	9	#include <QScrollBar>
	10	#include <QTimer>
	11	#include <QVBoxLayout>
	12
	13	const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
	14	const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
	15
	16	const int SCROLL_SPEED = 5;
	17	const int SCROLL_ZONE_SIZE = 50;
	18
	19	struct DragDropScroller::DragDropScrollerPrivate {
	20
	21	QList<QScrollArea *> m_ScrollAreas;
	22	QScrollArea *m_CurrentScrollArea = nullptr;
	23	std::unique_ptr<QTimer> m_Timer = nullptr;
	24
	25
	26	enum class ScrollDirection { up, down, unknown };
	27	ScrollDirection m_Direction = ScrollDirection::unknown;
	28
	29	explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
	30	{
	31	m_Timer->setInterval(0);
	32	}
	33	};
	34
	35	DragDropScroller::DragDropScroller(QObject *parent)
	36	: QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
	37	{
	38	connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
	39	}
	40
	41	void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
	42	{
	43	impl->m_ScrollAreas << scrollArea;
	44	scrollArea->viewport()->setAcceptDrops(true);
	45	}
	46
	47	void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
	48	{
	49	impl->m_ScrollAreas.removeAll(scrollArea);
	50	scrollArea->viewport()->setAcceptDrops(false);
	51	}
	52
	53	bool DragDropScroller::eventFilter(QObject obj, QEvent event)
	54	{
	55	if (event->type() == QEvent::DragMove) {
	56	auto w = static_cast<QWidget *>(obj);
	57
	58	if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
	59	auto moveEvent = static_cast<QDragMoveEvent *>(event);
	60
	61	auto pos = moveEvent->pos();
	62	if (impl->m_CurrentScrollArea->viewport() != w) {
	63	auto globalPos = w->mapToGlobal(moveEvent->pos());
	64	pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
	65	}
	66
	67	auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
	68	- SCROLL_ZONE_SIZE;
	69	auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
	70
	71	if (!isInTopZone && !isInBottomZone) {
	72	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	73	impl->m_Timer->stop();
	74	}
	75	else if (!impl->m_Timer->isActive()) {
	76	impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
	77	: DragDropScrollerPrivate::ScrollDirection::down;
	78	impl->m_Timer->start();
	79	}
	80	}
	81	}
	82	else if (event->type() == QEvent::DragEnter) {
	83	auto w = static_cast<QWidget *>(obj);
	84
	85	for (auto scrollArea : impl->m_ScrollAreas) {
	86	if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
	87	auto enterEvent = static_cast<QDragEnterEvent *>(event);
	88	enterEvent->acceptProposedAction();
	89	enterEvent->setDropAction(Qt::IgnoreAction);
	90	impl->m_CurrentScrollArea = scrollArea;
	91	break;
	92	}
	93	}
	94	}
	95	else if (event->type() == QEvent::DragLeave) {
	96	if (impl->m_CurrentScrollArea) {
	97	if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
	98	.contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
	99	impl->m_CurrentScrollArea = nullptr;
	100	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	101	impl->m_Timer->stop();
	102	}
	103	}
	104	}
	105	else if (event->type() == QEvent::Drop) {
	106	if (impl->m_CurrentScrollArea) {
	107	impl->m_CurrentScrollArea = nullptr;
	108	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	109	impl->m_Timer->stop();
	110	}
	111	}
	112
	113	return false;
	114	}
	115
	116	void DragDropScroller::onTimer()
	117	{
	118	if (impl->m_CurrentScrollArea) {
	119	auto mvt = 0;
	120	switch (impl->m_Direction) {
	121	case DragDropScrollerPrivate::ScrollDirection::up:
	122	mvt = SCROLL_SPEED;
	123	break;
	124	case DragDropScrollerPrivate::ScrollDirection::down:
	125	mvt = -SCROLL_SPEED;
	126	break;
	127	default:
	128	break;
	129	}
	130
	131	impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
	132	impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
	133	}
	134	}
	135
	136	struct DragDropHelper::DragDropHelperPrivate {
	137
	138	VisualizationDragWidget *m_CurrentDragWidget = nullptr;
	139	std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
	140	std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
	141	QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
	142	// QTemporaryFile to have a name which is not generated.
	143
	144	explicit DragDropHelperPrivate()
	145	: m_PlaceHolder{std::make_unique<QWidget>()},
	146	m_DragDropScroller{std::make_unique<DragDropScroller>()}
	147	{
	148	m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
	149	sqpApp->installEventFilter(m_DragDropScroller.get());
	150
	151
	152	m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
	153	}
	154
	155	void preparePlaceHolder() const
	156	{
	157	if (m_CurrentDragWidget) {
	158	m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
	159	m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
	160	}
	161	else {
	162	m_PlaceHolder->setMinimumSize(200, 200);
	163	}
	164	}
	165	};
	166
	167
	168	DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
	169	{
	170	}
	171
	172	DragDropHelper::~DragDropHelper()
	173	{
	174	QFile::remove(impl->m_ImageTempUrl);
	175	}
	176
	177	void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
	178	{
	179	impl->m_CurrentDragWidget = dragWidget;
	180	}
	181
	182	VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
	183	{
	184	return impl->m_CurrentDragWidget;
	185	}
	186
	187
	188	QWidget &DragDropHelper::placeHolder() const
	189	{
	190	return *impl->m_PlaceHolder;
	191	}
	192
	193	void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index)
	194	{
	195	removePlaceHolder();
	196	impl->preparePlaceHolder();
	197	layout->insertWidget(index, impl->m_PlaceHolder.get());
	198	impl->m_PlaceHolder->show();
	199	}
	200
	201	void DragDropHelper::removePlaceHolder()
	202	{
	203	auto parentWidget = impl->m_PlaceHolder->parentWidget();
	204	if (parentWidget) {
	205	parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
	206	impl->m_PlaceHolder->setParent(nullptr);
	207	impl->m_PlaceHolder->hide();
	208	}
	209	}
	210
	211	bool DragDropHelper::isPlaceHolderSet() const
	212	{
	213	return impl->m_PlaceHolder->parentWidget();
	214	}
	215
	216	void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
	217	{
	218	impl->m_DragDropScroller->addScrollArea(scrollArea);
	219	}
	220
	221	void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
	222	{
	223	impl->m_DragDropScroller->removeScrollArea(scrollArea);
	224	}
	225
	226	QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
	227	{
	228	image.save(impl->m_ImageTempUrl);
	229	return QUrl::fromLocalFile(impl->m_ImageTempUrl);
	230	}

gui/src/Visualization/VisualizationDragDropContainer.cpp created 644 +302 0

@@ -0,0 +1,302
	1	#include "Visualization/VisualizationDragDropContainer.h"
	2	#include "DragDropHelper.h"
	3	#include "SqpApplication.h"
	4	#include "Visualization/VisualizationDragWidget.h"
	5
	6	#include <QDrag>
	7	#include <QDragEnterEvent>
	8	#include <QVBoxLayout>
	9
	10	#include <cmath>
	11	#include <memory>
	12
	13	struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
	14
	15	QVBoxLayout *m_Layout;
	16	QStringList m_AcceptedMimeTypes;
	17	QStringList m_MergeAllowedMimeTypes;
	18
	19	explicit VisualizationDragDropContainerPrivate(QWidget *widget)
	20	{
	21	m_Layout = new QVBoxLayout(widget);
	22	m_Layout->setContentsMargins(0, 0, 0, 0);
	23	}
	24
	25	bool acceptMimeData(const QMimeData *data) const
	26	{
	27	for (const auto &type : m_AcceptedMimeTypes) {
	28	if (data->hasFormat(type)) {
	29	return true;
	30	}
	31	}
	32
	33	return false;
	34	}
	35
	36	bool allowMergeMimeData(const QMimeData *data) const
	37	{
	38	for (const auto &type : m_MergeAllowedMimeTypes) {
	39	if (data->hasFormat(type)) {
	40	return true;
	41	}
	42	}
	43
	44	return false;
	45	}
	46
	47	bool hasPlaceHolder() const
	48	{
	49	return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
	50	}
	51
	52	VisualizationDragWidget getChildDragWidgetAt(QWidget parent, const QPoint &pos) const
	53	{
	54	VisualizationDragWidget *dragWidget = nullptr;
	55
	56	for (auto child : parent->children()) {
	57	auto widget = qobject_cast<VisualizationDragWidget *>(child);
	58	if (widget && widget->isVisible()) {
	59	if (widget->frameGeometry().contains(pos)) {
	60	dragWidget = widget;
	61	break;
	62	}
	63	}
	64	}
	65
	66	return dragWidget;
	67	}
	68
	69	bool cursorIsInContainer(QWidget *container) const
	70	{
	71	auto adustNum = 18; // to be safe, in case of scrollbar on the side
	72	auto containerRect = QRect(QPoint(), container->contentsRect().size())
	73	.adjusted(adustNum, adustNum, -adustNum, -adustNum);
	74	return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
	75	}
	76	};
	77
	78	VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
	79	: QWidget{parent},
	80	impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
	81	{
	82	setAcceptDrops(true);
	83	}
	84
	85	void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
	86	{
	87	impl->m_Layout->addWidget(dragWidget);
	88	disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
	89	connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
	90	&VisualizationDragDropContainer::startDrag);
	91	}
	92
	93	void VisualizationDragDropContainer::insertDragWidget(int index,
	94	VisualizationDragWidget *dragWidget)
	95	{
	96	impl->m_Layout->insertWidget(index, dragWidget);
	97	disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
	98	connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
	99	&VisualizationDragDropContainer::startDrag);
	100	}
	101
	102	void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
	103	{
	104	impl->m_AcceptedMimeTypes = mimeTypes;
	105	}
	106
	107	void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
	108	{
	109	impl->m_MergeAllowedMimeTypes = mimeTypes;
	110	}
	111
	112	int VisualizationDragDropContainer::countDragWidget() const
	113	{
	114	auto nbGraph = 0;
	115	for (auto child : children()) {
	116	if (qobject_cast<VisualizationDragWidget *>(child)) {
	117	nbGraph += 1;
	118	}
	119	}
	120
	121	return nbGraph;
	122	}
	123
	124	void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
	125	const QPoint &dragPosition)
	126	{
	127	auto &helper = sqpApp->dragDropHelper();
	128
	129	// Note: The management of the drag object is done by Qt
	130	auto drag = new QDrag{dragWidget};
	131	drag->setHotSpot(dragPosition);
	132
	133	auto mimeData = dragWidget->mimeData();
	134	drag->setMimeData(mimeData);
	135
	136	auto pixmap = QPixmap(dragWidget->size());
	137	dragWidget->render(&pixmap);
	138	drag->setPixmap(pixmap);
	139
	140	auto image = pixmap.toImage();
	141	mimeData->setImageData(image);
	142	mimeData->setUrls({helper.imageTemporaryUrl(image)});
	143
	144	if (impl->m_Layout->indexOf(dragWidget) >= 0) {
	145	helper.setCurrentDragWidget(dragWidget);
	146
	147	if (impl->cursorIsInContainer(this)) {
	148	auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
	149	helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
	150	dragWidget->setVisible(false);
	151	}
	152	}
	153
	154	// Note: The exec() is blocking on windows but not on linux and macOS
	155	drag->exec(Qt::MoveAction \| Qt::CopyAction);
	156	}
	157
	158	void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
	159	{
	160	if (impl->acceptMimeData(event->mimeData())) {
	161	event->acceptProposedAction();
	162
	163	auto &helper = sqpApp->dragDropHelper();
	164
	165	if (!impl->hasPlaceHolder()) {
	166	auto dragWidget = helper.getCurrentDragWidget();
	167	auto parentWidget
	168	= qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
	169	if (parentWidget) {
	170	dragWidget->setVisible(false);
	171	}
	172
	173	auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
	174
	175	if (dragWidgetHovered) {
	176	auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
	177	auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
	178	if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
	179	hoveredWidgetIndex
	180	+= 1; // Correction of the index if the drop occurs in the same container
	181	}
	182
	183	helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
	184	}
	185	else {
	186	helper.insertPlaceHolder(impl->m_Layout, 0);
	187	}
	188	}
	189	}
	190	else {
	191	event->ignore();
	192	}
	193
	194	QWidget::dragEnterEvent(event);
	195	}
	196
	197	void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
	198	{
	199	Q_UNUSED(event);
	200
	201	auto &helper = sqpApp->dragDropHelper();
	202
	203	if (!impl->cursorIsInContainer(this)) {
	204	helper.removePlaceHolder();
	205
	206	bool isInternal = true;
	207	if (isInternal) {
	208	// Only if the drag is started from the visualization
	209	// Show the drag widget at its original place
	210	// So the drag widget doesn't stay hidden if the drop occurs outside the visualization
	211	// drop zone (It is not possible to catch a drop event outside of the application)
	212
	213	auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
	214	if (dragWidget) {
	215	dragWidget->setVisible(true);
	216	}
	217	}
	218	}
	219
	220	QWidget::dragLeaveEvent(event);
	221	}
	222
	223	void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
	224	{
	225	if (impl->acceptMimeData(event->mimeData())) {
	226	auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
	227	if (dragWidgetHovered) {
	228	auto canMerge = impl->allowMergeMimeData(event->mimeData());
	229
	230	auto nbDragWidget = countDragWidget();
	231	if (nbDragWidget > 0) {
	232	auto graphHeight = size().height() / nbDragWidget;
	233	auto dropIndex = floor(event->pos().y() / graphHeight);
	234	auto zoneSize = qMin(graphHeight / 3.0, 150.0);
	235
	236	auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
	237	auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
	238
	239	auto &helper = sqpApp->dragDropHelper();
	240	auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
	241
	242	if (isOnTop \|\| isOnBottom) {
	243	if (isOnBottom) {
	244	dropIndex += 1;
	245	}
	246
	247	auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
	248	if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
	249	dropIndex += 1; // Correction of the index if the drop occurs in the same
	250	// container
	251	}
	252
	253	if (dropIndex != placeHolderIndex) {
	254	helper.insertPlaceHolder(impl->m_Layout, dropIndex);
	255	}
	256	}
	257	else if (canMerge) {
	258	// drop on the middle -> merge
	259	if (impl->hasPlaceHolder()) {
	260	helper.removePlaceHolder();
	261	}
	262	}
	263	}
	264	}
	265	}
	266	else {
	267	event->ignore();
	268	}
	269
	270	QWidget::dragMoveEvent(event);
	271	}
	272
	273	void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
	274	{
	275	if (impl->acceptMimeData(event->mimeData())) {
	276	auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
	277	if (impl->hasPlaceHolder() && dragWidget) {
	278	auto &helper = sqpApp->dragDropHelper();
	279
	280	auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
	281
	282	auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
	283	if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
	284	droppedIndex
	285	-= 1; // Correction of the index if the drop occurs in the same container
	286	}
	287
	288	dragWidget->setVisible(true);
	289
	290	event->acceptProposedAction();
	291
	292	helper.removePlaceHolder();
	293
	294	emit dropOccured(droppedIndex, event->mimeData());
	295	}
	296	}
	297	else {
	298	event->ignore();
	299	}
	300
	301	QWidget::dropEvent(event);
	302	}

gui/src/Visualization/VisualizationDragWidget.cpp created 644 +53 0

@@ -0,0 +1,53
	1	#include "Visualization/VisualizationDragWidget.h"
	2	#include "Visualization/VisualizationDragDropContainer.h"
	3
	4	#include <QApplication>
	5	#include <QMouseEvent>
	6
	7	struct VisualizationDragWidget::VisualizationDragWidgetPrivate {
	8
	9	QPoint m_DragStartPosition;
	10	bool m_DragStartPositionValid = false;
	11
	12	explicit VisualizationDragWidgetPrivate() {}
	13	};
	14
	15	VisualizationDragWidget::VisualizationDragWidget(QWidget *parent)
	16	: QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
	17	{
	18	}
	19
	20	void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
	21	{
	22	if (event->button() == Qt::LeftButton) {
	23	impl->m_DragStartPosition = event->pos();
	24	}
	25
	26	impl->m_DragStartPositionValid = isDragAllowed();
	27
	28	QWidget::mousePressEvent(event);
	29	}
	30
	31	void VisualizationDragWidget::mouseMoveEvent(QMouseEvent *event)
	32	{
	33	if (!impl->m_DragStartPositionValid \|\| !isDragAllowed()) {
	34	return;
	35	}
	36
	37	if (!(event->buttons() & Qt::LeftButton)) {
	38	return;
	39	}
	40
	41	if (!event->modifiers().testFlag(Qt::AltModifier)) {
	42	return;
	43	}
	44
	45	if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
	46	< QApplication::startDragDistance()) {
	47	return;
	48	}
	49
	50	emit dragDetected(this, impl->m_DragStartPosition);
	51
	52	QWidget::mouseMoveEvent(event);
	53	}

gui/include/SqpApplication.h +4 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
             class NetworkController;
             class TimeController;
             class VariableController;
             class VisualizationController;
+            class DragDropHelper;
             /**
              * @brief The SqpApplication 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 load 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 SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
                 NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
+                /// Accessors for the differents sciqlop helpers
+                DragDropHelper &dragDropHelper() noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/include/Visualization/VisualizationGraphWidget.h +11 -1

             #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 QWidget, public IVisualizationWidget {
+            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;
             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/VisualizationTabWidget.h +24 -1

             #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
             #define SCIQLOP_VISUALIZATIONTABWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
+            #include <QMimeData>
             #include <QWidget>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
             class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationTabWidget;
             } // namespace Ui
             class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
+                void insertZone(int index, VisualizationZoneWidget *zoneWidget);
                 /**
                  * Creates a zone using a variable. The variable will be displayed in a new graph of the new
-                 * zone.
+                 * zone. The zone is added at the end.
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
+                /**
+                 * Creates a zone using a list of variables. The variables will be displayed in a new graph of
+                 * the new zone. The zone is inserted at the specified index.
+                 * @param variables the variables for which to create the zone
+                 * @param index The index where the zone should be inserted in the layout
+                 * @return the pointer to the created zone
+                 */
+                VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
+                                                    int index);
+                /**
+                 * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
+                 * @param index The index where the zone should be inserted in the layout
+                 * @return the pointer to the created zone
+                 */
+                VisualizationZoneWidget *createEmptyZone(int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 /// @return the layout of tab in which zones are added
                 QLayout &tabLayout() const noexcept;
                 Ui::VisualizationTabWidget *ui;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
+            private slots:
+                void dropMimeData(int index, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +33 -3

             #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;
-            } // Ui
+            } // namespace Ui
             class Variable;
             class VisualizationGraphWidget;
-            class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
+            class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
-                /// Add a graph widget
+                /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
+                /// Inserts a graph widget
+                void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
+                 * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
+                /**
+                 * Creates a graph using a variable. The variable will be displayed in the new graph.
+                 * The graph is inserted at the specified index.
+                 * @param variable the variable for which to create the graph
+                 * @param index The index where the graph should be inserted in the layout
+                 * @return the pointer to the created graph
+                 */
+                VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
+                /**
+                 * Creates a graph using a list of variables. The variables will be displayed in the new graph.
+                 * The graph is inserted at the specified index.
+                 * @param variables List of variables to be added to the graph
+                 * @param index The index where the graph should be inserted in the layout
+                 * @return the pointer to the created graph
+                 */
+                VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
+                                                      int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
+                // VisualisationDragWidget
+                QMimeData *mimeData() const override;
+                bool isDragAllowed() const override;
             protected:
                 void closeEvent(QCloseEvent *event) override;
             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);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/SqpApplication.cpp +10 -1

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
+            #include <DragDropHelper.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.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_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>)));
                     // 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/Visualization/VisualizationGraphWidget.cpp +43 -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 <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
+            #include <DragDropHelper.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.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)
-                    : 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(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+                return mimeData;
+            }
+            bool VisualizationGraphWidget::isDragAllowed() const
+            {
+                return true;
+            }
             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 +95 -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 "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;
             };
             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(
+                    {DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
+                connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+                        &VisualizationTabWidget::dropMimeData);
+                sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
+                sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
-                tabLayout().addWidget(zoneWidget);
+                ui->dragDropContainer->addDragWidget(zoneWidget);
+            }
+            void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
+            {
+                ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
-                auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};
+                return createZone({variable}, -1);
-                this->addZone(zoneWidget);
+            VisualizationZoneWidget *
+            VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
+            {
+                auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
-                zoneWidget->createGraph(variable);
+                zoneWidget->createGraph(variables, index);
+                return zoneWidget;
+            }
+            VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
+            {
+                auto zoneWidget
+                    = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
+                this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             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->scrollAreaWidgetContents->layout();
+                return *ui->dragDropContainer->layout();
+            }
+            void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
+            {
+                auto &helper = sqpApp->dragDropHelper();
+                if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+                    auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                    auto parentDragDropContainer
+                        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+                    Q_ASSERT(parentDragDropContainer);
+                    auto nbGraph = parentDragDropContainer->countDragWidget();
+                    const auto &variables = graphWidget->variables();
+                    if (!variables.isEmpty()) {
+                        // Abort the requests for the variables (if any)
+                        // Commented, because it's not sure if it's needed or not
+                        // for (const auto& var : variables)
+                        //{
+                        //    sqpApp->variableController().onAbortProgressRequested(var);
+                        //}
+                        if (nbGraph == 1) {
+                            // This is the only graph in the previous zone, close the zone
+                            graphWidget->parentZoneWidget()->close();
+                        }
+                        else {
+                            // Close the graph
+                            graphWidget->close();
+                        }
+                        createZone(variables, index);
+                    }
+                    else {
+                        // The graph is empty, create an empty zone and move the graph inside
+                        auto parentZoneWidget = graphWidget->parentZoneWidget();
+                        parentDragDropContainer->layout()->removeWidget(graphWidget);
+                        auto zoneWidget = createEmptyZone(index);
+                        zoneWidget->addGraph(graphWidget);
+                        // Close the old zone if it was the only graph inside
+                        if (nbGraph == 1) {
+                            parentZoneWidget->close();
+                        }
+                    }
+                }
+                else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE)) {
+                    // Simple move of the zone, no variable operation associated
+                    auto zoneWidget = static_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
+                    auto parentDragDropContainer = zoneWidget->parentWidget();
+                    parentDragDropContainer->layout()->removeWidget(zoneWidget);
+                    ui->dragDropContainer->insertDragWidget(index, zoneWidget);
+                }
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +115 -9

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include <Data/SqpRange.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
+            #include <DragDropHelper.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
+            #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Minimum height for graph added in zones (in pixels)
             const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             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;
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
-                    : QWidget{parent},
+                    : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
+                ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
+                connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+                        &VisualizationZoneWidget::dropMimeData);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 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->visualizationZoneFrame->layout()->addWidget(graphWidget);
+                ui->dragDropContainer->addDragWidget(graphWidget);
+            }
+            void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
+            {
+                // Synchronize new graph with others in the zone
+                impl->m_Synchronizer->addGraph(*graphWidget);
+                ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
-                auto graphWidget = new VisualizationGraphWidget{
+                return createGraph(variable, -1);
-                    defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
+            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->visualizationZoneFrame->layout();
+                    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{};
                 // Apply visitor to graph children
-                auto layout = ui->visualizationZoneFrame->layout();
+                auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
                     if (auto visualizationGraphWidget
                         = 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->addGraph(graphWidget);
+                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->visualizationZoneFrame->layout(),
+                        *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(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
+                return mimeData;
+            }
+            bool VisualizationZoneWidget::isDragAllowed() const
+            {
+                return true;
+            }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
-                processGraphs(*ui->visualizationZoneFrame->layout(),
+                processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 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)
+            {
+                auto &helper = sqpApp->dragDropHelper();
+                if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+                    auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                    auto parentDragDropContainer
+                        = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
+                    Q_ASSERT(parentDragDropContainer);
+                    const auto &variables = graphWidget->variables();
+                    if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
+                        // The drop didn't occur in the same zone
+                        // Abort the requests for the variables (if any)
+                        // Commented, because it's not sure if it's needed or not
+                        // for (const auto& var : variables)
+                        //{
+                        //    sqpApp->variableController().onAbortProgressRequested(var);
+                        //}
+                        auto previousParentZoneWidget = graphWidget->parentZoneWidget();
+                        auto nbGraph = parentDragDropContainer->countDragWidget();
+                        if (nbGraph == 1) {
+                            // This is the only graph in the previous zone, close the zone
+                            previousParentZoneWidget->close();
+                        }
+                        else {
+                            // Close the graph
+                            graphWidget->close();
+                        }
+                        // Creates the new graph in the zone
+                        createGraph(variables, index);
+                    }
+                    else {
+                        // The drop occurred in the same zone or the graph is empty
+                        // Simple move of the graph, no variable operation associated
+                        parentDragDropContainer->layout()->removeWidget(graphWidget);
+                        if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
+                            // The graph is empty and dropped in a different zone.
+                            // Take the range of the first graph in the zone (if existing).
+                            auto layout = ui->dragDropContainer->layout();
+                            if (layout->count() > 0) {
+                                if (auto visualizationGraphWidget
+                                    = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                                    graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
+                                }
+                            }
+                        }
+                        ui->dragDropContainer->insertDragWidget(index, graphWidget);
+                    }
+                }
+            }

gui/ui/Visualization/VisualizationTabWidget.ui +11 0

             <?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"/>
+                   </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
+             <customwidgets>
+              <customwidget>
+               <class>VisualizationDragDropContainer</class>
+               <extends>QWidget</extends>
+               <header>Visualization/VisualizationDragDropContainer.h</header>
+               <container>1</container>
+              </customwidget>
+             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +11 0

             <?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">
                  <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>
+               <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