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

                 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;

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

                 /// 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);

gui/meson.build +3 -1

               '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 = [
               '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',

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

             struct ActionsGuiController::ActionsGuiControllerPrivate {
                 QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
+                QSet<QStringList> m_FilteredMenu;
             };
             ActionsGuiController::ActionsGuiController()
             {
                 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

                 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)
                 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);

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

                     {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"),
                         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()

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

             #include "ui_VisualizationGraphWidget.h"
             #include <Actions/ActionsGuiController.h>
+            #include <Actions/FilteringAction.h>
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
                         &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);
                     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) {

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