From 0b3fbaa8bda51a0276815e543170638f6e9967db 2017-12-07 17:07:24
From: trabillard <trabillard@itlink.fr>
Date: 2017-12-07 17:07:24
Subject: [PATCH] Merge pull request #382 from SciQLop-fork develop

 Develop

---

diff --git a/gui/include/Actions/ActionsGuiController.h b/gui/include/Actions/ActionsGuiController.h
new file mode 100644
index 0000000..7dab26c
--- /dev/null
+++ b/gui/include/Actions/ActionsGuiController.h
@@ -0,0 +1,27 @@
+#ifndef SCIQLOP_ACTIONSGUICONTROLLER_H
+#define SCIQLOP_ACTIONSGUICONTROLLER_H
+
+#include <Actions/SelectionZoneAction.h>
+#include <Common/spimpl.h>
+
+#include <memory>
+
+class ActionsGuiController {
+public:
+    ActionsGuiController();
+
+    std::shared_ptr<SelectionZoneAction>
+    addSectionZoneAction(const QString &name, SelectionZoneAction::ExecuteFunction function);
+
+    std::shared_ptr<SelectionZoneAction>
+    addSectionZoneAction(const QStringList &subMenuList, const QString &name,
+                         SelectionZoneAction::ExecuteFunction function);
+
+    QVector<std::shared_ptr<SelectionZoneAction> > selectionZoneActions() const;
+
+private:
+    class ActionsGuiControllerPrivate;
+    spimpl::unique_impl_ptr<ActionsGuiControllerPrivate> impl;
+};
+
+#endif // SCIQLOP_ACTIONSGUICONTROLLER_H
diff --git a/gui/include/Actions/SelectionZoneAction.h b/gui/include/Actions/SelectionZoneAction.h
new file mode 100644
index 0000000..93f6b4b
--- /dev/null
+++ b/gui/include/Actions/SelectionZoneAction.h
@@ -0,0 +1,75 @@
+#ifndef SCIQLOP_SELECTIONZONEACTION_H
+#define SCIQLOP_SELECTIONZONEACTION_H
+
+#include <Common/spimpl.h>
+
+#include <QLoggingCategory>
+#include <QObject>
+
+#include <functional>
+
+class VisualizationSelectionZoneItem;
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_SelectionZoneAction)
+
+/**
+ * @brief The SelectionZoneAction class represents an action on a selection zone in the
+ * visualization.
+ *
+ * The action is a function that will be executed when the slot execute() is called.
+ */
+class SelectionZoneAction : public QObject {
+
+    Q_OBJECT
+
+public:
+    /// Signature of the function associated to the action
+    using ExecuteFunction
+        = std::function<void(const QVector<VisualizationSelectionZoneItem *> &item)>;
+
+    using EnableFunction
+        = std::function<bool(const QVector<VisualizationSelectionZoneItem *> &item)>;
+
+    /**
+     * @param name the name of the action, displayed to the user
+     * @param fun the function that will be called when the action is executed
+     * @sa execute()
+     */
+    explicit SelectionZoneAction(const QString &name, ExecuteFunction fun);
+
+    /**
+     * @param name the name of the action, displayed to the user
+     * @param subMenusList the list of sub menus where the action should be inserted
+     * @param fun the function that will be called when the action is executed
+     * @sa execute()
+     */
+    explicit SelectionZoneAction(const QStringList &subMenuList, const QString &name,
+                                 ExecuteFunction fun);
+
+    /// Sets the function which determine if the action should be enabled or disabled
+    void setEnableFunction(EnableFunction fun);
+
+    /// Sets the shortcut displayed by the action.
+    /// Note: The shortcut is only displayed and not active because it is not permanently stored
+    void setDisplayedShortcut(const QKeySequence &shortcut);
+    QKeySequence displayedShortcut() const;
+
+    /// The name of the action
+    QString name() const noexcept;
+
+    /// The path in the sub menus, if any
+    QStringList subMenuList() const noexcept;
+
+public slots:
+    /// Executes the action
+    void execute(const QVector<VisualizationSelectionZoneItem *> &item);
+
+    /// Returns true if the action is enabled
+    bool isEnabled(const QVector<VisualizationSelectionZoneItem *> &item);
+
+private:
+    class SelectionZoneActionPrivate;
+    spimpl::unique_impl_ptr<SelectionZoneActionPrivate> impl;
+};
+
+#endif // SCIQLOP_SELECTIONZONEACTION_H
diff --git a/gui/include/DragAndDrop/DragDropHelper.h b/gui/include/DragAndDrop/DragDropGuiController.h
similarity index 85%
rename from gui/include/DragAndDrop/DragDropHelper.h
rename to gui/include/DragAndDrop/DragDropGuiController.h
index 7274376..9d223b4 100644
--- a/gui/include/DragAndDrop/DragDropHelper.h
+++ b/gui/include/DragAndDrop/DragDropGuiController.h
@@ -1,5 +1,5 @@
-#ifndef SCIQLOP_DRAGDROPHELPER_H
-#define SCIQLOP_DRAGDROPHELPER_H
+#ifndef SCIQLOP_DRAGDROPGUICONTROLLER_H
+#define SCIQLOP_DRAGDROPGUICONTROLLER_H
 
 #include <Common/spimpl.h>
 #include <QLoggingCategory>
@@ -12,7 +12,7 @@ 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.
@@ -21,15 +21,15 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
  * 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();
-    virtual ~DragDropHelper();
+    DragDropGuiController();
+    virtual ~DragDropGuiController();
 
     /// Resets some internal variables. Must be called before any new drag&drop operation.
     void resetDragAndDrop();
@@ -68,8 +68,8 @@ public:
     void doCloseWidgets();
 
 private:
-    class DragDropHelperPrivate;
-    spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
+    class DragDropGuiControllerPrivate;
+    spimpl::unique_impl_ptr<DragDropGuiControllerPrivate> impl;
 };
 
-#endif // SCIQLOP_DRAGDROPHELPER_H
+#endif // SCIQLOP_DRAGDROPGUICONTROLLER_H
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index c9d37a2..91f5f13 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -20,7 +20,8 @@ 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
@@ -47,7 +48,8 @@ public:
 
     /// 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 };
 
diff --git a/gui/include/Visualization/VisualizationActionManager.h b/gui/include/Visualization/VisualizationActionManager.h
new file mode 100644
index 0000000..cd2255f
--- /dev/null
+++ b/gui/include/Visualization/VisualizationActionManager.h
@@ -0,0 +1,12 @@
+#ifndef SCIQLOP_VISUALIZATIONACTIONMANAGER_H
+#define SCIQLOP_VISUALIZATIONACTIONMANAGER_H
+
+
+class VisualizationActionManager {
+public:
+    VisualizationActionManager();
+
+    void installSelectionZoneActions();
+};
+
+#endif // SCIQLOP_VISUALIZATIONACTIONMANAGER_H
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
index 25150ae..b3e6436 100644
--- a/gui/include/Visualization/VisualizationDragDropContainer.h
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -9,7 +9,7 @@
 
 #include <functional>
 
-#include <DragAndDrop/DragDropHelper.h>
+#include <DragAndDrop/DragDropGuiController.h>
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
 
@@ -41,7 +41,7 @@ public:
 
     void setAcceptDragWidgetFunction(AcceptDragWidgetFunction fun);
 
-    void setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+    void setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                             const QString &placeHolderText = QString());
 
 protected:
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 56ba511..8f97ea9 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -19,6 +19,7 @@ class SqpRange;
 class Variable;
 class VisualizationWidget;
 class VisualizationZoneWidget;
+class VisualizationSelectionZoneItem;
 
 namespace Ui {
 class VisualizationGraphWidget;
@@ -56,11 +57,13 @@ public:
     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();
diff --git a/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h b/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
new file mode 100644
index 0000000..f3ebcfb
--- /dev/null
+++ b/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
@@ -0,0 +1,30 @@
+#ifndef SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
+#define SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
+
+#include <Common/spimpl.h>
+#include <QDialog>
+
+namespace Ui {
+class VisualizationMultiZoneSelectionDialog;
+}
+
+class VisualizationSelectionZoneItem;
+
+class VisualizationMultiZoneSelectionDialog : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit VisualizationMultiZoneSelectionDialog(QWidget *parent = 0);
+    ~VisualizationMultiZoneSelectionDialog();
+
+    void setZones(const QVector<VisualizationSelectionZoneItem *> &zones);
+    QMap<VisualizationSelectionZoneItem *, bool> selectedZones() const;
+
+private:
+    Ui::VisualizationMultiZoneSelectionDialog *ui;
+
+    class VisualizationMultiZoneSelectionDialogPrivate;
+    spimpl::unique_impl_ptr<VisualizationMultiZoneSelectionDialogPrivate> impl;
+};
+
+#endif // SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
diff --git a/gui/include/Visualization/VisualizationSelectionZoneItem.h b/gui/include/Visualization/VisualizationSelectionZoneItem.h
index 2bc3c93..d7b6e58 100644
--- a/gui/include/Visualization/VisualizationSelectionZoneItem.h
+++ b/gui/include/Visualization/VisualizationSelectionZoneItem.h
@@ -5,12 +5,16 @@
 #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;
 
@@ -24,11 +28,29 @@ public:
     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;
@@ -38,7 +60,6 @@ protected:
     void resizeRight(double pixelDiff);
     void move(double pixelDiff);
 
-
 private:
     class VisualizationSelectionZoneItemPrivate;
     spimpl::unique_impl_ptr<VisualizationSelectionZoneItemPrivate> impl;
diff --git a/gui/meson.build b/gui/meson.build
index d923004..6e63bb2 100644
--- a/gui/meson.build
+++ b/gui/meson.build
@@ -17,7 +17,9 @@ gui_moc_headers = [
   '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 = [
@@ -33,7 +35,8 @@ gui_ui_files = [
   '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']
@@ -44,7 +47,7 @@ gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
 
 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',
@@ -84,7 +87,11 @@ gui_sources = [
   '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'])
diff --git a/gui/src/Actions/ActionsGuiController.cpp b/gui/src/Actions/ActionsGuiController.cpp
new file mode 100644
index 0000000..b69e6c3
--- /dev/null
+++ b/gui/src/Actions/ActionsGuiController.cpp
@@ -0,0 +1,36 @@
+#include "Actions/ActionsGuiController.h"
+
+struct ActionsGuiController::ActionsGuiControllerPrivate {
+
+    QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
+};
+
+ActionsGuiController::ActionsGuiController()
+        : impl{spimpl::make_unique_impl<ActionsGuiControllerPrivate>()}
+{
+}
+
+std::shared_ptr<SelectionZoneAction>
+ActionsGuiController::addSectionZoneAction(const QString &name,
+                                           SelectionZoneAction::ExecuteFunction function)
+{
+    auto action = std::make_shared<SelectionZoneAction>(name, function);
+    impl->m_SelectionZoneActions.push_back(action);
+
+    return action;
+}
+
+std::shared_ptr<SelectionZoneAction>
+ActionsGuiController::addSectionZoneAction(const QStringList &subMenuList, const QString &name,
+                                           SelectionZoneAction::ExecuteFunction function)
+{
+    auto action = std::make_shared<SelectionZoneAction>(subMenuList, name, function);
+    impl->m_SelectionZoneActions.push_back(action);
+
+    return action;
+}
+
+QVector<std::shared_ptr<SelectionZoneAction> > ActionsGuiController::selectionZoneActions() const
+{
+    return impl->m_SelectionZoneActions;
+}
diff --git a/gui/src/Actions/SelectionZoneAction.cpp b/gui/src/Actions/SelectionZoneAction.cpp
new file mode 100644
index 0000000..0fcae06
--- /dev/null
+++ b/gui/src/Actions/SelectionZoneAction.cpp
@@ -0,0 +1,66 @@
+#include <Actions/SelectionZoneAction.h>
+#include <Visualization/VisualizationSelectionZoneItem.h>
+
+Q_LOGGING_CATEGORY(LOG_SelectionZoneAction, "SelectionZoneAction")
+
+struct SelectionZoneAction::SelectionZoneActionPrivate {
+    explicit SelectionZoneActionPrivate(const QString &name, const QStringList &subMenuList,
+                                        SelectionZoneAction::ExecuteFunction fun)
+            : m_Name{name}, m_SubMenuList{subMenuList}, m_Fun{std::move(fun)}
+    {
+    }
+
+    QString m_Name;
+    QStringList m_SubMenuList;
+    QKeySequence m_DisplayedShortcut;
+    SelectionZoneAction::ExecuteFunction m_Fun;
+    SelectionZoneAction::EnableFunction m_EnableFun = [](auto zones) { return true; };
+};
+
+SelectionZoneAction::SelectionZoneAction(const QString &name, ExecuteFunction fun)
+        : impl{spimpl::make_unique_impl<SelectionZoneActionPrivate>(name, QStringList{},
+                                                                    std::move(fun))}
+{
+}
+
+SelectionZoneAction::SelectionZoneAction(const QStringList &subMenuList, const QString &name,
+                                         SelectionZoneAction::ExecuteFunction fun)
+        : impl{spimpl::make_unique_impl<SelectionZoneActionPrivate>(name, subMenuList,
+                                                                    std::move(fun))}
+{
+}
+
+void SelectionZoneAction::setEnableFunction(EnableFunction fun)
+{
+    impl->m_EnableFun = std::move(fun);
+}
+
+void SelectionZoneAction::setDisplayedShortcut(const QKeySequence &shortcut)
+{
+    impl->m_DisplayedShortcut = shortcut;
+}
+
+QKeySequence SelectionZoneAction::displayedShortcut() const
+{
+    return impl->m_DisplayedShortcut;
+}
+
+QString SelectionZoneAction::name() const noexcept
+{
+    return impl->m_Name;
+}
+
+QStringList SelectionZoneAction::subMenuList() const noexcept
+{
+    return impl->m_SubMenuList;
+}
+
+void SelectionZoneAction::execute(const QVector<VisualizationSelectionZoneItem *> &item)
+{
+    impl->m_Fun(item);
+}
+
+bool SelectionZoneAction::isEnabled(const QVector<VisualizationSelectionZoneItem *> &item)
+{
+    return impl->m_EnableFun(item);
+}
diff --git a/gui/src/DataSource/DataSourceTreeWidget.cpp b/gui/src/DataSource/DataSourceTreeWidget.cpp
index d8bc863..c95ebcd 100644
--- a/gui/src/DataSource/DataSourceTreeWidget.cpp
+++ b/gui/src/DataSource/DataSourceTreeWidget.cpp
@@ -4,7 +4,7 @@
 #include "DataSource/DataSourceItem.h"
 #include "DataSource/DataSourceTreeWidgetItem.h"
 
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "SqpApplication.h"
 
 #include <QMimeData>
@@ -42,6 +42,6 @@ QMimeData *DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem *> items) 
 void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions)
 {
     // Resets the drag&drop operations before it's starting
-    sqpApp->dragDropHelper().resetDragAndDrop();
+    sqpApp->dragDropGuiController().resetDragAndDrop();
     QTreeWidget::startDrag(supportedActions);
 }
diff --git a/gui/src/DragAndDrop/DragDropHelper.cpp b/gui/src/DragAndDrop/DragDropGuiController.cpp
similarity index 77%
rename from gui/src/DragAndDrop/DragDropHelper.cpp
rename to gui/src/DragAndDrop/DragDropGuiController.cpp
index 88a6756..1546c22 100644
--- a/gui/src/DragAndDrop/DragDropHelper.cpp
+++ b/gui/src/DragAndDrop/DragDropGuiController.cpp
@@ -1,4 +1,4 @@
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "DragAndDrop/DragDropScroller.h"
 #include "DragAndDrop/DragDropTabSwitcher.h"
 #include "SqpApplication.h"
@@ -19,10 +19,10 @@
 #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;
@@ -40,7 +40,7 @@ struct DragDropHelper::DragDropHelperPrivate {
 
     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>()}
@@ -64,7 +64,8 @@ struct DragDropHelper::DragDropHelperPrivate {
         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());
@@ -79,12 +80,12 @@ struct DragDropHelper::DragDropHelperPrivate {
         }
 
         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 DragDropHelper::PlaceHolderType::Default:
+            case DragDropGuiController::PlaceHolderType::Zone:
+            case DragDropGuiController::PlaceHolderType::Default:
                 m_PlaceBackground->setStyleSheet(
                     "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                 m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
@@ -97,22 +98,23 @@ struct DragDropHelper::DragDropHelperPrivate {
 };
 
 
-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) {
 
@@ -129,18 +131,18 @@ void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
     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,
-                                       const QString &topLabelText)
+void DragDropGuiController::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+                                              const QString &topLabelText)
 {
     removePlaceHolder();
     impl->preparePlaceHolder(type, topLabelText);
@@ -148,7 +150,7 @@ void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHold
     impl->m_PlaceHolder->show();
 }
 
-void DragDropHelper::removePlaceHolder()
+void DragDropGuiController::removePlaceHolder()
 {
     auto parentWidget = impl->m_PlaceHolder->parentWidget();
     if (parentWidget) {
@@ -158,38 +160,38 @@ void DragDropHelper::removePlaceHolder()
     }
 }
 
-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);
@@ -208,18 +210,18 @@ void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidg
     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();
@@ -228,12 +230,12 @@ void DragDropHelper::doCloseWidgets()
     impl->m_WidgetToClose.clear();
 }
 
-bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
-                                                   VisualizationDragDropContainer *dropContainer)
+bool DragDropGuiController::checkMimeDataForVisualization(
+    const QMimeData *mimeData, VisualizationDragDropContainer *dropContainer)
 {
     if (!mimeData || !dropContainer) {
-        qCWarning(LOG_DragDropHelper()) << QObject::tr(
-            "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
+        qCWarning(LOG_DragDropGuiController()) << QObject::tr(
+            "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
         Q_ASSERT(false);
         return false;
     }
@@ -270,8 +272,8 @@ bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                     }
                 }
                 else {
-                    qCWarning(LOG_DragDropHelper()) << QObject::tr(
-                        "DragDropHelper::checkMimeDataForVisualization, the parent "
+                    qCWarning(LOG_DragDropGuiController()) << QObject::tr(
+                        "DragDropGuiController::checkMimeDataForVisualization, the parent "
                         "VisualizationWidget cannot be found. Cannot check if the variable is "
                         "already used or not.");
                 }
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index 4e676ed..c2c5337 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -1,9 +1,10 @@
 #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>
@@ -22,8 +23,9 @@ public:
               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)
     {
@@ -94,13 +96,15 @@ public:
     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;
@@ -177,9 +181,14 @@ 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
diff --git a/gui/src/TimeWidget/TimeWidget.cpp b/gui/src/TimeWidget/TimeWidget.cpp
index d3939b0..06a19b9 100644
--- a/gui/src/TimeWidget/TimeWidget.cpp
+++ b/gui/src/TimeWidget/TimeWidget.cpp
@@ -4,7 +4,7 @@
 #include <Common/DateUtils.h>
 #include <Common/MimeTypesDef.h>
 
-#include <DragAndDrop/DragDropHelper.h>
+#include <DragAndDrop/DragDropGuiController.h>
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 
@@ -145,7 +145,7 @@ void TimeWidget::mouseMoveEvent(QMouseEvent *event)
     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);
diff --git a/gui/src/Variable/VariableInspectorTableView.cpp b/gui/src/Variable/VariableInspectorTableView.cpp
index 29352d3..8d3b1ba 100644
--- a/gui/src/Variable/VariableInspectorTableView.cpp
+++ b/gui/src/Variable/VariableInspectorTableView.cpp
@@ -1,6 +1,6 @@
 #include "Variable/VariableInspectorTableView.h"
 
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "SqpApplication.h"
 
 VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent)
@@ -10,6 +10,6 @@ VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTable
 void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
 {
     // Resets the drag&drop operations before it's starting
-    sqpApp->dragDropHelper().resetDragAndDrop();
+    sqpApp->dragDropGuiController().resetDragAndDrop();
     QTableView::startDrag(supportedActions);
 }
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index 849bec7..101ceb6 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -12,7 +12,7 @@
 #include <QStyledItemDelegate>
 #include <QWidgetAction>
 
-#include <DragAndDrop/DragDropHelper.h>
+#include <DragAndDrop/DragDropGuiController.h>
 #include <SqpApplication.h>
 
 Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
diff --git a/gui/src/Visualization/VisualizationActionManager.cpp b/gui/src/Visualization/VisualizationActionManager.cpp
new file mode 100644
index 0000000..cb84119
--- /dev/null
+++ b/gui/src/Visualization/VisualizationActionManager.cpp
@@ -0,0 +1,109 @@
+#include "Visualization/VisualizationActionManager.h"
+#include "Visualization/VisualizationGraphWidget.h"
+#include "Visualization/VisualizationSelectionZoneItem.h"
+
+#include <Actions/ActionsGuiController.h>
+#include <SqpApplication.h>
+
+VisualizationActionManager::VisualizationActionManager() {}
+
+void VisualizationActionManager::installSelectionZoneActions()
+{
+    auto &actionController = sqpApp->actionsGuiController();
+
+    auto removeZonesAction
+        = actionController.addSectionZoneAction("Remove Selected Zone(s)", [](auto zones) {
+              for (auto selectionZone : zones) {
+                  if (auto graph = selectionZone->parentGraphWidget()) {
+                      graph->removeSelectionZone(selectionZone);
+                  }
+              }
+          });
+    removeZonesAction->setDisplayedShortcut(QKeySequence::Delete);
+
+    auto alignEnableFuntion = [](auto items) { return items.count() > 1; };
+
+    // Vertical alignment actions
+    auto alignLeftAction = actionController.addSectionZoneAction(
+        QStringList{"Align Vertically"}, "Left", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesVerticallyOnLeft(zones, false);
+        });
+    alignLeftAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignLeftBorderAction = actionController.addSectionZoneAction(
+        QStringList{"Align Vertically"}, "Left Borders", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesVerticallyOnLeft(zones, true);
+        });
+    alignLeftBorderAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignRightAction = actionController.addSectionZoneAction(
+        QStringList{"Align Vertically"}, "Right", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesVerticallyOnRight(zones, false);
+        });
+    alignRightAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignRightBorderAction = actionController.addSectionZoneAction(
+        QStringList{"Align Vertically"}, "Right Borders", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesVerticallyOnRight(zones, true);
+        });
+    alignRightBorderAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignLeftAndRightAction = actionController.addSectionZoneAction(
+        QStringList{"Align Vertically"}, "Left and Right", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesVerticallyOnLeft(zones, false);
+            ref->alignZonesVerticallyOnRight(zones, true);
+        });
+    alignLeftAndRightAction->setEnableFunction(alignEnableFuntion);
+
+    // Temporal alignment actions
+    auto alignLeftTemporallyAction = actionController.addSectionZoneAction(
+        QStringList{"Align Temporally"}, "Left", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesTemporallyOnLeft(zones, false);
+        });
+    alignLeftTemporallyAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignLeftBorderTemporallyAction = actionController.addSectionZoneAction(
+        QStringList{"Align Temporally"}, "Left Borders", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesTemporallyOnLeft(zones, true);
+        });
+    alignLeftBorderTemporallyAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignRightTemporallyAction = actionController.addSectionZoneAction(
+        QStringList{"Align Temporally"}, "Right", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesTemporallyOnRight(zones, false);
+        });
+    alignRightTemporallyAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignRightBorderTemporallyAction = actionController.addSectionZoneAction(
+        QStringList{"Align Temporally"}, "Right Borders", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesTemporallyOnRight(zones, true);
+        });
+    alignRightBorderTemporallyAction->setEnableFunction(alignEnableFuntion);
+
+    auto alignLeftAndRightTemporallyAction = actionController.addSectionZoneAction(
+        QStringList{"Align Temporally"}, "Left and Right", [](auto zones) {
+            Q_ASSERT(zones.count() > 1);
+            auto ref = zones.takeFirst();
+            ref->alignZonesTemporallyOnLeft(zones, false);
+            ref->alignZonesTemporallyOnRight(zones, true);
+        });
+    alignLeftAndRightTemporallyAction->setEnableFunction(alignEnableFuntion);
+}
diff --git a/gui/src/Visualization/VisualizationDragDropContainer.cpp b/gui/src/Visualization/VisualizationDragDropContainer.cpp
index 83da700..b79b8b9 100644
--- a/gui/src/Visualization/VisualizationDragDropContainer.cpp
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -1,5 +1,5 @@
 #include "Visualization/VisualizationDragDropContainer.h"
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "SqpApplication.h"
 #include "Visualization/VisualizationDragWidget.h"
 
@@ -21,7 +21,7 @@ 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; };
@@ -31,7 +31,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
     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);
@@ -104,7 +104,8 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     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
@@ -128,7 +129,7 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
     {
         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
@@ -196,7 +197,7 @@ void VisualizationDragDropContainer::setAcceptDragWidgetFunction(
     impl->m_AcceptDragWidgetFun = fun;
 }
 
-void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+void VisualizationDragDropContainer::setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                                                         const QString &placeHolderText)
 {
     impl->m_PlaceHolderType = type;
@@ -206,7 +207,7 @@ void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHol
 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
@@ -261,7 +262,7 @@ 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();
@@ -298,7 +299,7 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
 {
     Q_UNUSED(event);
 
-    auto &helper = sqpApp->dragDropHelper();
+    auto &helper = sqpApp->dragDropGuiController();
 
     if (!impl->cursorIsInContainer(this)) {
         helper.removePlaceHolder();
@@ -342,7 +343,7 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
 
 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
 {
-    auto &helper = sqpApp->dragDropHelper();
+    auto &helper = sqpApp->dragDropGuiController();
 
     if (impl->acceptMimeData(event->mimeData())) {
         auto dragWidget = helper.getCurrentDragWidget();
@@ -398,7 +399,7 @@ void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
         event->ignore();
     }
 
-    sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
+    sqpApp->dragDropGuiController().setHightlightedDragWidget(nullptr);
     impl->m_MinContainerHeight = 0;
 
     QWidget::dropEvent(event);
@@ -409,7 +410,7 @@ bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
     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));
@@ -431,7 +432,7 @@ bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
 
             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;
@@ -441,8 +442,10 @@ bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
 
             auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
 
-            if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
-                if (isOnBottom) {
+            auto acceptMerge = m_AcceptDragWidgetFun(dragWidgetHovered, mimeData);
+
+            if (canInsert && (isOnTop || isOnBottom || !canMerge || !acceptMerge)) {
+                if (posY > (dropIndex + 1) * graphHeight - graphHeight / 2.0) {
                     dropIndex += 1;
                 }
 
@@ -469,13 +472,7 @@ bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
                     helper.removePlaceHolder();
                 }
 
-                if (m_AcceptDragWidgetFun(dragWidgetHovered, mimeData)) {
-                    helper.setHightlightedDragWidget(dragWidgetHovered);
-                    return true;
-                }
-                else {
-                    return false;
-                }
+                helper.setHightlightedDragWidget(dragWidgetHovered);
             }
             else {
                 qCWarning(LOG_VisualizationDragDropContainer())
@@ -484,7 +481,7 @@ bool VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::find
             }
         }
         else {
-            qCWarning(LOG_VisualizationDragDropContainer())
+            qCInfo(LOG_VisualizationDragDropContainer())
                 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
                       "found in the "
                       "container");
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 4e0c6d9..52484ae 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -4,17 +4,19 @@
 #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>
@@ -169,6 +171,29 @@ struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
         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);
@@ -377,6 +402,20 @@ void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges
     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();
@@ -602,6 +641,53 @@ void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
         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());
     }
@@ -780,16 +866,24 @@ void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
     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());
+        }
     }
 
 
@@ -832,15 +926,49 @@ void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
     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 (!isMultiSelectionClick && !impl->m_HasMovedMouse) {
-                parentVisualizationWidget()->selectionZoneManager().select(
-                    {selectionZoneItemUnderCursor});
+        if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
+            && !impl->m_HasMovedMouse) {
+
+            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) {
-                parentVisualizationWidget()->selectionZoneManager().setSelected(
-                    selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
-                                                      || event->button() == Qt::RightButton);
+            else {
+                if (!isMultiSelectionClick) {
+                    parentVisualizationWidget()->selectionZoneManager().select(
+                        {selectionZoneItemUnderCursor});
+                    impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
+                }
+                else {
+                    parentVisualizationWidget()->selectionZoneManager().setSelected(
+                        selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                                          || event->button() == Qt::RightButton);
+                }
             }
         }
         else {
diff --git a/gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp b/gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp
new file mode 100644
index 0000000..e625b52
--- /dev/null
+++ b/gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp
@@ -0,0 +1,69 @@
+#include "Visualization/VisualizationMultiZoneSelectionDialog.h"
+#include "ui_VisualizationMultiZoneSelectionDialog.h"
+
+#include "Common/DateUtils.h"
+#include "Visualization/VisualizationSelectionZoneItem.h"
+
+const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
+
+struct VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialogPrivate {
+    QVector<VisualizationSelectionZoneItem *> m_Zones;
+};
+
+VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialog(QWidget *parent)
+        : QDialog(parent, Qt::Tool),
+          ui(new Ui::VisualizationMultiZoneSelectionDialog),
+          impl{spimpl::make_unique_impl<VisualizationMultiZoneSelectionDialogPrivate>()}
+{
+    ui->setupUi(this);
+
+    connect(ui->buttonBox, &QDialogButtonBox::accepted, this,
+            &VisualizationMultiZoneSelectionDialog::accept);
+    connect(ui->buttonBox, &QDialogButtonBox::rejected, this,
+            &VisualizationMultiZoneSelectionDialog::reject);
+}
+
+VisualizationMultiZoneSelectionDialog::~VisualizationMultiZoneSelectionDialog()
+{
+    delete ui;
+}
+
+void VisualizationMultiZoneSelectionDialog::setZones(
+    const QVector<VisualizationSelectionZoneItem *> &zones)
+{
+    impl->m_Zones = zones;
+
+    // Sorts the zones to display them in temporal order
+    std::sort(impl->m_Zones.begin(), impl->m_Zones.end(), [](auto zone1, auto zone2) {
+        return zone1->range().m_TStart < zone2->range().m_TStart;
+    });
+
+    // Adds the zones in the listwidget
+    for (auto zone : impl->m_Zones) {
+        auto name = zone->name();
+        if (!name.isEmpty()) {
+            name += tr(": ");
+        }
+
+        auto range = zone->range();
+        name += DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT);
+        name += " - ";
+        name += DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT);
+
+        auto item = new QListWidgetItem(name, ui->listWidget);
+        item->setSelected(zone->selected());
+    }
+}
+
+QMap<VisualizationSelectionZoneItem *, bool>
+VisualizationMultiZoneSelectionDialog::selectedZones() const
+{
+    QMap<VisualizationSelectionZoneItem *, bool> selectedZones;
+
+    for (auto i = 0; i < ui->listWidget->count(); ++i) {
+        auto item = ui->listWidget->item(i);
+        selectedZones[impl->m_Zones[i]] = item->isSelected();
+    }
+
+    return selectedZones;
+}
diff --git a/gui/src/Visualization/VisualizationSelectionZoneItem.cpp b/gui/src/Visualization/VisualizationSelectionZoneItem.cpp
index c29e8fc..2e5c5b2 100644
--- a/gui/src/Visualization/VisualizationSelectionZoneItem.cpp
+++ b/gui/src/Visualization/VisualizationSelectionZoneItem.cpp
@@ -1,4 +1,7 @@
 #include "Visualization/VisualizationSelectionZoneItem.h"
+#include "Visualization/VisualizationGraphWidget.h"
+#include "Visualization/VisualizationSelectionZoneManager.h"
+#include "Visualization/VisualizationWidget.h"
 
 const QString &DEFAULT_COLOR = QStringLiteral("#E79D41");
 
@@ -54,6 +57,53 @@ struct VisualizationSelectionZoneItem::VisualizationSelectionZoneItemPrivate {
         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)
@@ -94,8 +144,16 @@ VisualizationSelectionZoneItem::VisualizationSelectionZoneItem(QCustomPlot *plot
 
 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)
@@ -193,6 +251,11 @@ bool VisualizationSelectionZoneItem::isEditionEnabled() const
     return impl->m_IsEditionEnabled;
 }
 
+void VisualizationSelectionZoneItem::moveToTop()
+{
+    moveToLayer(layer(), false);
+}
+
 Qt::CursorShape
 VisualizationSelectionZoneItem::curshorShapeForPosition(const QPoint &position) const
 {
@@ -241,8 +304,34 @@ void VisualizationSelectionZoneItem::setAssociatedEditedZones(
     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);
 
@@ -262,6 +351,12 @@ void VisualizationSelectionZoneItem::mousePressEvent(QMouseEvent *event, const Q
 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);
@@ -304,6 +399,8 @@ void VisualizationSelectionZoneItem::mouseMoveEvent(QMouseEvent *event, const QP
 
 void VisualizationSelectionZoneItem::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
 {
+    Q_UNUSED(startPos);
+
     if (isEditionEnabled()) {
         impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
     }
diff --git a/gui/src/Visualization/VisualizationSelectionZoneManager.cpp b/gui/src/Visualization/VisualizationSelectionZoneManager.cpp
index f90009b..ee679ce 100644
--- a/gui/src/Visualization/VisualizationSelectionZoneManager.cpp
+++ b/gui/src/Visualization/VisualizationSelectionZoneManager.cpp
@@ -24,7 +24,7 @@ void VisualizationSelectionZoneManager::setSelected(VisualizationSelectionZoneIt
 {
     if (value != item->selected()) {
         item->setSelected(value);
-        item->parentPlot()->replot();
+        item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
     }
 
     if (!value && impl->m_SelectedItems.contains(item)) {
@@ -39,7 +39,7 @@ void VisualizationSelectionZoneManager::clearSelection()
 {
     for (auto item : impl->m_SelectedItems) {
         item->setSelected(false);
-        item->parentPlot()->replot();
+        item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
     }
 
     impl->m_SelectedItems.clear();
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index ff28657..ff81937 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -11,7 +11,7 @@
 
 #include "Common/MimeTypesDef.h"
 
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "SqpApplication.h"
 
 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
@@ -78,7 +78,7 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
     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,
@@ -89,14 +89,14 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
                                        VisualizationDragDropContainer::DropBehavior::Inserted);
 
     ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-        return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
-                                                                      ui->dragDropContainer);
+        return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
+                                                                             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);
@@ -104,7 +104,7 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
 
 VisualizationTabWidget::~VisualizationTabWidget()
 {
-    sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
+    sqpApp->dragDropGuiController().removeDragDropScrollArea(ui->scrollArea);
     delete ui;
 }
 
@@ -213,7 +213,7 @@ void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
 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) {
@@ -286,7 +286,7 @@ void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
 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) {
diff --git a/gui/src/Visualization/VisualizationWidget.cpp b/gui/src/Visualization/VisualizationWidget.cpp
index 91d1ce7..f406a0e 100644
--- a/gui/src/Visualization/VisualizationWidget.cpp
+++ b/gui/src/Visualization/VisualizationWidget.cpp
@@ -1,6 +1,8 @@
 #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"
@@ -12,7 +14,7 @@
 
 #include "ui_VisualizationWidget.h"
 
-#include "DragAndDrop/DragDropHelper.h"
+#include "DragAndDrop/DragDropGuiController.h"
 #include "SqpApplication.h"
 
 #include <QToolButton>
@@ -23,6 +25,7 @@ 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>())
@@ -84,7 +87,22 @@ VisualizationWidget::VisualizationWidget(QWidget *parent)
     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();
@@ -92,7 +110,7 @@ VisualizationWidget::VisualizationWidget(QWidget *parent)
 
 VisualizationWidget::~VisualizationWidget()
 {
-    sqpApp->dragDropHelper().removeDragDropTabBar(ui->tabWidget->tabBar());
+    sqpApp->dragDropGuiController().removeDragDropTabBar(ui->tabWidget->tabBar());
     delete ui;
 }
 
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 6c93f50..64f7413 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -16,7 +16,7 @@
 
 #include <Visualization/operations/FindVariableOperation.h>
 
-#include <DragAndDrop/DragDropHelper.h>
+#include <DragAndDrop/DragDropGuiController.h>
 #include <QUuid>
 #include <SqpApplication.h>
 #include <cmath>
@@ -86,7 +86,7 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
 
     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(
@@ -98,8 +98,8 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
     ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                        VisualizationDragDropContainer::DropBehavior::Forbidden);
     ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-        return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
-                                                                      ui->dragDropContainer);
+        return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
+                                                                             ui->dragDropContainer);
     });
 
     auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
@@ -501,7 +501,7 @@ void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragW
 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) {
diff --git a/gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui b/gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui
new file mode 100644
index 0000000..8bb98fb
--- /dev/null
+++ b/gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>VisualizationMultiZoneSelectionDialog</class>
+ <widget class="QDialog" name="VisualizationMultiZoneSelectionDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>303</width>
+    <height>139</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Select...</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="spacing">
+    <number>6</number>
+   </property>
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <widget class="QListWidget" name="listWidget">
+     <property name="selectionMode">
+      <enum>QAbstractItemView::ExtendedSelection</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>