GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1382:eb278710ae3b

LineEdit to filter the create catalogue menu

trabillard -

r1382:eb278710ae3b

parent child

Context file:

r1382:eb278710ae3b

gui/include/Actions/FilteringAction.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_FILTERINGACTION_H
	2	#define SCIQLOP_FILTERINGACTION_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QWidgetAction>
	6
	7	/// A LineEdit inside an action which is able to filter other actions
	8	class FilteringAction : public QWidgetAction {
	9	public:
	10	FilteringAction(QWidget *parent);
	11
	12	void addActionToFilter(QAction *action);
	13
	14	private:
	15	class FilteringActionPrivate;
	16	spimpl::unique_impl_ptr<FilteringActionPrivate> impl;
	17	};
	18
	19	#endif // SCIQLOP_FILTERINGACTION_H

gui/src/Actions/FilteringAction.cpp created 644 +27 0

@@ -0,0 +1,27
	1	#include "Actions/FilteringAction.h"
	2
	3	#include <QLineEdit>
	4
	5	struct FilteringAction::FilteringActionPrivate {
	6	QLineEdit *m_FilterLineEdit;
	7	QVector<QAction *> m_FilteredActions;
	8	};
	9
	10	FilteringAction::FilteringAction(QWidget *parent)
	11	: QWidgetAction(parent), impl{spimpl::make_unique_impl<FilteringActionPrivate>()}
	12	{
	13	impl->m_FilterLineEdit = new QLineEdit(parent);
	14	setDefaultWidget(impl->m_FilterLineEdit);
	15
	16	connect(impl->m_FilterLineEdit, &QLineEdit::textEdited, [this](auto text) {
	17	for (auto action : impl->m_FilteredActions) {
	18	auto match = action->text().contains(text, Qt::CaseInsensitive);
	19	action->setVisible(match);
	20	}
	21	});
	22	}
	23
	24	void FilteringAction::addActionToFilter(QAction *action)
	25	{
	26	impl->m_FilteredActions << action;
	27	}

gui/include/Actions/ActionsGuiController.h +6 0

             #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;
                 void removeAction(const std::shared_ptr<SelectionZoneAction> &action);
+                /// Sets a flag to say that the specified menu can be filtered, usually via a FilteringAction
+                void addFilterForMenu(const QStringList &menuPath);
+                /// Returns true if the menu can be filtered
+                bool isMenuFiltered(const QStringList &menuPath) const;
             private:
                 class ActionsGuiControllerPrivate;
                 spimpl::unique_impl_ptr<ActionsGuiControllerPrivate> impl;
             };
             #endif // SCIQLOP_ACTIONSGUICONTROLLER_H

gui/include/Actions/SelectionZoneAction.h +7 0

             #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;
+                /// Sets if filtering the action is allowed via a FilteringAction
+                void setAllowedFiltering(bool value);
+                /// Returns true if filtering the action is allowed via a FilteringAction. By default it is
+                /// allowed.
+                bool isFilteringAllowed() const;
             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

gui/meson.build +3 -1

             qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
             catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
             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/VisualizationSelectionZoneItem.h',
               'include/Actions/SelectionZoneAction.h',
               'include/Visualization/VisualizationMultiZoneSelectionDialog.h',
               'include/Catalogue/CatalogueExplorer.h',
               'include/Catalogue/CatalogueEventsWidget.h',
               'include/Catalogue/CatalogueSideBarWidget.h',
               'include/Catalogue/CatalogueInspectorWidget.h',
               'include/Catalogue/CatalogueEventsModel.h',
-              'include/Catalogue/CatalogueTreeModel.h'
+              'include/Catalogue/CatalogueTreeModel.h',
+              'include/Actions/FilteringAction.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/VisualizationMultiZoneSelectionDialog.ui',
               'ui/Catalogue/CatalogueExplorer.ui',
               'ui/Catalogue/CatalogueEventsWidget.ui',
               'ui/Catalogue/CatalogueSideBarWidget.ui',
               'ui/Catalogue/CatalogueInspectorWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : [
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@',
                              '@EXTRA_ARGS@'])
             rcc_files = rcc_gen.process(gui_qresources, extra_args : ['-name', 'sqpguiresources'])
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files)
             gui_sources = [
               'src/SqpApplication.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/Actions/SelectionZoneAction.cpp',
               'src/Actions/ActionsGuiController.cpp',
+              'src/Actions/FilteringAction.cpp',
               'src/Visualization/VisualizationActionManager.cpp',
               'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp',
               'src/Catalogue/CatalogueExplorer.cpp',
               'src/Catalogue/CatalogueEventsWidget.cpp',
               'src/Catalogue/CatalogueSideBarWidget.cpp',
               'src/Catalogue/CatalogueInspectorWidget.cpp',
               'src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp',
               'src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp',
               'src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp',
               'src/Catalogue/CatalogueEventsModel.cpp',
               'src/Catalogue/CatalogueExplorerHelper.cpp',
               'src/Catalogue/CatalogueActionManager.cpp',
               'src/Catalogue/CatalogueTreeModel.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    rcc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep])

gui/src/Actions/ActionsGuiController.cpp +11 0

             #include "Actions/ActionsGuiController.h"
             struct ActionsGuiController::ActionsGuiControllerPrivate {
                 QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
+                QSet<QStringList> m_FilteredMenu;
             };
             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;
             }
             void ActionsGuiController::removeAction(const std::shared_ptr<SelectionZoneAction> &action)
             {
                 impl->m_SelectionZoneActions.removeAll(action);
             }
+            void ActionsGuiController::addFilterForMenu(const QStringList &menuPath)
+            {
+                impl->m_FilteredMenu.insert(menuPath);
+            }
+            bool ActionsGuiController::isMenuFiltered(const QStringList &menuPath) const
+            {
+                return impl->m_FilteredMenu.contains(menuPath);
+            }

gui/src/Actions/SelectionZoneAction.cpp +11 0

             #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; };
+                bool m_FilteringAllowed = 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::setAllowedFiltering(bool value)
+            {
+                impl->m_FilteringAllowed = value;
+            }
+            bool SelectionZoneAction::isFilteringAllowed() const
+            {
+                return impl->m_FilteringAllowed;
+            }
             void SelectionZoneAction::execute(const QVector<VisualizationSelectionZoneItem *> &item)
             {
                 impl->m_Fun(item);
             }
             bool SelectionZoneAction::isEnabled(const QVector<VisualizationSelectionZoneItem *> &item)
             {
                 return impl->m_EnableFun(item);
             }

gui/src/Catalogue/CatalogueActionManager.cpp +4 -1

             #include "Catalogue/CatalogueActionManager.h"
             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationSelectionZoneItem.h>
             #include <Catalogue/CatalogueEventsWidget.h>
             #include <Catalogue/CatalogueExplorer.h>
             #include <Catalogue/CatalogueSideBarWidget.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <QBoxLayout>
             #include <QComboBox>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QLineEdit>
             #include <memory>
             const auto CATALOGUE_MENU_NAME = QObject::tr("Catalogues");
             const auto CATALOGUE_CREATE_EVENT_MENU_NAME = QObject::tr("New Event...");
             const auto DEFAULT_EVENT_NAME = QObject::tr("Event");
             const auto DEFAULT_CATALOGUE_NAME = QObject::tr("Catalogue");
             struct CatalogueActionManager::CatalogueActionManagerPrivate {
                 CatalogueExplorer *m_CatalogueExplorer = nullptr;
                 QVector<std::shared_ptr<SelectionZoneAction> > m_CreateInCatalogueActions;
                 CatalogueActionManagerPrivate(CatalogueExplorer *catalogueExplorer)
                         : m_CatalogueExplorer(catalogueExplorer)
                 {
                 }
                 void createEventFromZones(const QString &eventName,
                                           const QVector<VisualizationSelectionZoneItem *> &zones,
                                           const std::shared_ptr<DBCatalogue> &catalogue = nullptr)
                 {
                     auto event = std::make_shared<DBEvent>();
                     event->setName(eventName);
                     std::list<DBEventProduct> productList;
                     for (auto zone : zones) {
                         auto graph = zone->parentGraphWidget();
                         for (auto var : graph->variables()) {
                             auto eventProduct = std::make_shared<DBEventProduct>();
                             eventProduct->setEvent(*event);
                             auto productId
                                 = var->metadata().value(DataSourceItem::ID_DATA_KEY, "UnknownID").toString();
                             auto zoneRange = zone->range();
                             eventProduct->setTStart(zoneRange.m_TStart);
                             eventProduct->setTEnd(zoneRange.m_TEnd);
                             eventProduct->setProductId(productId);
                             productList.push_back(*eventProduct);
                         }
                     }
                     event->setEventProducts(productList);
                     sqpApp->catalogueController().addEvent(event);
                     if (catalogue) {
                         catalogue->addEvent(event->getUniqId());
                         sqpApp->catalogueController().updateCatalogue(catalogue);
                         m_CatalogueExplorer->sideBarWidget().setCatalogueChanges(catalogue, true);
                         if (m_CatalogueExplorer->eventsWidget().displayedCatalogues().contains(catalogue)) {
                             m_CatalogueExplorer->eventsWidget().addEvent(event);
                             m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                         }
                     }
                     else if (m_CatalogueExplorer->eventsWidget().isAllEventsDisplayed()) {
                         m_CatalogueExplorer->eventsWidget().addEvent(event);
                         m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                     }
                 }
                 SelectionZoneAction::EnableFunction createEventEnableFuntion() const
                 {
                     return [](auto zones) {
                         // Checks that all variables in the zones doesn't refer to the same product
                         QSet<QString> usedDatasource;
                         for (auto zone : zones) {
                             auto graph = zone->parentGraphWidget();
                             auto variables = graph->variables();
                             for (auto var : variables) {
                                 auto datasourceId
                                     = var->metadata().value(DataSourceItem::ID_DATA_KEY).toString();
                                 if (!usedDatasource.contains(datasourceId)) {
                                     usedDatasource.insert(datasourceId);
                                 }
                                 else {
                                     return false;
                                 }
                             }
                         }
                         return true;
                     };
                 }
             };
             CatalogueActionManager::CatalogueActionManager(CatalogueExplorer *catalogueExplorer)
                     : impl{spimpl::make_unique_impl<CatalogueActionManagerPrivate>(catalogueExplorer)}
             {
             }
             void CatalogueActionManager::installSelectionZoneActions()
             {
                 auto &actionController = sqpApp->actionsGuiController();
                 auto createEventAction = actionController.addSectionZoneAction(
                     {CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME}, QObject::tr("Without Catalogue"),
                     [this](auto zones) { impl->createEventFromZones(DEFAULT_EVENT_NAME, zones); });
                 createEventAction->setEnableFunction(impl->createEventEnableFuntion());
+                createEventAction->setAllowedFiltering(false);
                 auto createEventInNewCatalogueAction = actionController.addSectionZoneAction(
                     {CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME}, QObject::tr("In New Catalogue"),
                     [this](auto zones) {
                         auto newCatalogue = std::make_shared<DBCatalogue>();
                         newCatalogue->setName(DEFAULT_CATALOGUE_NAME);
                         sqpApp->catalogueController().addCatalogue(newCatalogue);
                         impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(newCatalogue,
                                                                                 REPOSITORY_DEFAULT);
                         impl->createEventFromZones(DEFAULT_EVENT_NAME, zones, newCatalogue);
                     });
                 createEventInNewCatalogueAction->setEnableFunction(impl->createEventEnableFuntion());
+                createEventInNewCatalogueAction->setAllowedFiltering(false);
                 refreshCreateInCatalogueAction();
+                actionController.addFilterForMenu({CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME});
             }
             void CatalogueActionManager::refreshCreateInCatalogueAction()
             {
                 auto &actionController = sqpApp->actionsGuiController();
                 for (auto action : impl->m_CreateInCatalogueActions) {
                     actionController.removeAction(action);
                 }
                 impl->m_CreateInCatalogueActions.clear();
                 auto allCatalogues
                     = impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT);
                 for (auto catalogue : allCatalogues) {
                     auto catalogueName = catalogue->getName();
                     auto createEventInCatalogueAction = actionController.addSectionZoneAction(
                         {CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME},
                         QObject::tr("In \"").append(catalogueName).append("\""), [this, catalogue](auto zones) {
                             impl->createEventFromZones(DEFAULT_EVENT_NAME, zones, catalogue);
                         });
                     createEventInCatalogueAction->setEnableFunction(impl->createEventEnableFuntion());
                     impl->m_CreateInCatalogueActions << createEventInCatalogueAction;
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +26 -6

             #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 <Actions/FilteringAction.h>
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.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_Flags{GraphFlag::EnableAll},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                 const SqpRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, 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;
                 GraphFlags m_Flags;
                 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
                 bool m_VariableAutoRangeOnInit = true;
                 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);
+                    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);
                 // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                 plot().setPlottingHint(QCP::phFastPolylines, true);
             }
             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::setFlags(GraphFlags flags)
             {
                 impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 /// Lambda used to set graph's units and range according to the variable passed in parameter
                 auto loadRange = [this](std::shared_ptr<Variable> variable, const SqpRange &range) {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                     this->setFlags(GraphFlag::DisableAll);
                     setGraphRange(range);
                     this->setFlags(GraphFlag::EnableAll);
                     emit requestDataLoading({variable}, range, false);
                 };
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 // Calls update of graph's range and units when the data of the variable have been initialized.
                 // Note: we use QueuedConnection here as the update event must be called in the UI thread
                 connect(variable.get(), &Variable::dataInitialized, this,
                         [ varW = std::weak_ptr<Variable>{variable}, range, loadRange, this ]() {
                             if (auto var = varW.lock()) {
                                 // If the variable is the first added in the graph, we load its range
                                 auto firstVariableInGraph = range == INVALID_RANGE;
                                 auto loadedRange = graphRange();
                                 if (impl->m_VariableAutoRangeOnInit) {
                                     loadedRange = firstVariableInGraph ? var->range() : range;
                                 }
                                 loadRange(var, loadedRange);
                                 setYRange(var);
                             }
                         },
                         Qt::QueuedConnection);
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 // Sets graph properties
                 impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 // If the variable already has its data loaded, load its units and its range in the graph
                 if (variable->dataSeries() != nullptr) {
                     loadRange(variable, range);
                 }
                 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, bool calibration)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 if (calibration) {
                     impl->m_IsCalibration = true;
                 }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 if (calibration) {
                     impl->m_IsCalibration = false;
                 }
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::setAutoRangeOnVariableInitialization(bool value)
             {
                 impl->m_VariableAutoRangeOnInit = value;
             }
             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);
             }
             VisualizationSelectionZoneItem *VisualizationGraphWidget::addSelectionZone(const QString &name,
                                                                                        const SqpRange &range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
                 zone->setName(name);
                 zone->setRange(range.m_TStart, range.m_TEnd);
                 impl->addSelectionZone(zone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
                 return zone;
             }
             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);
                 for (auto i : impl->m_SelectionZones) {
                     parentVisualizationWidget()->selectionZoneManager().setSelected(i, false);
                 }
                 // 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;
+                    QHash<QString, FilteringAction *> filteredMenu;
                     for (auto zoneAction : zoneActions) {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
+                        QString menuPath;
                         for (auto subMenuName : zoneAction->subMenuList()) {
-                            if (!subMenus.contains(subMenuName)) {
+                            menuPath += '/';
+                            menuPath += subMenuName;
+                            if (!subMenus.contains(menuPath)) {
                                 menu = menu->addMenu(subMenuName);
-                                subMenus[subMenuName] = menu;
+                                subMenus[menuPath] = menu;
-                                subMenusEnabled[subMenuName] = isEnabled;
+                                subMenusEnabled[menuPath] = isEnabled;
                             }
                             else {
-                                menu = subMenus.value(subMenuName);
+                                menu = subMenus.value(menuPath);
                                 if (isEnabled) {
                                     // The sub menu is enabled if at least one of its actions is enabled
-                                    subMenusEnabled[subMenuName] = true;
+                                    subMenusEnabled[menuPath] = true;
                                 }
                             }
                         }
+                        FilteringAction *filterAction = nullptr;
+                        if (sqpApp->actionsGuiController().isMenuFiltered(zoneAction->subMenuList())) {
+                            filterAction = filteredMenu.value(menuPath);
+                            if (!filterAction) {
+                                filterAction = new FilteringAction{this};
+                                filteredMenu[menuPath] = filterAction;
+                                menu->addAction(filterAction);
+                            }
+                        }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                                          [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
+                        if (filterAction && zoneAction->isFilteringAllowed()) {
+                            filterAction->addActionToFilter(action);
+                        }
                     }
                     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_Flags.testFlag(GraphFlag::EnableAcquisition);
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
                     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_Flags.testFlag(GraphFlag::EnableSynchronization) && !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";
                 }
                 // Quits calibration
                 impl->m_IsCalibration = false;
             }
             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 && !selectionZoneItemUnderCursor->selected()
                         && !isMultiSelectionClick) {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             {selectionZoneItemUnderCursor});
                     }
                     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);
                 // 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
                         && !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 (!isMultiSelectionClick) {
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     {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, 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, range);
                 }
             }

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