HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1108:0b3fbaa8bda5

Merge pull request from SciQLop-fork develop...

trabillard -

r1108:0b3fbaa8bda5

parent child

Context file:

r1108:0b3fbaa8bda5

gui/include/Actions/ActionsGuiController.h created 644 +27 0

@@ -0,0 +1,27
	1	#ifndef SCIQLOP_ACTIONSGUICONTROLLER_H
	2	#define SCIQLOP_ACTIONSGUICONTROLLER_H
	3
	4	#include <Actions/SelectionZoneAction.h>
	5	#include <Common/spimpl.h>
	6
	7	#include <memory>
	8
	9	class ActionsGuiController {
	10	public:
	11	ActionsGuiController();
	12
	13	std::shared_ptr<SelectionZoneAction>
	14	addSectionZoneAction(const QString &name, SelectionZoneAction::ExecuteFunction function);
	15
	16	std::shared_ptr<SelectionZoneAction>
	17	addSectionZoneAction(const QStringList &subMenuList, const QString &name,
	18	SelectionZoneAction::ExecuteFunction function);
	19
	20	QVector<std::shared_ptr<SelectionZoneAction> > selectionZoneActions() const;
	21
	22	private:
	23	class ActionsGuiControllerPrivate;
	24	spimpl::unique_impl_ptr<ActionsGuiControllerPrivate> impl;
	25	};
	26
	27	#endif // SCIQLOP_ACTIONSGUICONTROLLER_H

gui/include/Actions/SelectionZoneAction.h created 644 +75 0

@@ -0,0 +1,75
	1	#ifndef SCIQLOP_SELECTIONZONEACTION_H
	2	#define SCIQLOP_SELECTIONZONEACTION_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8
	9	#include <functional>
	10
	11	class VisualizationSelectionZoneItem;
	12
	13	Q_DECLARE_LOGGING_CATEGORY(LOG_SelectionZoneAction)
	14
	15	/**
	16	* @brief The SelectionZoneAction class represents an action on a selection zone in the
	17	* visualization.
	18	*
	19	* The action is a function that will be executed when the slot execute() is called.
	20	*/
	21	class SelectionZoneAction : public QObject {
	22
	23	Q_OBJECT
	24
	25	public:
	26	/// Signature of the function associated to the action
	27	using ExecuteFunction
	28	= std::function<void(const QVector<VisualizationSelectionZoneItem *> &item)>;
	29
	30	using EnableFunction
	31	= std::function<bool(const QVector<VisualizationSelectionZoneItem *> &item)>;
	32
	33	/**
	34	* @param name the name of the action, displayed to the user
	35	* @param fun the function that will be called when the action is executed
	36	* @sa execute()
	37	*/
	38	explicit SelectionZoneAction(const QString &name, ExecuteFunction fun);
	39
	40	/**
	41	* @param name the name of the action, displayed to the user
	42	* @param subMenusList the list of sub menus where the action should be inserted
	43	* @param fun the function that will be called when the action is executed
	44	* @sa execute()
	45	*/
	46	explicit SelectionZoneAction(const QStringList &subMenuList, const QString &name,
	47	ExecuteFunction fun);
	48
	49	/// Sets the function which determine if the action should be enabled or disabled
	50	void setEnableFunction(EnableFunction fun);
	51
	52	/// Sets the shortcut displayed by the action.
	53	/// Note: The shortcut is only displayed and not active because it is not permanently stored
	54	void setDisplayedShortcut(const QKeySequence &shortcut);
	55	QKeySequence displayedShortcut() const;
	56
	57	/// The name of the action
	58	QString name() const noexcept;
	59
	60	/// The path in the sub menus, if any
	61	QStringList subMenuList() const noexcept;
	62
	63	public slots:
	64	/// Executes the action
	65	void execute(const QVector<VisualizationSelectionZoneItem *> &item);
	66
	67	/// Returns true if the action is enabled
	68	bool isEnabled(const QVector<VisualizationSelectionZoneItem *> &item);
	69
	70	private:
	71	class SelectionZoneActionPrivate;
	72	spimpl::unique_impl_ptr<SelectionZoneActionPrivate> impl;
	73	};
	74
	75	#endif // SCIQLOP_SELECTIONZONEACTION_H

gui/include/Visualization/VisualizationActionManager.h created 644 +12 0

@@ -0,0 +1,12
	1	#ifndef SCIQLOP_VISUALIZATIONACTIONMANAGER_H
	2	#define SCIQLOP_VISUALIZATIONACTIONMANAGER_H
	3
	4
	5	class VisualizationActionManager {
	6	public:
	7	VisualizationActionManager();
	8
	9	void installSelectionZoneActions();
	10	};
	11
	12	#endif // SCIQLOP_VISUALIZATIONACTIONMANAGER_H

gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h created 644 +30 0

@@ -0,0 +1,30
	1	#ifndef SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
	2	#define SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QDialog>
	6
	7	namespace Ui {
	8	class VisualizationMultiZoneSelectionDialog;
	9	}
	10
	11	class VisualizationSelectionZoneItem;
	12
	13	class VisualizationMultiZoneSelectionDialog : public QDialog {
	14	Q_OBJECT
	15
	16	public:
	17	explicit VisualizationMultiZoneSelectionDialog(QWidget *parent = 0);
	18	~VisualizationMultiZoneSelectionDialog();
	19
	20	void setZones(const QVector<VisualizationSelectionZoneItem *> &zones);
	21	QMap<VisualizationSelectionZoneItem *, bool> selectedZones() const;
	22
	23	private:
	24	Ui::VisualizationMultiZoneSelectionDialog *ui;
	25
	26	class VisualizationMultiZoneSelectionDialogPrivate;
	27	spimpl::unique_impl_ptr<VisualizationMultiZoneSelectionDialogPrivate> impl;
	28	};
	29
	30	#endif // SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H

gui/src/Actions/ActionsGuiController.cpp created 644 +36 0

@@ -0,0 +1,36
	1	#include "Actions/ActionsGuiController.h"
	2
	3	struct ActionsGuiController::ActionsGuiControllerPrivate {
	4
	5	QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
	6	};
	7
	8	ActionsGuiController::ActionsGuiController()
	9	: impl{spimpl::make_unique_impl<ActionsGuiControllerPrivate>()}
	10	{
	11	}
	12
	13	std::shared_ptr<SelectionZoneAction>
	14	ActionsGuiController::addSectionZoneAction(const QString &name,
	15	SelectionZoneAction::ExecuteFunction function)
	16	{
	17	auto action = std::make_shared<SelectionZoneAction>(name, function);
	18	impl->m_SelectionZoneActions.push_back(action);
	19
	20	return action;
	21	}
	22
	23	std::shared_ptr<SelectionZoneAction>
	24	ActionsGuiController::addSectionZoneAction(const QStringList &subMenuList, const QString &name,
	25	SelectionZoneAction::ExecuteFunction function)
	26	{
	27	auto action = std::make_shared<SelectionZoneAction>(subMenuList, name, function);
	28	impl->m_SelectionZoneActions.push_back(action);
	29
	30	return action;
	31	}
	32
	33	QVector<std::shared_ptr<SelectionZoneAction> > ActionsGuiController::selectionZoneActions() const
	34	{
	35	return impl->m_SelectionZoneActions;
	36	}

gui/src/Actions/SelectionZoneAction.cpp created 644 +66 0

@@ -0,0 +1,66
	1	#include <Actions/SelectionZoneAction.h>
	2	#include <Visualization/VisualizationSelectionZoneItem.h>
	3
	4	Q_LOGGING_CATEGORY(LOG_SelectionZoneAction, "SelectionZoneAction")
	5
	6	struct SelectionZoneAction::SelectionZoneActionPrivate {
	7	explicit SelectionZoneActionPrivate(const QString &name, const QStringList &subMenuList,
	8	SelectionZoneAction::ExecuteFunction fun)
	9	: m_Name{name}, m_SubMenuList{subMenuList}, m_Fun{std::move(fun)}
	10	{
	11	}
	12
	13	QString m_Name;
	14	QStringList m_SubMenuList;
	15	QKeySequence m_DisplayedShortcut;
	16	SelectionZoneAction::ExecuteFunction m_Fun;
	17	SelectionZoneAction::EnableFunction m_EnableFun = [](auto zones) { return true; };
	18	};
	19
	20	SelectionZoneAction::SelectionZoneAction(const QString &name, ExecuteFunction fun)
	21	: impl{spimpl::make_unique_impl<SelectionZoneActionPrivate>(name, QStringList{},
	22	std::move(fun))}
	23	{
	24	}
	25
	26	SelectionZoneAction::SelectionZoneAction(const QStringList &subMenuList, const QString &name,
	27	SelectionZoneAction::ExecuteFunction fun)
	28	: impl{spimpl::make_unique_impl<SelectionZoneActionPrivate>(name, subMenuList,
	29	std::move(fun))}
	30	{
	31	}
	32
	33	void SelectionZoneAction::setEnableFunction(EnableFunction fun)
	34	{
	35	impl->m_EnableFun = std::move(fun);
	36	}
	37
	38	void SelectionZoneAction::setDisplayedShortcut(const QKeySequence &shortcut)
	39	{
	40	impl->m_DisplayedShortcut = shortcut;
	41	}
	42
	43	QKeySequence SelectionZoneAction::displayedShortcut() const
	44	{
	45	return impl->m_DisplayedShortcut;
	46	}
	47
	48	QString SelectionZoneAction::name() const noexcept
	49	{
	50	return impl->m_Name;
	51	}
	52
	53	QStringList SelectionZoneAction::subMenuList() const noexcept
	54	{
	55	return impl->m_SubMenuList;
	56	}
	57
	58	void SelectionZoneAction::execute(const QVector<VisualizationSelectionZoneItem *> &item)
	59	{
	60	impl->m_Fun(item);
	61	}
	62
	63	bool SelectionZoneAction::isEnabled(const QVector<VisualizationSelectionZoneItem *> &item)
	64	{
	65	return impl->m_EnableFun(item);
	66	}

gui/src/Visualization/VisualizationActionManager.cpp created 644 +109 0

@@ -0,0 +1,109
	1	#include "Visualization/VisualizationActionManager.h"
	2	#include "Visualization/VisualizationGraphWidget.h"
	3	#include "Visualization/VisualizationSelectionZoneItem.h"
	4
	5	#include <Actions/ActionsGuiController.h>
	6	#include <SqpApplication.h>
	7
	8	VisualizationActionManager::VisualizationActionManager() {}
	9
	10	void VisualizationActionManager::installSelectionZoneActions()
	11	{
	12	auto &actionController = sqpApp->actionsGuiController();
	13
	14	auto removeZonesAction
	15	= actionController.addSectionZoneAction("Remove Selected Zone(s)", [](auto zones) {
	16	for (auto selectionZone : zones) {
	17	if (auto graph = selectionZone->parentGraphWidget()) {
	18	graph->removeSelectionZone(selectionZone);
	19	}
	20	}
	21	});
	22	removeZonesAction->setDisplayedShortcut(QKeySequence::Delete);
	23
	24	auto alignEnableFuntion = [](auto items) { return items.count() > 1; };
	25
	26	// Vertical alignment actions
	27	auto alignLeftAction = actionController.addSectionZoneAction(
	28	QStringList{"Align Vertically"}, "Left", [](auto zones) {
	29	Q_ASSERT(zones.count() > 1);
	30	auto ref = zones.takeFirst();
	31	ref->alignZonesVerticallyOnLeft(zones, false);
	32	});
	33	alignLeftAction->setEnableFunction(alignEnableFuntion);
	34
	35	auto alignLeftBorderAction = actionController.addSectionZoneAction(
	36	QStringList{"Align Vertically"}, "Left Borders", [](auto zones) {
	37	Q_ASSERT(zones.count() > 1);
	38	auto ref = zones.takeFirst();
	39	ref->alignZonesVerticallyOnLeft(zones, true);
	40	});
	41	alignLeftBorderAction->setEnableFunction(alignEnableFuntion);
	42
	43	auto alignRightAction = actionController.addSectionZoneAction(
	44	QStringList{"Align Vertically"}, "Right", [](auto zones) {
	45	Q_ASSERT(zones.count() > 1);
	46	auto ref = zones.takeFirst();
	47	ref->alignZonesVerticallyOnRight(zones, false);
	48	});
	49	alignRightAction->setEnableFunction(alignEnableFuntion);
	50
	51	auto alignRightBorderAction = actionController.addSectionZoneAction(
	52	QStringList{"Align Vertically"}, "Right Borders", [](auto zones) {
	53	Q_ASSERT(zones.count() > 1);
	54	auto ref = zones.takeFirst();
	55	ref->alignZonesVerticallyOnRight(zones, true);
	56	});
	57	alignRightBorderAction->setEnableFunction(alignEnableFuntion);
	58
	59	auto alignLeftAndRightAction = actionController.addSectionZoneAction(
	60	QStringList{"Align Vertically"}, "Left and Right", [](auto zones) {
	61	Q_ASSERT(zones.count() > 1);
	62	auto ref = zones.takeFirst();
	63	ref->alignZonesVerticallyOnLeft(zones, false);
	64	ref->alignZonesVerticallyOnRight(zones, true);
	65	});
	66	alignLeftAndRightAction->setEnableFunction(alignEnableFuntion);
	67
	68	// Temporal alignment actions
	69	auto alignLeftTemporallyAction = actionController.addSectionZoneAction(
	70	QStringList{"Align Temporally"}, "Left", [](auto zones) {
	71	Q_ASSERT(zones.count() > 1);
	72	auto ref = zones.takeFirst();
	73	ref->alignZonesTemporallyOnLeft(zones, false);
	74	});
	75	alignLeftTemporallyAction->setEnableFunction(alignEnableFuntion);
	76
	77	auto alignLeftBorderTemporallyAction = actionController.addSectionZoneAction(
	78	QStringList{"Align Temporally"}, "Left Borders", [](auto zones) {
	79	Q_ASSERT(zones.count() > 1);
	80	auto ref = zones.takeFirst();
	81	ref->alignZonesTemporallyOnLeft(zones, true);
	82	});
	83	alignLeftBorderTemporallyAction->setEnableFunction(alignEnableFuntion);
	84
	85	auto alignRightTemporallyAction = actionController.addSectionZoneAction(
	86	QStringList{"Align Temporally"}, "Right", [](auto zones) {
	87	Q_ASSERT(zones.count() > 1);
	88	auto ref = zones.takeFirst();
	89	ref->alignZonesTemporallyOnRight(zones, false);
	90	});
	91	alignRightTemporallyAction->setEnableFunction(alignEnableFuntion);
	92
	93	auto alignRightBorderTemporallyAction = actionController.addSectionZoneAction(
	94	QStringList{"Align Temporally"}, "Right Borders", [](auto zones) {
	95	Q_ASSERT(zones.count() > 1);
	96	auto ref = zones.takeFirst();
	97	ref->alignZonesTemporallyOnRight(zones, true);
	98	});
	99	alignRightBorderTemporallyAction->setEnableFunction(alignEnableFuntion);
	100
	101	auto alignLeftAndRightTemporallyAction = actionController.addSectionZoneAction(
	102	QStringList{"Align Temporally"}, "Left and Right", [](auto zones) {
	103	Q_ASSERT(zones.count() > 1);
	104	auto ref = zones.takeFirst();
	105	ref->alignZonesTemporallyOnLeft(zones, false);
	106	ref->alignZonesTemporallyOnRight(zones, true);
	107	});
	108	alignLeftAndRightTemporallyAction->setEnableFunction(alignEnableFuntion);
	109	}

gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp created 644 +69 0

@@ -0,0 +1,69
	1	#include "Visualization/VisualizationMultiZoneSelectionDialog.h"
	2	#include "ui_VisualizationMultiZoneSelectionDialog.h"
	3
	4	#include "Common/DateUtils.h"
	5	#include "Visualization/VisualizationSelectionZoneItem.h"
	6
	7	const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
	8
	9	struct VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialogPrivate {
	10	QVector<VisualizationSelectionZoneItem *> m_Zones;
	11	};
	12
	13	VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialog(QWidget *parent)
	14	: QDialog(parent, Qt::Tool),
	15	ui(new Ui::VisualizationMultiZoneSelectionDialog),
	16	impl{spimpl::make_unique_impl<VisualizationMultiZoneSelectionDialogPrivate>()}
	17	{
	18	ui->setupUi(this);
	19
	20	connect(ui->buttonBox, &QDialogButtonBox::accepted, this,
	21	&VisualizationMultiZoneSelectionDialog::accept);
	22	connect(ui->buttonBox, &QDialogButtonBox::rejected, this,
	23	&VisualizationMultiZoneSelectionDialog::reject);
	24	}
	25
	26	VisualizationMultiZoneSelectionDialog::~VisualizationMultiZoneSelectionDialog()
	27	{
	28	delete ui;
	29	}
	30
	31	void VisualizationMultiZoneSelectionDialog::setZones(
	32	const QVector<VisualizationSelectionZoneItem *> &zones)
	33	{
	34	impl->m_Zones = zones;
	35
	36	// Sorts the zones to display them in temporal order
	37	std::sort(impl->m_Zones.begin(), impl->m_Zones.end(), [](auto zone1, auto zone2) {
	38	return zone1->range().m_TStart < zone2->range().m_TStart;
	39	});
	40
	41	// Adds the zones in the listwidget
	42	for (auto zone : impl->m_Zones) {
	43	auto name = zone->name();
	44	if (!name.isEmpty()) {
	45	name += tr(": ");
	46	}
	47
	48	auto range = zone->range();
	49	name += DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT);
	50	name += " - ";
	51	name += DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT);
	52
	53	auto item = new QListWidgetItem(name, ui->listWidget);
	54	item->setSelected(zone->selected());
	55	}
	56	}
	57
	58	QMap<VisualizationSelectionZoneItem *, bool>
	59	VisualizationMultiZoneSelectionDialog::selectedZones() const
	60	{
	61	QMap<VisualizationSelectionZoneItem *, bool> selectedZones;
	62
	63	for (auto i = 0; i < ui->listWidget->count(); ++i) {
	64	auto item = ui->listWidget->item(i);
	65	selectedZones[impl->m_Zones[i]] = item->isSelected();
	66	}
	67
	68	return selectedZones;
	69	}

gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui created 644 +50 0

@@ -0,0 +1,50
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>VisualizationMultiZoneSelectionDialog</class>
	4	<widget class="QDialog" name="VisualizationMultiZoneSelectionDialog">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>303</width>
	10	<height>139</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Select...</string>
	15	</property>
	16	<layout class="QVBoxLayout" name="verticalLayout">
	17	<property name="spacing">
	18	<number>6</number>
	19	</property>
	20	<property name="leftMargin">
	21	<number>0</number>
	22	</property>
	23	<property name="topMargin">
	24	<number>0</number>
	25	</property>
	26	<property name="rightMargin">
	27	<number>0</number>
	28	</property>
	29	<property name="bottomMargin">
	30	<number>0</number>
	31	</property>
	32	<item>
	33	<widget class="QListWidget" name="listWidget">
	34	<property name="selectionMode">
	35	<enum>QAbstractItemView::ExtendedSelection</enum>
	36	</property>
	37	</widget>
	38	</item>
	39	<item>
	40	<widget class="QDialogButtonBox" name="buttonBox">
	41	<property name="standardButtons">
	42	<set>QDialogButtonBox::Cancel\|QDialogButtonBox::Ok</set>
	43	</property>
	44	</widget>
	45	</item>
	46	</layout>
	47	</widget>
	48	<resources/>
	49	<connections/>
	50	</ui>

gui/include/DragAndDrop/DragDropGuiController.h ~~gui/include/DragAndDrop/DragDropHelper.h~~ renamed +9 -9

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

gui/include/SqpApplication.h +4 -2

             #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;
+            class DragDropGuiController;
+            class ActionsGuiController;
             /**
              * @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, these helpers classes are like controllers but
                 /// doesn't live in a thread and access gui
-                DragDropHelper &dragDropHelper() noexcept;
+                DragDropGuiController &dragDropGuiController() noexcept;
+                ActionsGuiController &actionsGuiController() noexcept;
                 enum class PlotsInteractionMode { None, ZoomBox, DragAndDrop, SelectionZones };
                 enum class PlotsCursorMode { NoCursor, Vertical, Temporal, Horizontal, Cross };
                 PlotsInteractionMode plotsInteractionMode() const;
                 void setPlotsInteractionMode(PlotsInteractionMode mode);
                 PlotsCursorMode plotsCursorMode() const;
                 void setPlotsCursorMode(PlotsCursorMode mode);
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/include/Visualization/VisualizationDragDropContainer.h +2 -2

             #ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
             #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
             #include <Common/spimpl.h>
             #include <QFrame>
             #include <QLoggingCategory>
             #include <QMimeData>
             #include <QVBoxLayout>
             #include <functional>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
             class VisualizationDragWidget;
             class VisualizationDragDropContainer : public QFrame {
                 Q_OBJECT
             signals:
                 void dropOccuredInContainer(int dropIndex, const QMimeData *mimeData);
                 void dropOccuredOnWidget(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             public:
                 enum class DropBehavior { Inserted, Merged, InsertedAndMerged, Forbidden };
                 using AcceptMimeDataFunction = std::function<bool(const QMimeData *mimeData)>;
                 using AcceptDragWidgetFunction
                     = std::function<bool(const VisualizationDragWidget *dragWidget, const QMimeData *mimeData)>;
                 VisualizationDragDropContainer(QWidget *parent = nullptr);
                 void addDragWidget(VisualizationDragWidget *dragWidget);
                 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
                 void setMimeType(const QString &mimeType, DropBehavior behavior);
                 int countDragWidget() const;
                 void setAcceptMimeDataFunction(AcceptMimeDataFunction fun);
                 void setAcceptDragWidgetFunction(AcceptDragWidgetFunction fun);
-                void setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+                void setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                                         const QString &placeHolderText = QString());
             protected:
                 void dragEnterEvent(QDragEnterEvent *event);
                 void dragLeaveEvent(QDragLeaveEvent *event);
                 void dragMoveEvent(QDragMoveEvent *event);
                 void dropEvent(QDropEvent *event);
             private:
                 class VisualizationDragDropContainerPrivate;
                 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
             private slots:
                 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
             };
             #endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H

gui/include/Visualization/VisualizationGraphWidget.h +4 -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 VisualizationWidget;
             class VisualizationZoneWidget;
+            class VisualizationSelectionZoneItem;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 friend class VisualizationGraphRenderingDelegate;
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 /// Returns the VisualizationZoneWidget which contains the graph or nullptr
                 VisualizationZoneWidget *parentZoneWidget() const noexcept;
                 /// Returns the main VisualizationWidget which contains the graph or nullptr
                 VisualizationWidget *parentVisualizationWidget() const;
                 /// 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;
                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
+                // Zones
                 /// Returns the ranges of all the selection zones on the graph
                 QVector<SqpRange> selectionZoneRanges() const;
                 /// Adds new selection zones in the graph
                 void addSelectionZones(const QVector<SqpRange> &ranges);
+                /// Removes the specified selection zone
+                void removeSelectionZone(VisualizationSelectionZoneItem *selectionZone);
                 /// Undo the last zoom  done with a zoom box
                 void undoZoom();
                 // 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 QPoint &position) const override;
                 QPixmap customDragPixmap(const QPoint &dragPosition) override;
                 bool isDragAllowed() const override;
                 void highlightForMerge(bool highlighted) override;
                 // Cursors
                 /// Adds or moves the vertical cursor at the specified value on the x-axis
                 void addVerticalCursor(double time);
                 /// Adds or moves the vertical cursor at the specified value on the x-axis
                 void addVerticalCursorAtViewportPosition(double position);
                 void removeVerticalCursor();
                 /// Adds or moves the vertical cursor at the specified value on the y-axis
                 void addHorizontalCursor(double value);
                 /// Adds or moves the vertical cursor at the specified value on the y-axis
                 void addHorizontalCursorAtViewportPosition(double position);
                 void removeHorizontalCursor();
             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() const 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 double click was made
                 void onMouseDoubleClick(QMouseEvent *event) noexcept;
                 /// 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/VisualizationSelectionZoneItem.h +22 -1

             #ifndef SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #define SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #include <Common/spimpl.h>
             #include <Data/SqpRange.h>
             #include <Visualization/qcustomplot.h>
+            class VisualizationGraphWidget;
             class VisualizationSelectionZoneItem : public QCPItemRect {
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);
                 virtual ~VisualizationSelectionZoneItem();
+                VisualizationGraphWidget *parentGraphWidget() const noexcept;
                 void setName(const QString &name);
                 QString name() const;
                 SqpRange range() const;
                 void setRange(double tstart, double tend);
                 void setStart(double tstart);
                 void setEnd(double tend);
                 void setColor(const QColor &color);
                 void setEditionEnabled(bool value);
                 bool isEditionEnabled() const;
+                /// Moves the item at the top of its QCPLayer. It will then receive the mouse events if multiple
+                /// items are stacked on top of each others.
+                void moveToTop();
                 Qt::CursorShape curshorShapeForPosition(const QPoint &position) const;
                 void setHovered(bool value);
+                /// Sets the zones which should be moved or reisized together with this zone
                 void setAssociatedEditedZones(const QVector<VisualizationSelectionZoneItem *> &associatedZones);
+                /// Align the specified zones with this one, vertically with the left border
+                bool alignZonesVerticallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
+                                                bool allowResize);
+                /// Align the specified zones with this one, vertically with the right border
+                bool alignZonesVerticallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
+                                                 bool allowResize);
+                /// Align the specified zones with this one, temporally with the left border
+                bool alignZonesTemporallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
+                                                bool allowResize);
+                /// Align the specified zones with this one, temporally with the right border
+                bool alignZonesTemporallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
+                                                 bool allowResize);
             protected:
                 void mousePressEvent(QMouseEvent *event, const QVariant &details) override;
                 void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void resizeLeft(double pixelDiff);
                 void resizeRight(double pixelDiff);
                 void move(double pixelDiff);
             private:
                 class VisualizationSelectionZoneItemPrivate;
                 spimpl::unique_impl_ptr<VisualizationSelectionZoneItemPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H

gui/meson.build +11 -4

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
-              'include/Visualization/ColorScaleEditor.h'
+              'include/Visualization/ColorScaleEditor.h',
+              'include/Actions/SelectionZoneAction.h',
+              'include/Visualization/VisualizationMultiZoneSelectionDialog.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui',
-              'ui/Visualization/ColorScaleEditor.ui'
+              'ui/Visualization/ColorScaleEditor.ui',
+              'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
-              'src/DragAndDrop/DragDropHelper.cpp',
+              'src/DragAndDrop/DragDropGuiController.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
-              'src/Visualization/VisualizationSelectionZoneManager.cpp'
+              'src/Visualization/VisualizationSelectionZoneManager.cpp',
+              'src/Actions/SelectionZoneAction.cpp',
+              'src/Actions/ActionsGuiController.cpp',
+              'src/Visualization/VisualizationActionManager.cpp',
+              'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/DataSource/DataSourceTreeWidget.cpp +2 -2

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

gui/src/DragAndDrop/DragDropGuiController.cpp ~~gui/src/DragAndDrop/DragDropHelper.cpp~~ renamed +35 -33

-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
-            Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
+            Q_LOGGING_CATEGORY(LOG_DragDropGuiController, "DragDropGuiController")
-            struct DragDropHelper::DragDropHelperPrivate {
+            struct DragDropGuiController::DragDropGuiControllerPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel *m_PlaceHolderLabel;
                 QWidget *m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
                 std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
                 QList<QWidget *> m_WidgetToClose;
-                explicit DragDropHelperPrivate()
+                explicit DragDropGuiControllerPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()},
                           m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                 {
                     auto layout = new QVBoxLayout{m_PlaceHolder.get()};
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
-                void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
+                void preparePlaceHolder(DragDropGuiController::PlaceHolderType type,
+                                        const QString &topLabelText) const
                 {
                     if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
                     else {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type) {
-                        case DragDropHelper::PlaceHolderType::Graph:
+                        case DragDropGuiController::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
-                        case DragDropHelper::PlaceHolderType::Zone:
+                        case DragDropGuiController::PlaceHolderType::Zone:
-                        case DragDropHelper::PlaceHolderType::Default:
+                        case DragDropGuiController::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
-            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
+            DragDropGuiController::DragDropGuiController()
+                    : impl{spimpl::make_unique_impl<DragDropGuiControllerPrivate>()}
             {
             }
-            DragDropHelper::~DragDropHelper()
+            DragDropGuiController::~DragDropGuiController()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
-            void DragDropHelper::resetDragAndDrop()
+            void DragDropGuiController::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
-            void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
+            void DragDropGuiController::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
             }
-            VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
+            VisualizationDragWidget *DragDropGuiController::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
-            QWidget &DragDropHelper::placeHolder() const
+            QWidget &DragDropGuiController::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
-            void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+            void DragDropGuiController::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
-                                                   const QString &topLabelText)
+                                                          const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
-            void DragDropHelper::removePlaceHolder()
+            void DragDropGuiController::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget) {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
                 }
             }
-            bool DragDropHelper::isPlaceHolderSet() const
+            bool DragDropGuiController::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
-            void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
+            void DragDropGuiController::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
-            void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
+            void DragDropGuiController::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
-            void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
+            void DragDropGuiController::addDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
-            void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
+            void DragDropGuiController::removeDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
-            QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
+            QUrl DragDropGuiController::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
-            void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
+            void DragDropGuiController::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
-            VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
+            VisualizationDragWidget *DragDropGuiController::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
-            void DragDropHelper::delayedCloseWidget(QWidget *widget)
+            void DragDropGuiController::delayedCloseWidget(QWidget *widget)
             {
                 widget->hide();
                 impl->m_WidgetToClose << widget;
             }
-            void DragDropHelper::doCloseWidgets()
+            void DragDropGuiController::doCloseWidgets()
             {
                 for (auto widget : impl->m_WidgetToClose) {
                     widget->close();
                 }
                 impl->m_WidgetToClose.clear();
             }
-            bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
+            bool DragDropGuiController::checkMimeDataForVisualization(
-                                                               VisualizationDragDropContainer *dropContainer)
+                const QMimeData *mimeData, VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
-                    qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                    qCWarning(LOG_DragDropGuiController()) << QObject::tr(
-                        "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
+                        "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         auto variable = variables.first();
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent) {
                                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                                 FindVariableOperation findVariableOperation{variable};
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty()) {
                                     result = true;
                                 }
                                 else {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else {
-                                qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                                qCWarning(LOG_DragDropGuiController()) << QObject::tr(
-                                    "DragDropHelper::checkMimeDataForVisualization, the parent "
+                                    "DragDropGuiController::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/SqpApplication.cpp +14 -5

             #include "SqpApplication.h"
+            #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
-                          m_DragDropHelper{std::make_unique<DragDropHelper>()},
+                          m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
                           m_CatalogueController{std::make_unique<CatalogueController>()},
+                          m_ActionsGuiController{std::make_unique<ActionsGuiController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     m_CatalogueController->moveToThread(&m_CatalogueControllerThread);
                     m_CatalogueControllerThread.setObjectName("CatalogueControllerThread");
                     // 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();
                     m_CatalogueControllerThread.quit();
                     m_CatalogueControllerThread.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;
                 std::unique_ptr<CatalogueController> m_CatalogueController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
                 QThread m_CatalogueControllerThread;
-                std::unique_ptr<DragDropHelper> m_DragDropHelper;
+                std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
+                std::unique_ptr<ActionsGuiController> m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             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);
                 connect(&impl->m_CatalogueControllerThread, &QThread::started,
                         impl->m_CatalogueController.get(), &CatalogueController::initialize);
                 connect(&impl->m_CatalogueControllerThread, &QThread::finished,
                         impl->m_CatalogueController.get(), &CatalogueController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
                 impl->m_CatalogueControllerThread.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
+            DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
+            {
+                return *impl->m_DragDropGuiController;
+            }
+            ActionsGuiController &SqpApplication::actionsGuiController() noexcept
             {
-                return *impl->m_DragDropHelper;
+                return *impl->m_ActionsGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

gui/src/TimeWidget/TimeWidget.cpp +2 -2

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QDropEvent>
             #include <QMimeData>
             struct TimeWidget::TimeWidgetPrivate {
                 explicit TimeWidgetPrivate() {}
                 QPoint m_DragStartPosition;
             };
             TimeWidget::TimeWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::TimeWidget},
                       impl{spimpl::make_unique_impl<TimeWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));
                 // Connection
                 connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                         &TimeWidget::onTimeUpdateRequested);
                 connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),
                         &TimeController::onTimeNotify);
                 // Initialisation
                 auto endDateTime = QDateTime::currentDateTimeUtc();
                 auto startDateTime = endDateTime.addSecs(-3600); // one hour before
                 ui->startDateTimeEdit->setDateTime(startDateTime);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
                 auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),
                                          DateUtils::secondsSinceEpoch(endDateTime)};
                 sqpApp->timeController().onTimeToUpdate(dateTime);
             }
             TimeWidget::~TimeWidget()
             {
                 delete ui;
             }
             void TimeWidget::setTimeRange(SqpRange time)
             {
                 auto startDateTime = DateUtils::dateTime(time.m_TStart);
                 auto endDateTime = DateUtils::dateTime(time.m_TEnd);
                 ui->startDateTimeEdit->setDateTime(startDateTime);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
             }
             SqpRange TimeWidget::timeRange() const
             {
                 return SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
                                 DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
             }
             void TimeWidget::onTimeUpdateRequested()
             {
                 auto dateTime = timeRange();
                 emit timeUpdated(std::move(dateTime));
             }
             void TimeWidget::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     event->acceptProposedAction();
                     setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
                 }
                 else {
                     event->ignore();
                 }
             }
             void TimeWidget::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 setStyleSheet(QString{});
             }
             void TimeWidget::dropEvent(QDropEvent *event)
             {
                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
                     auto timeRange = TimeController::timeRangeForMimeData(mimeData);
                     setTimeRange(timeRange);
                 }
                 else {
                     event->ignore();
                 }
                 setStyleSheet(QString{});
             }
             void TimeWidget::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                     impl->m_DragStartPosition = event->pos();
                 }
                 QWidget::mousePressEvent(event);
             }
             void TimeWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 if (!(event->buttons() & Qt::LeftButton)) {
                     return;
                 }
                 if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
                     < QApplication::startDragDistance()) {
                     return;
                 }
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{this};
                 auto mimeData = new QMimeData;
                 auto timeData = TimeController::mimeDataForTimeRange(timeRange());
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap{":/icones/time.png"};
                 drag->setPixmap(pixmap.scaledToWidth(22));
-                sqpApp->dragDropHelper().resetDragAndDrop();
+                sqpApp->dragDropGuiController().resetDragAndDrop();
                 // Note: The exec() is blocking on windows but not on linux and macOS
                 drag->exec(Qt::MoveAction | Qt::CopyAction);
                 QWidget::mouseMoveEvent(event);
             }

gui/src/Variable/VariableInspectorTableView.cpp +2 -2

             #include "Variable/VariableInspectorTableView.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent)
             {
             }
             void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
             {
                 // Resets the drag&drop operations before it's starting
-                sqpApp->dragDropHelper().resetDragAndDrop();
+                sqpApp->dragDropGuiController().resetDragAndDrop();
                 QTableView::startDrag(supportedActions);
             }

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

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

gui/src/Visualization/VisualizationDragDropContainer.cpp +20 -23

             #include "Visualization/VisualizationDragDropContainer.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Common/VisualizationDef.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             auto DRAGGED_MINIATURE_WIDTH = 200; // in pixels
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
                 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
                 QString m_PlaceHolderText;
-                DragDropHelper::PlaceHolderType m_PlaceHolderType;
+                DragDropGuiController::PlaceHolderType m_PlaceHolderType;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 VisualizationDragDropContainer::AcceptDragWidgetFunction m_AcceptDragWidgetFun
                     = [](auto dragWidget, auto mimeData) { return true; };
                 int m_MinContainerHeight = 0;
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
-                        : m_PlaceHolderType(DragDropHelper::PlaceHolderType::Graph)
+                        : m_PlaceHolderType(DragDropGuiController::PlaceHolderType::Graph)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 bool acceptMimeData(const QMimeData *data) const
                 {
                     auto accepted = false;
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         const auto &type = it.key();
                         const auto &behavior = it.value();
                         if (data->hasFormat(type)) {
                             if (behavior != DropBehavior::Forbidden) {
                                 accepted = true;
                             }
                             else {
                                 accepted = false;
                                 break;
                             }
                         }
                     }
                     if (accepted) {
                         accepted = m_AcceptMimeDataFun(data);
                     }
                     return accepted;
                 }
                 bool allowMergeForMimeData(const QMimeData *data) const
                 {
                     auto result = false;
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             result = true;
                         }
                         else if (data->hasFormat(it.key())
                                  && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
                             // Merge is forbidden if the mime data contain an acceptable type which cannot be
                             // merged
                             result = false;
                             break;
                         }
                     }
                     return result;
                 }
                 bool allowInsertForMimeData(const QMimeData *data) const
                 {
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
-                    return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
+                    return sqpApp->dragDropGuiController().placeHolder().parentWidget()
+                           == m_Layout->parentWidget();
                 }
                 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
                 {
                     VisualizationDragWidget *dragWidget = nullptr;
                     for (auto child : parent->children()) {
                         auto widget = qobject_cast<VisualizationDragWidget *>(child);
                         if (widget && widget->isVisible()) {
                             if (widget->frameGeometry().contains(pos)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 bool cursorIsInContainer(QWidget *container) const
                 {
                     auto widgetUnderMouse = sqpApp->widgetAt(QCursor::pos());
                     return container->isAncestorOf(widgetUnderMouse) && widgetUnderMouse != container
-                           && sqpApp->dragDropHelper().placeHolder().isAncestorOf(widgetUnderMouse);
+                           && sqpApp->dragDropGuiController().placeHolder().isAncestorOf(widgetUnderMouse);
                 }
                 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
                 {
                     auto nbGraph = 0;
                     for (auto child : parent->children()) {
                         if (qobject_cast<VisualizationDragWidget *>(child)) {
                             if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
                                 nbGraph += 1;
                             }
                         }
                     }
                     return nbGraph;
                 }
                 bool findPlaceHolderPosition(const QPoint &pos, const QMimeData *mimeData, bool canInsert,
                                              bool canMerge, const VisualizationDragDropContainer *container);
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
                     : QFrame{parent},
                       impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
             {
                 setAcceptDrops(true);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::setMimeType(
                 const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
             {
                 impl->m_AcceptedMimeTypes[mimeType] = behavior;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
                 return impl->countDragWidget(this);
             }
             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
             {
                 impl->m_AcceptMimeDataFun = fun;
             }
             void VisualizationDragDropContainer::setAcceptDragWidgetFunction(
                 VisualizationDragDropContainer::AcceptDragWidgetFunction fun)
             {
                 impl->m_AcceptDragWidgetFun = fun;
             }
-            void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+            void VisualizationDragDropContainer::setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                                                                     const QString &placeHolderText)
             {
                 impl->m_PlaceHolderType = type;
                 impl->m_PlaceHolderText = placeHolderText;
             }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 auto mimeData = dragWidget->mimeData(dragPosition);
                 drag->setMimeData(mimeData);
                 auto pixmap = dragWidget->customDragPixmap(dragPosition);
                 if (pixmap.isNull()) {
                     pixmap = QPixmap{dragWidget->size()};
                     dragWidget->render(&pixmap);
                 }
                 drag->setPixmap(pixmap.scaled(DRAGGED_MINIATURE_WIDTH, DRAGGED_MINIATURE_WIDTH,
                                               Qt::KeepAspectRatio, Qt::SmoothTransformation));
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
                     if (impl->acceptMimeData(mimeData) && impl->allowInsertForMimeData(mimeData)) {
                         helper.setCurrentDragWidget(dragWidget);
                         if (impl->cursorIsInContainer(this)) {
                             auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                             helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
                                                      impl->m_PlaceHolderText);
                             dragWidget->setVisible(false);
                         }
                         else {
                             // The drag starts directly outside the drop zone
                             // do not add the placeHolder
                         }
                     }
                     drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::MoveAction);
                     helper.doCloseWidgets();
                 }
                 else {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
                 }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
-                    auto &helper = sqpApp->dragDropHelper();
+                    auto &helper = sqpApp->dragDropGuiController();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
                         if (dragWidget) {
                             // If the drag&drop is internal to the visualization, entering the container hide
                             // the dragWidget which was made visible by the dragLeaveEvent
                             auto parentWidget
                                 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                             if (parentWidget) {
                                 dragWidget->setVisible(false);
                             }
                         }
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         if (!impl->findPlaceHolderPosition(event->pos(), event->mimeData(), canInsert, canMerge,
                                                            this)) {
                             event->ignore();
                         }
                     }
                     else {
                         // do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
                     helper.setHightlightedDragWidget(nullptr);
                     impl->m_MinContainerHeight = 0;
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (dragWidget) {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
                         if (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
                 else {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
                 }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                     auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                     impl->findPlaceHolderPosition(event->pos(), event->mimeData(), canInsert, canMerge, this);
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragMoveEvent(event);
             }
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (impl->hasPlaceHolder()) {
                         // drop where the placeHolder is located
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         if (canInsert) {
                             auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
                             if (dragWidget) {
                                 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     droppedIndex -= 1;
                                 }
                                 dragWidget->setVisible(true);
                             }
                             event->acceptProposedAction();
                             helper.removePlaceHolder();
                             emit dropOccuredInContainer(droppedIndex, event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer()) << tr(
                                 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
                                 "the insertion is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                     else if (helper.getHightlightedDragWidget()) {
                         // drop on the highlighted widget
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         if (canMerge) {
                             event->acceptProposedAction();
                             emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
                                       "the merge is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                 }
                 else {
                     event->ignore();
                 }
-                sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
+                sqpApp->dragDropGuiController().setHightlightedDragWidget(nullptr);
                 impl->m_MinContainerHeight = 0;
                 QWidget::dropEvent(event);
             }
             bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
                 const QPoint &pos, const QMimeData *mimeData, bool canInsert, bool canMerge,
                 const VisualizationDragDropContainer *container)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto absPos = container->mapToGlobal(pos);
                 auto isOnPlaceHolder = helper.placeHolder().isAncestorOf(sqpApp->widgetAt(absPos));
                 if (countDragWidget(container, true) == 0) {
                     // Drop on an empty container, just add the placeHolder at the top
                     helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
                 }
                 else if (!isOnPlaceHolder) {
                     auto nbDragWidget = countDragWidget(container);
                     if (nbDragWidget > 0) {
                         if (m_MinContainerHeight == 0) {
                             m_MinContainerHeight = container->size().height();
                         }
                         m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
                         auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
                         auto posY = pos.y();
                         auto dropIndex = floor(posY / graphHeight);
-                        auto zoneSize = qMin(graphHeight / 4.0, 75.0);
+                        auto zoneSize = graphHeight / 4.0;
                         auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
                         auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
                         auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
                         auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
-                        if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
+                        auto acceptMerge = m_AcceptDragWidgetFun(dragWidgetHovered, mimeData);
-                            if (isOnBottom) {
+                        if (canInsert && (isOnTop || isOnBottom || !canMerge || !acceptMerge)) {
+                            if (posY > (dropIndex + 1) * graphHeight - graphHeight / 2.0) {
                                 dropIndex += 1;
                             }
                             if (helper.getCurrentDragWidget()) {
                                 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     dropIndex += 1;
                                 }
                             }
                             if (dropIndex != placeHolderIndex) {
                                 helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
                                                          m_PlaceHolderText);
                             }
                             helper.setHightlightedDragWidget(nullptr);
                         }
                         else if (canMerge && dragWidgetHovered) {
                             // drop on the middle -> merge
                             if (hasPlaceHolder()) {
                                 helper.removePlaceHolder();
                             }
-                            if (m_AcceptDragWidgetFun(dragWidgetHovered, mimeData)) {
+                            helper.setHightlightedDragWidget(dragWidgetHovered);
-                                helper.setHightlightedDragWidget(dragWidgetHovered);
-                                return true;
-                            else {
-                                return false;
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
                                       "action.");
                         }
                     }
                     else {
-                        qCWarning(LOG_VisualizationDragDropContainer())
+                        qCInfo(LOG_VisualizationDragDropContainer())
                             << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
                                   "found in the "
                                   "container");
                     }
                 }
                 else {
                     // the mouse is hover the placeHolder
                     // Do nothing
                 }
                 return true;
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +141 -13

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationCursorItem.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
+            #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
+            #include <Actions/ActionsGuiController.h>
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
             /// Speed of a step of a wheel event for a pan, in percentage of the axis range
             const auto PAN_SPEED = 5;
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable multi selection of selection zones
             const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
             /// Format of the dates appearing in the label of a cursor
             const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
                                 const SqpRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, dataSeries, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 QCPItemRect *m_DrawingZoomRect = nullptr;
                 QStack<QPair<QCPRange, QCPRange> > m_ZoomStack;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
                 VisualizationSelectionZoneItem *m_DrawingZone = nullptr;
                 VisualizationSelectionZoneItem *m_HoveredZone = nullptr;
                 QVector<VisualizationSelectionZoneItem *> m_SelectionZones;
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
                 {
                     removeDrawingRect(plot);
                     auto axisPos = posToAxisPos(pos, plot);
                     m_DrawingZoomRect = new QCPItemRect{&plot};
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect(QCustomPlot &plot)
                 {
                     if (m_DrawingZoomRect) {
                         plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         plot.replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void startDrawingZone(const QPoint &pos, VisualizationGraphWidget *graph)
                 {
                     endDrawingZone(graph);
                     auto axisPos = posToAxisPos(pos, graph->plot());
                     m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone(VisualizationGraphWidget *graph)
                 {
                     if (m_DrawingZone) {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
                         else {
                             graph->plot().removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
                         }
                         graph->plot().replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
                     for (auto s : m_SelectionZones) {
                         s->setEditionEnabled(value);
                     }
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
                                                                 const QCustomPlot &plot) const
                 {
                     VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
                     for (auto zone : m_SelectionZones) {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
                             && distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
+                QVector<VisualizationSelectionZoneItem *> selectionZonesAt(const QPoint &pos,
+                                                                           const QCustomPlot &plot) const
+                {
+                    QVector<VisualizationSelectionZoneItem *> zones;
+                    for (auto zone : m_SelectionZones) {
+                        auto distanceToZone = zone->selectTest(pos, false);
+                        if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
+                            zones << zone;
+                        }
+                    }
+                    return zones;
+                }
+                void moveSelectionZoneOnTop(VisualizationSelectionZoneItem *zone, QCustomPlot &plot)
+                {
+                    if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone) {
+                        zone->moveToTop();
+                        m_SelectionZones.removeAll(zone);
+                        m_SelectionZones.append(zone);
+                    }
+                }
                 QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
                 }
                 bool pointIsInAxisRect(const QPointF &axisPoint, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - zoom is enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 // Init the cursors
                 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
                 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, &QCustomPlot::mouseDoubleClick, this,
                         &VisualizationGraphWidget::onMouseDoubleClick);
                 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);
             #ifdef Q_OS_MAC
                 plot().setPlottingHint(QCP::phFastPolylines, true);
             #endif
             }
             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);
             }
             VisualizationWidget *VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationWidget *>(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);
                 if (auto dataSeries = variable->dataSeries()) {
                     // Set axes properties according to the units of the data series
                     impl->m_RenderingDelegate->setAxesProperties(dataSeries);
                     // Sets rendering properties for the new plottables
                     // Warning: this method must be called after setAxesProperties(), as it can access to some
                     // axes properties that have to be initialized
                     impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
                 }
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 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(std::shared_ptr<Variable> variable)
             {
                 if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
             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");
             }
             QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<SqpRange> ranges;
                 for (auto zone : impl->m_SelectionZones) {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
             {
                 for (const auto &range : ranges) {
                     // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
                     impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
+            void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem *selectionZone)
+            {
+                parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
+                if (impl->m_HoveredZone == selectionZone) {
+                    impl->m_HoveredZone = nullptr;
+                    setCursor(Qt::ArrowCursor);
+                }
+                impl->m_SelectionZones.removeAll(selectionZone);
+                plot().removeItem(selectionZone);
+                plot().replot(QCustomPlot::rpQueuedReplot);
+            }
             void VisualizationGraphWidget::undoZoom()
             {
                 auto zoom = impl->m_ZoomStack.pop();
                 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                 axisX->setRange(zoom.first);
                 axisY->setRange(zoom.second);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             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
             {
                 auto isSpectrogram = [](const auto &variable) {
                     return std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()) != nullptr;
                 };
                 // - A spectrogram series can't be dropped on graph with existing plottables
                 // - No data series can be dropped on graph with existing spectrogram series
                 return isSpectrogram(variable)
                            ? impl->m_VariableToPlotMultiMap.empty()
                            : std::none_of(
                                  impl->m_VariableToPlotMultiMap.cbegin(), impl->m_VariableToPlotMultiMap.cend(),
                                  [isSpectrogram](const auto &entry) { return isSpectrogram(*entry.first); });
             }
             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 QPoint &position) const
             {
                 auto mimeData = new QMimeData;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
                                                                 selectionZoneItemUnderCursor->range()));
                     mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
                                                                     selectionZoneItemUnderCursor->range()));
                 }
                 else {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
                     auto zoneSize = QSizeF{qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
                                            qAbs(zoneBottomRight.y() - zoneTopLeft.y())}
                                         .toSize();
                     auto pixmap = QPixmap(zoneSize);
                     render(&pixmap, QPoint(), QRegion{QRect{zoneTopLeft.toPoint(), zoneSize}});
                     return pixmap;
                 }
                 return QPixmap();
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted) {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::addVerticalCursor(double time)
             {
                 impl->m_VerticalCursor->setPosition(time);
                 impl->m_VerticalCursor->setVisible(true);
                 auto text
                     = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
             {
                 impl->m_VerticalCursor->setAbsolutePosition(position);
                 impl->m_VerticalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto text
                     = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::removeVerticalCursor()
             {
                 impl->m_VerticalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::addHorizontalCursor(double value)
             {
                 impl->m_HorizontalCursor->setPosition(value);
                 impl->m_HorizontalCursor->setVisible(true);
                 impl->m_HorizontalCursor->setLabelText(QString::number(value));
             }
             void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
             {
                 impl->m_HorizontalCursor->setAbsolutePosition(position);
                 impl->m_HorizontalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
                 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
             }
             void VisualizationGraphWidget::removeHorizontalCursor()
             {
                 impl->m_HorizontalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             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);
                 if (auto parentZone = parentZoneWidget()) {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
                 if (impl->m_HoveredZone) {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             }
             QCustomPlot &VisualizationGraphWidget::plot() const 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 (!impl->m_ZoomStack.isEmpty()) {
                     if (!graphMenu.isEmpty()) {
                         graphMenu.addSeparator();
                     }
                     graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
                 }
+                // Selection Zone Actions
+                auto selectionZoneItem = impl->selectionZoneAt(pos, plot());
+                if (selectionZoneItem) {
+                    auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
+                    selectedItems.removeAll(selectionZoneItem);
+                    selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
+                    auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
+                    if (!zoneActions.isEmpty() && !graphMenu.isEmpty()) {
+                        graphMenu.addSeparator();
+                    }
+                    QHash<QString, QMenu *> subMenus;
+                    QHash<QString, bool> subMenusEnabled;
+                    for (auto zoneAction : zoneActions) {
+                        auto isEnabled = zoneAction->isEnabled(selectedItems);
+                        auto menu = &graphMenu;
+                        for (auto subMenuName : zoneAction->subMenuList()) {
+                            if (!subMenus.contains(subMenuName)) {
+                                menu = menu->addMenu(subMenuName);
+                                subMenus[subMenuName] = menu;
+                                subMenusEnabled[subMenuName] = isEnabled;
+                            }
+                            else {
+                                menu = subMenus.value(subMenuName);
+                                if (isEnabled) {
+                                    // The sub menu is enabled if at least one of its actions is enabled
+                                    subMenusEnabled[subMenuName] = true;
+                                }
+                            }
+                        }
+                        auto action = menu->addAction(zoneAction->name());
+                        action->setEnabled(isEnabled);
+                        action->setShortcut(zoneAction->displayedShortcut());
+                        QObject::connect(action, &QAction::triggered,
+                                         [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
+                    }
+                    for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
+                        it.value()->setEnabled(subMenusEnabled[it.key()]);
+                    }
+                }
                 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);
                     }
                 }
                 auto pos = mapFromGlobal(QCursor::pos());
                 auto axisPos = impl->posToAxisPos(pos, plot());
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(pos, axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 auto axisPos = impl->posToAxisPos(event->pos(), plot());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect) {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 else if (impl->m_DrawingZone) {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
                     // Sets the appropriate cursor shape
                     auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
                     setCursor(cursorShape);
                     // Manages the hovered zone
                     if (selectionZoneItemUnderCursor != impl->m_HoveredZone) {
                         if (impl->m_HoveredZone) {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         impl->m_HoveredZone = selectionZoneItemUnderCursor;
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 else {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
                     if (impl->m_HoveredZone) {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_HasMovedMouse = true;
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto value = event->angleDelta().x() + event->angleDelta().y();
                 if (value != 0) {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
                     impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
                     auto zoomOrientations = QFlags<Qt::Orientation>{};
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
                     ui->widget->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY) {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                         auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
                         axis->setRange(axis->range() + diff);
                         if (plot().noAntialiasingOnDrag()) {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
                 if (!isDragDropClick && isLeftClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos(), plot());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
                         if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos(), this);
                         }
                     }
                 }
                 // Allows mouse panning only in default mode
                 plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
                                                                == SqpApplication::PlotsInteractionMode::None
                                                            && !isDragDropClick);
                 // Allows zone edition only in selection zone mode without drag&drop
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
-                    if (selectionZoneItemUnderCursor && isLeftClick) {
-                        selectionZoneItemUnderCursor->setAssociatedEditedZones(
-                            parentVisualizationWidget()->selectionZoneManager().selectedItems());
+                    if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
+                        && !isMultiSelectionClick) {
+                        parentVisualizationWidget()->selectionZoneManager().select(
+                            {selectionZoneItemUnderCursor});
                     }
-                    else if (!isMultiSelectionClick && isLeftClick) {
+                    else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick) {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
                     else {
                         // No selection change
                     }
+                    if (selectionZoneItemUnderCursor && isLeftClick) {
+                        selectionZoneItemUnderCursor->setAssociatedEditedZones(
+                            parentVisualizationWidget()->selectionZoneManager().selectedItems());
+                    }
                 }
                 impl->m_HasMovedMouse = false;
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 if (impl->m_DrawingZoomRect) {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().x(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().x()};
                     auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().y()};
                     impl->removeDrawingRect(plot());
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)) {
                         impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 impl->endDrawingZone(this);
                 impl->m_IsCalibration = false;
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
-                    if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton) {
+                    if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
-                        if (!isMultiSelectionClick && !impl->m_HasMovedMouse) {
+                        && !impl->m_HasMovedMouse) {
-                            parentVisualizationWidget()->selectionZoneManager().select(
-                                {selectionZoneItemUnderCursor});
+                        auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
+                        if (zonesUnderCursor.count() > 1) {
+                            // There are multiple zones under the mouse.
+                            // Performs the selection with a selection dialog.
+                            VisualizationMultiZoneSelectionDialog dialog{this};
+                            dialog.setZones(zonesUnderCursor);
+                            dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
+                            dialog.activateWindow();
+                            dialog.raise();
+                            if (dialog.exec() == QDialog::Accepted) {
+                                auto selection = dialog.selectedZones();
+                                if (!isMultiSelectionClick) {
+                                    parentVisualizationWidget()->selectionZoneManager().clearSelection();
+                                }
+                                for (auto it = selection.cbegin(); it != selection.cend(); ++it) {
+                                    auto zone = it.key();
+                                    auto isSelected = it.value();
+                                    parentVisualizationWidget()->selectionZoneManager().setSelected(zone,
+                                                                                                    isSelected);
+                                    if (isSelected) {
+                                        // Puts the zone on top of the stack so it can be moved or resized
+                                        impl->moveSelectionZoneOnTop(zone, plot());
+                                    }
+                                }
+                            }
                         }
-                        else if (!impl->m_HasMovedMouse) {
+                        else {
-                            parentVisualizationWidget()->selectionZoneManager().setSelected(
+                            if (!isMultiSelectionClick) {
-                                selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                parentVisualizationWidget()->selectionZoneManager().select(
-                                                                  || event->button() == Qt::RightButton);
+                                    {selectionZoneItemUnderCursor});
+                                impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
+                            }
+                            else {
+                                parentVisualizationWidget()->selectionZoneManager().setSelected(
+                                    selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                                                      || event->button() == Qt::RightButton);
+                            }
                         }
                     }
                     else {
                         // No selection change
                     }
                 }
             }
             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())) {
                         impl->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()) {
                     impl->updateData(it->second, variable->dataSeries(), range);
                 }
             }

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +99 -2

             #include "Visualization/VisualizationSelectionZoneItem.h"
+            #include "Visualization/VisualizationGraphWidget.h"
+            #include "Visualization/VisualizationSelectionZoneManager.h"
+            #include "Visualization/VisualizationWidget.h"
             const QString &DEFAULT_COLOR = QStringLiteral("#E79D41");
             struct VisualizationSelectionZoneItem::VisualizationSelectionZoneItemPrivate {
                 QCustomPlot *m_Plot;
                 double m_T1 = 0;
                 double m_T2 = 0;
                 QColor m_Color;
                 bool m_IsEditionEnabled = true;
                 double m_MovedOrinalT1 = 0;
                 double m_MovedOrinalT2 = 0;
                 QCPItemStraightLine *m_LeftLine;
                 QCPItemStraightLine *m_RightLine;
                 QCPItemText *m_NameLabelItem = nullptr;
                 enum class EditionMode { NoEdition, ResizeLeft, ResizeRight, Move };
                 EditionMode m_CurrentEditionMode;
                 QVector<VisualizationSelectionZoneItem *> m_AssociatedEditedZones;
                 VisualizationSelectionZoneItemPrivate(QCustomPlot *plot)
                         : m_Plot(plot), m_Color(Qt::blue), m_CurrentEditionMode(EditionMode::NoEdition)
                 {
                 }
                 void updatePosition(VisualizationSelectionZoneItem *item)
                 {
                     item->topLeft->setCoords(m_T1, 0);
                     item->bottomRight->setCoords(m_T2, 1);
                 }
                 EditionMode getEditionMode(const QPoint &pos, const VisualizationSelectionZoneItem *zoneItem)
                 {
                     auto distanceLeft = m_LeftLine->selectTest(pos, false);
                     auto distanceRight = m_RightLine->selectTest(pos, false);
                     auto distance = zoneItem->selectTest(pos, false);
                     if (distanceRight <= distance) {
                         return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight;
                     }
                     else if (distanceLeft <= distance) {
                         return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft;
                     }
                     return VisualizationSelectionZoneItemPrivate::EditionMode::Move;
                 }
                 double pixelSizeToAxisXSize(double pixels)
                 {
                     auto axis = m_Plot->axisRect()->axis(QCPAxis::atBottom);
                     return axis->pixelToCoord(pixels) - axis->pixelToCoord(0);
                 }
+                bool alignZones(VisualizationSelectionZoneItem *referenceZone,
+                                const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool alignOnLeft,
+                                bool allowResize, bool vertically)
+                {
+                    auto result = false;
+                    auto referenceTime
+                        = alignOnLeft ? referenceZone->range().m_TStart : referenceZone->range().m_TEnd;
+                    auto referenceBottomAxis = m_Plot->axisRect()->axis(QCPAxis::atBottom);
+                    auto referenceVerticalPosition = referenceBottomAxis->coordToPixel(referenceTime);
+                    for (auto otherZone : zonesToAlign) {
+                        auto otherZoneRange = otherZone->range();
+                        auto newZoneStart = otherZoneRange.m_TStart;
+                        auto newZoneEnd = otherZoneRange.m_TEnd;
+                        auto alignedTime = referenceTime;
+                        if (vertically) {
+                            auto otherZoneAxis = otherZone->parentPlot()->axisRect()->axis(QCPAxis::atBottom);
+                            alignedTime = otherZoneAxis->pixelToCoord(referenceVerticalPosition);
+                        }
+                        if (alignOnLeft) {
+                            newZoneStart = alignedTime;
+                            if (!allowResize) {
+                                newZoneEnd = alignedTime + (otherZoneRange.m_TEnd - otherZoneRange.m_TStart);
+                            }
+                        }
+                        else { // align on right
+                            newZoneEnd = alignedTime;
+                            if (!allowResize) {
+                                newZoneStart = alignedTime - (otherZoneRange.m_TEnd - otherZoneRange.m_TStart);
+                            }
+                        }
+                        if (newZoneStart < newZoneEnd) {
+                            result = true;
+                            otherZone->setRange(newZoneStart, newZoneEnd);
+                            otherZone->parentPlot()->replot();
+                        }
+                    }
+                    return result;
+                }
             };
             VisualizationSelectionZoneItem::VisualizationSelectionZoneItem(QCustomPlot *plot)
                     : QCPItemRect(plot),
                       impl{spimpl::make_unique_impl<VisualizationSelectionZoneItemPrivate>(plot)}
             {
                 topLeft->setTypeX(QCPItemPosition::ptPlotCoords);
                 topLeft->setTypeY(QCPItemPosition::ptAxisRectRatio);
                 bottomRight->setTypeX(QCPItemPosition::ptPlotCoords);
                 bottomRight->setTypeY(QCPItemPosition::ptAxisRectRatio);
                 setSelectable(false);
                 impl->m_RightLine = new QCPItemStraightLine(plot);
                 impl->m_RightLine->point1->setParentAnchor(topRight);
                 impl->m_RightLine->point2->setParentAnchor(bottomRight);
                 impl->m_RightLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->setSelectable(false);
                 impl->m_LeftLine = new QCPItemStraightLine(plot);
                 impl->m_LeftLine->point1->setParentAnchor(topLeft);
                 impl->m_LeftLine->point2->setParentAnchor(bottomLeft);
                 impl->m_LeftLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->setSelectable(false);
                 connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_RightLine,
                         &QCPItemStraightLine::setSelected);
                 connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_LeftLine,
                         &QCPItemStraightLine::setSelected);
                 setColor(QColor(DEFAULT_COLOR));
             }
             VisualizationSelectionZoneItem::~VisualizationSelectionZoneItem()
             {
-                impl->m_Plot->removeItem(impl->m_RightLine);
-                impl->m_Plot->removeItem(impl->m_LeftLine);
+            VisualizationGraphWidget *VisualizationSelectionZoneItem::parentGraphWidget() const noexcept
+            {
+                auto parent = impl->m_Plot->parentWidget();
+                while (parent != nullptr && !qobject_cast<VisualizationGraphWidget *>(parent)) {
+                    parent = parent->parentWidget();
+                }
+                return qobject_cast<VisualizationGraphWidget *>(parent);
             }
             void VisualizationSelectionZoneItem::setName(const QString &name)
             {
                 if (name.isEmpty() && impl->m_NameLabelItem) {
                     impl->m_Plot->removeItem(impl->m_NameLabelItem);
                     impl->m_NameLabelItem = nullptr;
                 }
                 else if (!impl->m_NameLabelItem) {
                     impl->m_NameLabelItem = new QCPItemText(impl->m_Plot);
                     impl->m_NameLabelItem->setText(name);
                     impl->m_NameLabelItem->setPositionAlignment(Qt::AlignHCenter | Qt::AlignTop);
                     impl->m_NameLabelItem->setColor(impl->m_Color);
                     impl->m_NameLabelItem->position->setParentAnchor(top);
                 }
             }
             QString VisualizationSelectionZoneItem::name() const
             {
                 if (!impl->m_NameLabelItem) {
                     return QString();
                 }
                 return impl->m_NameLabelItem->text();
             }
             SqpRange VisualizationSelectionZoneItem::range() const
             {
                 SqpRange range;
                 range.m_TStart = impl->m_T1 <= impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 range.m_TEnd = impl->m_T1 > impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 return range;
             }
             void VisualizationSelectionZoneItem::setRange(double tstart, double tend)
             {
                 impl->m_T1 = tstart;
                 impl->m_T2 = tend;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setStart(double tstart)
             {
                 impl->m_T1 = tstart;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setEnd(double tend)
             {
                 impl->m_T2 = tend;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setColor(const QColor &color)
             {
                 impl->m_Color = color;
                 auto brushColor = color;
                 brushColor.setAlpha(80);
                 setBrush(QBrush(brushColor));
                 setPen(QPen(Qt::NoPen));
                 auto selectedBrushColor = brushColor;
                 selectedBrushColor.setAlpha(150);
                 setSelectedBrush(QBrush(selectedBrushColor));
                 setSelectedPen(QPen(Qt::NoPen));
                 auto linePen = QPen(color);
                 linePen.setStyle(Qt::SolidLine);
                 linePen.setWidth(4);
                 auto selectedLinePen = linePen;
                 selectedLinePen.setColor(color.darker(120));
                 selectedLinePen.setWidth(4);
                 impl->m_LeftLine->setPen(linePen);
                 impl->m_RightLine->setPen(linePen);
                 impl->m_LeftLine->setSelectedPen(selectedLinePen);
                 impl->m_RightLine->setSelectedPen(selectedLinePen);
             }
             void VisualizationSelectionZoneItem::setEditionEnabled(bool value)
             {
                 impl->m_IsEditionEnabled = value;
                 setSelectable(value);
                 if (!value) {
                     setSelected(false);
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                 }
             }
             bool VisualizationSelectionZoneItem::isEditionEnabled() const
             {
                 return impl->m_IsEditionEnabled;
             }
+            void VisualizationSelectionZoneItem::moveToTop()
+            {
+                moveToLayer(layer(), false);
+            }
             Qt::CursorShape
             VisualizationSelectionZoneItem::curshorShapeForPosition(const QPoint &position) const
             {
                 auto mode = impl->m_CurrentEditionMode
                                     == VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition
                                 ? impl->getEditionMode(position, this)
                                 : impl->m_CurrentEditionMode;
                 switch (mode) {
                     case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
                         return Qt::SizeAllCursor;
                     case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
                     case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight: // fallthrough
                         return Qt::SizeHorCursor;
                     default:
                         return Qt::ArrowCursor;
                 }
             }
             void VisualizationSelectionZoneItem::setHovered(bool value)
             {
                 if (value) {
                     auto linePen = impl->m_LeftLine->pen();
                     linePen.setStyle(Qt::DotLine);
                     linePen.setWidth(3);
                     auto selectedLinePen = impl->m_LeftLine->selectedPen();
                     ;
                     selectedLinePen.setStyle(Qt::DotLine);
                     selectedLinePen.setWidth(3);
                     impl->m_LeftLine->setPen(linePen);
                     impl->m_RightLine->setPen(linePen);
                     impl->m_LeftLine->setSelectedPen(selectedLinePen);
                     impl->m_RightLine->setSelectedPen(selectedLinePen);
                 }
                 else {
                     setColor(impl->m_Color);
                 }
             }
             void VisualizationSelectionZoneItem::setAssociatedEditedZones(
                 const QVector<VisualizationSelectionZoneItem *> &associatedZones)
             {
                 impl->m_AssociatedEditedZones = associatedZones;
                 impl->m_AssociatedEditedZones.removeAll(this);
             }
+            bool VisualizationSelectionZoneItem::alignZonesVerticallyOnLeft(
+                const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
+            {
+                return impl->alignZones(this, zonesToAlign, true, allowResize, true);
+            }
+            bool VisualizationSelectionZoneItem::alignZonesVerticallyOnRight(
+                const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
+            {
+                return impl->alignZones(this, zonesToAlign, false, allowResize, true);
+            }
+            bool VisualizationSelectionZoneItem::alignZonesTemporallyOnLeft(
+                const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
+            {
+                return impl->alignZones(this, zonesToAlign, true, allowResize, false);
+            }
+            bool VisualizationSelectionZoneItem::alignZonesTemporallyOnRight(
+                const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
+            {
+                return impl->alignZones(this, zonesToAlign, false, allowResize, false);
+            }
             void VisualizationSelectionZoneItem::mousePressEvent(QMouseEvent *event, const QVariant &details)
             {
+                Q_UNUSED(details);
                 if (isEditionEnabled() && event->button() == Qt::LeftButton) {
                     impl->m_CurrentEditionMode = impl->getEditionMode(event->pos(), this);
                     impl->m_MovedOrinalT1 = impl->m_T1;
                     impl->m_MovedOrinalT2 = impl->m_T2;
                     for (auto associatedZone : impl->m_AssociatedEditedZones) {
                         associatedZone->impl->m_MovedOrinalT1 = associatedZone->impl->m_T1;
                         associatedZone->impl->m_MovedOrinalT2 = associatedZone->impl->m_T2;
                     }
                 }
                 else {
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                     event->ignore();
                 }
             }
             void VisualizationSelectionZoneItem::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
             {
                 if (isEditionEnabled()) {
+                    if (!selected()) {
+                        // Force the item to be selected during the edition
+                        parentGraphWidget()->parentVisualizationWidget()->selectionZoneManager().setSelected(
+                            this, true);
+                    }
                     auto axis = impl->m_Plot->axisRect()->axis(QCPAxis::atBottom);
                     auto pixelDiff = event->pos().x() - startPos.x();
                     auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                     switch (impl->m_CurrentEditionMode) {
                         case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
                             setRange(impl->m_MovedOrinalT1 + diff, impl->m_MovedOrinalT2 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 associatedZone->move(pixelDiff);
                             }
                             break;
                         case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
                             setStart(impl->m_MovedOrinalT1 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 impl->m_MovedOrinalT1 < impl->m_MovedOrinalT2
                                     ? associatedZone->resizeLeft(pixelDiff)
                                     : associatedZone->resizeRight(pixelDiff);
                             }
                             break;
                         case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight:
                             setEnd(impl->m_MovedOrinalT2 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 impl->m_MovedOrinalT1 < impl->m_MovedOrinalT2
                                     ? associatedZone->resizeRight(pixelDiff)
                                     : associatedZone->resizeLeft(pixelDiff);
                             }
                             break;
                         default:
                             break;
                     }
                     for (auto associatedZone : impl->m_AssociatedEditedZones) {
                         associatedZone->parentPlot()->replot();
                     }
                 }
                 else {
                     event->ignore();
                 }
             }
             void VisualizationSelectionZoneItem::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
             {
+                Q_UNUSED(startPos);
                 if (isEditionEnabled()) {
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                 }
                 else {
                     event->ignore();
                 }
                 impl->m_AssociatedEditedZones.clear();
             }
             void VisualizationSelectionZoneItem::resizeLeft(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 if (impl->m_MovedOrinalT1 <= impl->m_MovedOrinalT2) {
                     setStart(impl->m_MovedOrinalT1 + diff);
                 }
                 else {
                     setEnd(impl->m_MovedOrinalT2 + diff);
                 }
             }
             void VisualizationSelectionZoneItem::resizeRight(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 if (impl->m_MovedOrinalT1 > impl->m_MovedOrinalT2) {
                     setStart(impl->m_MovedOrinalT1 + diff);
                 }
                 else {
                     setEnd(impl->m_MovedOrinalT2 + diff);
                 }
             }
             void VisualizationSelectionZoneItem::move(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 setRange(impl->m_MovedOrinalT1 + diff, impl->m_MovedOrinalT2 + diff);
             }

gui/src/Visualization/VisualizationSelectionZoneManager.cpp +2 -2

             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             struct VisualizationSelectionZoneManager::VisualizationSelectionZoneManagerPrivate {
                 QVector<VisualizationSelectionZoneItem *> m_SelectedItems;
             };
             VisualizationSelectionZoneManager::VisualizationSelectionZoneManager()
                     : impl{spimpl::make_unique_impl<VisualizationSelectionZoneManagerPrivate>()}
             {
             }
             void VisualizationSelectionZoneManager::select(
                 const QVector<VisualizationSelectionZoneItem *> &items)
             {
                 clearSelection();
                 for (auto item : items) {
                     setSelected(item, true);
                 }
             }
             void VisualizationSelectionZoneManager::setSelected(VisualizationSelectionZoneItem *item,
                                                                 bool value)
             {
                 if (value != item->selected()) {
                     item->setSelected(value);
-                    item->parentPlot()->replot();
+                    item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
                 }
                 if (!value && impl->m_SelectedItems.contains(item)) {
                     impl->m_SelectedItems.removeAll(item);
                 }
                 else if (value) {
                     impl->m_SelectedItems << item;
                 }
             }
             void VisualizationSelectionZoneManager::clearSelection()
             {
                 for (auto item : impl->m_SelectedItems) {
                     item->setSelected(false);
-                    item->parentPlot()->replot();
+                    item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
                 }
                 impl->m_SelectedItems.clear();
             }
             QVector<VisualizationSelectionZoneItem *> VisualizationSelectionZoneManager::selectedItems() const
             {
                 return impl->m_SelectedItems;
             }

gui/src/Visualization/VisualizationTabWidget.cpp +8 -8

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/MacScrollBarStyle.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.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;
             #ifdef Q_OS_MAC
                 std::unique_ptr<MacScrollBarStyle> m_MacScrollBarStyle = std::make_unique<MacScrollBarStyle>();
             #endif
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
             #ifdef Q_OS_MAC
                 impl->m_MacScrollBarStyle->selfInstallOn(ui->scrollArea, true);
             #endif
-                ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
+                ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 12);
                 ui->dragDropContainer->layout()->setSpacing(0);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_VARIABLE_LIST,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
-                                                                                  ui->dragDropContainer);
+                                                                                         ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
-                sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
+                sqpApp->dragDropGuiController().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
-                sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
+                sqpApp->dragDropGuiController().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 if (!variables.isEmpty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     auto zoneWidget = tabWidget->createZone(variables, index);
                     auto firstGraph = zoneWidget->firstGraph();
                     if (firstGraph) {
                         firstGraph->addSelectionZones(graphWidget->selectionZoneRanges());
                     }
                     else {
                         qCWarning(LOG_VisualizationZoneWidget())
                             << tr("VisualizationTabWidget::dropGraph, no graph added in the widget.");
                         Q_ASSERT(false);
                     }
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
                         helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }

gui/src/Visualization/VisualizationWidget.cpp +21 -3

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
+            #include "Visualization/VisualizationActionManager.h"
             #include "Visualization/VisualizationGraphWidget.h"
+            #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/operations/RescaleAxeOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             #include <QToolButton>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             struct VisualizationWidget::VisualizationWidgetPrivate {
                 std::unique_ptr<VisualizationSelectionZoneManager> m_ZoneSelectionManager = nullptr;
+                VisualizationActionManager m_ActionManager;
                 VisualizationWidgetPrivate()
                         : m_ZoneSelectionManager(std::make_unique<VisualizationSelectionZoneManager>())
                 {
                 }
             };
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationWidget},
                       impl{spimpl::make_unique_impl<VisualizationWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                     auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                              ui->tabWidget};
                     auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                     if (ui->tabWidget->count() == 1) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
                     if (widget) {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
-                sqpApp->dragDropHelper().addDragDropTabBar(ui->tabWidget->tabBar());
+                sqpApp->dragDropGuiController().addDragDropTabBar(ui->tabWidget->tabBar());
+                // Actions
+                impl->m_ActionManager.installSelectionZoneActions();
+                auto removeZoneAction = new QAction("Remove selected zone(s)");
+                removeZoneAction->setShortcut(QKeySequence::Delete);
+                connect(removeZoneAction, &QAction::triggered, [this]() {
+                    auto selection = impl->m_ZoneSelectionManager->selectedItems();
+                    for (auto selectionZone : selection) {
+                        if (auto graph = selectionZone->parentGraphWidget()) {
+                            graph->removeSelectionZone(selectionZone);
+                        }
+                    }
+                });
+                addAction(removeZoneAction);
                 // Adds default tab
                 addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             {
-                sqpApp->dragDropHelper().removeDragDropTabBar(ui->tabWidget->tabBar());
+                sqpApp->dragDropGuiController().removeDragDropTabBar(ui->tabWidget->tabBar());
                 delete ui;
             }
             VisualizationSelectionZoneManager &VisualizationWidget::selectionZoneManager() const
             {
                 return *impl->m_ZoneSelectionManager.get();
             }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
                     for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
                             = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationWidget::canDrop(const Variable &variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
             bool VisualizationWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(
                 QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 // Menu is generated only if there is a single variable
                 if (variables.size() == 1) {
                     if (auto variable = variables.first()) {
                         // Gets the containers of the variable
                         FindVariableOperation findVariableOperation{variable};
                         accept(&findVariableOperation);
                         auto variableContainers = findVariableOperation.result();
                         // Generates the actions that make it possible to visualize the variable
                         GenerateVariableMenuOperation generateVariableMenuOperation{
                             menu, variable, std::move(variableContainers)};
                         accept(&generateVariableMenuOperation);
                     }
                     else {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "selected");
                 }
             }
             void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
             {
                 // Calls the operation of removing all references to the variable in the visualization
                 auto removeVariableOperation = RemoveVariableOperation{variable};
                 accept(&removeVariableOperation);
             }
             void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
                                                      const SqpRange &range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation{variable, range};
                 accept(&rescaleVariableOperation);
             }
             void VisualizationWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes tabs in the widget
                 for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                     if (auto visualizationTabWidget
                         = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                         visualizationTabWidget->close();
                     }
                 }
                 QWidget::closeEvent(event);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +5 -5

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = qobject_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;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
-                ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Graph);
+                ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
-                                                                                  ui->dragDropContainer);
+                                                                                         ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
                     if (!mimeData) {
                         return false;
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variablesForMimeData(
                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
                         if (variables.count() != 1) {
                             return false;
                         }
                         auto variable = variables.first();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                     return true;
                 };
                 ui->dragDropContainer->setAcceptDragWidgetFunction(acceptDragWidgetFun);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 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;
             }
             VisualizationGraphWidget *VisualizationZoneWidget::firstGraph() const
             {
                 VisualizationGraphWidget *firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     if (auto visualizationGraphWidget
                         = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
                 return firstGraph;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = this->firstGraph()) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
                                                                  const QPointF &plotPosition,
                                                                  VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
                                                                     VisualizationGraphWidget &processedGraph) {
                     switch (sqpApp->plotsCursorMode()) {
                         case SqpApplication::PlotsCursorMode::Vertical:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                             break;
                         case SqpApplication::PlotsCursorMode::Temporal:
                             processedGraph.addVerticalCursor(plotPosition.x());
                             processedGraph.removeHorizontalCursor();
                             break;
                         case SqpApplication::PlotsCursorMode::Horizontal:
                             processedGraph.removeVerticalCursor();
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::Cross:
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.removeVerticalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::NoCursor:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.removeVerticalCursor();
                             break;
                     }
                 });
             }
             void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
                     processedGraph.removeHorizontalCursor();
                     processedGraph.removeVerticalCursor();
                 });
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }

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