GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1383:4dfca649988f

Merge branch 'feature/CataloguePart7' into develop

trabillard -

r1383:4dfca649988f

parent child

Context file:

r1383:4dfca649988f

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 +8 0

                 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;

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/include/Catalogue/CatalogueActionManager.h +1 0

                 CatalogueActionManager(CatalogueExplorer *catalogueExplorer);
                 void installSelectionZoneActions();
+                void refreshCreateInCatalogueAction();
             private:
                 class CatalogueActionManagerPrivate;

gui/include/Catalogue/CatalogueSideBarWidget.h +1 0

                 void trashSelected();
                 void selectionCleared();
                 void catalogueSaved(const std::shared_ptr<DBCatalogue> &catalogue);
+                void catalogueListChanged();
             public:
                 explicit CatalogueSideBarWidget(QWidget *parent = 0);

gui/include/Catalogue/CatalogueTreeItems/CatalogueTreeItem.h +1 0

                 /// Returns the catalogue represented by the item
                 std::shared_ptr<DBCatalogue> catalogue() const;
+                void replaceCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
             private:
                 class CatalogueTreeItemPrivate;

gui/meson.build +4 -5

               'include/Catalogue/CatalogueSideBarWidget.h',
               'include/Catalogue/CatalogueInspectorWidget.h',
               'include/Catalogue/CatalogueEventsModel.h',
-              'include/Catalogue/CreateEventDialog.h',
+              'include/Catalogue/CatalogueTreeModel.h',
-              'include/Catalogue/CatalogueTreeModel.h'
+              'include/Actions/FilteringAction.h'
             ]
             gui_ui_files = [
               'ui/Catalogue/CatalogueExplorer.ui',
               'ui/Catalogue/CatalogueEventsWidget.ui',
               'ui/Catalogue/CatalogueSideBarWidget.ui',
-              'ui/Catalogue/CatalogueInspectorWidget.ui',
+              'ui/Catalogue/CatalogueInspectorWidget.ui'
-              'ui/Catalogue/CreateEventDialog.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
               '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/CatalogueEventsModel.cpp',
               'src/Catalogue/CatalogueExplorerHelper.cpp',
               'src/Catalogue/CatalogueActionManager.cpp',
-              'src/Catalogue/CreateEventDialog.cpp',
               'src/Catalogue/CatalogueTreeModel.cpp'
             ]

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

@@ -3,6 +3,7
3	struct ActionsGuiController::ActionsGuiControllerPrivate {	3	struct ActionsGuiController::ActionsGuiControllerPrivate {
4		4
5	QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;	5	QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
		6	QSet<QStringList> m_FilteredMenu;
6	};	7	};
7		8
8	ActionsGuiController::ActionsGuiController()	9	ActionsGuiController::ActionsGuiController()
@@ -34,3 +35,18 QVector<std::shared_ptr<SelectionZoneAction> > ActionsGuiController::selectionZo
34	{	35	{
35	return impl->m_SelectionZoneActions;	36	return impl->m_SelectionZoneActions;
36	}	37	}
		38
		39	void ActionsGuiController::removeAction(const std::shared_ptr<SelectionZoneAction> &action)
		40	{
		41	impl->m_SelectionZoneActions.removeAll(action);
		42	}
		43
		44	void ActionsGuiController::addFilterForMenu(const QStringList &menuPath)
		45	{
		46	impl->m_FilteredMenu.insert(menuPath);
		47	}
		48
		49	bool ActionsGuiController::isMenuFiltered(const QStringList &menuPath) const
		50	{
		51	return impl->m_FilteredMenu.contains(menuPath);
		52	}

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 +77 -48

@@ -11,7 +11,6
11	#include <Catalogue/CatalogueEventsWidget.h>	11	#include <Catalogue/CatalogueEventsWidget.h>
12	#include <Catalogue/CatalogueExplorer.h>	12	#include <Catalogue/CatalogueExplorer.h>
13	#include <Catalogue/CatalogueSideBarWidget.h>	13	#include <Catalogue/CatalogueSideBarWidget.h>
14	#include <Catalogue/CreateEventDialog.h>
15		14
16	#include <CatalogueDao.h>	15	#include <CatalogueDao.h>
17	#include <DBCatalogue.h>	16	#include <DBCatalogue.h>
@@ -25,9 +24,16
25	#include <QLineEdit>	24	#include <QLineEdit>
26	#include <memory>	25	#include <memory>
27		26
		27	const auto CATALOGUE_MENU_NAME = QObject::tr("Catalogues");
		28	const auto CATALOGUE_CREATE_EVENT_MENU_NAME = QObject::tr("New Event...");
		29
		30	const auto DEFAULT_EVENT_NAME = QObject::tr("Event");
		31	const auto DEFAULT_CATALOGUE_NAME = QObject::tr("Catalogue");
		32
28	struct CatalogueActionManager::CatalogueActionManagerPrivate {	33	struct CatalogueActionManager::CatalogueActionManagerPrivate {
29		34
30	CatalogueExplorer *m_CatalogueExplorer = nullptr;	35	CatalogueExplorer *m_CatalogueExplorer = nullptr;
		36	QVector<std::shared_ptr<SelectionZoneAction> > m_CreateInCatalogueActions;
31		37
32	CatalogueActionManagerPrivate(CatalogueExplorer *catalogueExplorer)	38	CatalogueActionManagerPrivate(CatalogueExplorer *catalogueExplorer)
33	: m_CatalogueExplorer(catalogueExplorer)	39	: m_CatalogueExplorer(catalogueExplorer)
@@ -80,6 +86,32 struct CatalogueActionManager::CatalogueActionManagerPrivate {
80	m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);	86	m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
81	}	87	}
82	}	88	}
		89
		90	SelectionZoneAction::EnableFunction createEventEnableFuntion() const
		91	{
		92	return [](auto zones) {
		93
		94	// Checks that all variables in the zones doesn't refer to the same product
		95	QSet<QString> usedDatasource;
		96	for (auto zone : zones) {
		97	auto graph = zone->parentGraphWidget();
		98	auto variables = graph->variables();
		99
		100	for (auto var : variables) {
		101	auto datasourceId
		102	= var->metadata().value(DataSourceItem::ID_DATA_KEY).toString();
		103	if (!usedDatasource.contains(datasourceId)) {
		104	usedDatasource.insert(datasourceId);
		105	}
		106	else {
		107	return false;
		108	}
		109	}
		110	}
		111
		112	return true;
		113	};
		114	}
83	};	115	};
84		116
85	CatalogueActionManager::CatalogueActionManager(CatalogueExplorer *catalogueExplorer)	117	CatalogueActionManager::CatalogueActionManager(CatalogueExplorer *catalogueExplorer)
@@ -91,55 +123,52 void CatalogueActionManager::installSelectionZoneActions()
91	{	123	{
92	auto &actionController = sqpApp->actionsGuiController();	124	auto &actionController = sqpApp->actionsGuiController();
93		125
94	auto createEventEnableFuntion = [](auto zones) {	126	auto createEventAction = actionController.addSectionZoneAction(
95		127	{CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME}, QObject::tr("Without Catalogue"),
96	// Checks that all variables in the zones doesn't refer to the same product	128	[this](auto zones) { impl->createEventFromZones(DEFAULT_EVENT_NAME, zones); });
97	QSet<QString> usedDatasource;	129	createEventAction->setEnableFunction(impl->createEventEnableFuntion());
98	for (auto zone : zones) {	130	createEventAction->setAllowedFiltering(false);
99	auto graph = zone->parentGraphWidget();	131
100	auto variables = graph->variables();	132	auto createEventInNewCatalogueAction = actionController.addSectionZoneAction(
		133	{CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME}, QObject::tr("In New Catalogue"),
		134	[this](auto zones) {
		135
		136	auto newCatalogue = std::make_shared<DBCatalogue>();
		137	newCatalogue->setName(DEFAULT_CATALOGUE_NAME);
		138	sqpApp->catalogueController().addCatalogue(newCatalogue);
		139	impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(newCatalogue,
		140	REPOSITORY_DEFAULT);
		141
		142	impl->createEventFromZones(DEFAULT_EVENT_NAME, zones, newCatalogue);
		143	});
		144	createEventInNewCatalogueAction->setEnableFunction(impl->createEventEnableFuntion());
		145	createEventInNewCatalogueAction->setAllowedFiltering(false);
101		146
102	for (auto var : variables) {	147	refreshCreateInCatalogueAction();
103	auto datasourceId = var->metadata().value(DataSourceItem::ID_DATA_KEY).toString();
104	if (!usedDatasource.contains(datasourceId)) {
105	usedDatasource.insert(datasourceId);
106	}
107	else {
108	return false;
109	}
110	}
111	}
112		148
113	return true;	149	actionController.addFilterForMenu({CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME});
114	};	150	}
115		151
116	auto createEventAction = actionController.addSectionZoneAction(	152	void CatalogueActionManager::refreshCreateInCatalogueAction()
117	{QObject::tr("Catalogues")}, QObject::tr("New Event..."), [this](auto zones) {	153	{
118	CreateEventDialog dialog(	154	auto &actionController = sqpApp->actionsGuiController();
119	impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
120	dialog.hideCatalogueChoice();
121	if (dialog.exec() == QDialog::Accepted) {
122	impl->createEventFromZones(dialog.eventName(), zones);
123	}
124	});
125	createEventAction->setEnableFunction(createEventEnableFuntion);
126
127	auto createEventInCatalogueAction = actionController.addSectionZoneAction(
128	{QObject::tr("Catalogues")}, QObject::tr("New Event in Catalogue..."), [this](auto zones) {
129	CreateEventDialog dialog(
130	impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
131	if (dialog.exec() == QDialog::Accepted) {
132	auto selectedCatalogue = dialog.selectedCatalogue();
133	if (!selectedCatalogue) {
134	selectedCatalogue = std::make_shared<DBCatalogue>();
135	selectedCatalogue->setName(dialog.catalogueName());
136	sqpApp->catalogueController().addCatalogue(selectedCatalogue);
137	impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(selectedCatalogue,
138	REPOSITORY_DEFAULT);
139	}
140		155
141	impl->createEventFromZones(dialog.eventName(), zones, selectedCatalogue);	156	for (auto action : impl->m_CreateInCatalogueActions) {
142	}	157	actionController.removeAction(action);
143	});	158	}
144	createEventInCatalogueAction->setEnableFunction(createEventEnableFuntion);	159	impl->m_CreateInCatalogueActions.clear();
		160
		161	auto allCatalogues
		162	= impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT);
		163
		164	for (auto catalogue : allCatalogues) {
		165	auto catalogueName = catalogue->getName();
		166	auto createEventInCatalogueAction = actionController.addSectionZoneAction(
		167	{CATALOGUE_MENU_NAME, CATALOGUE_CREATE_EVENT_MENU_NAME},
		168	QObject::tr("In \"").append(catalogueName).append("\""), [this, catalogue](auto zones) {
		169	impl->createEventFromZones(DEFAULT_EVENT_NAME, zones, catalogue);
		170	});
		171	createEventInCatalogueAction->setEnableFunction(impl->createEventEnableFuntion());
		172	impl->m_CreateInCatalogueActions << createEventInCatalogueAction;
		173	}
145	}	174	}

gui/src/Catalogue/CatalogueEventsWidget.cpp +44 -56

             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
+            #include <QActionGroup>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QKeyEvent>
             #include <QListWidget>
+            #include <QMenu>
             #include <QMessageBox>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Percentage added to the range of a event when it is displayed
             const auto EVENT_RANGE_MARGE = 30; // in %
+            const QString NEW_ZONE_TEXT = QStringLiteral("New Zone");
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
-                                       bool allowMultiSelection, const QPoint &location)
+                                       bool allowMultiSelection, bool addNewZoneOption, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
-                    if (availableZones.isEmpty()) {
+                    if (!addNewZoneOption && availableZones.isEmpty()) {
                         return QStringList{};
                     }
-                    QDialog d(parent, Qt::Tool);
+                    QActionGroup actionGroup{parent};
-                    d.setWindowTitle("Choose a zone");
+                    actionGroup.setExclusive(!allowMultiSelection);
-                    auto layout = new QVBoxLayout{&d};
-                    layout->setContentsMargins(0, 0, 0, 0);
-                    auto listWidget = new QListWidget{&d};
-                    layout->addWidget(listWidget);
-                    QSet<QListWidgetItem *> checkedItems;
+                    QVector<QAction *> zoneActions;
-                    for (auto zone : availableZones) {
-                        auto item = new QListWidgetItem{zone};
+                    QMenu selectionMenu{parent};
-                        item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
-                        if (selectedZones.contains(zone)) {
-                            item->setCheckState(Qt::Checked);
-                            checkedItems << item;
-                        else {
-                            item->setCheckState(Qt::Unchecked);
-                        listWidget->addItem(item);
+                    if (addNewZoneOption) {
+                        availableZones.prepend(NEW_ZONE_TEXT);
                     }
-                    auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
+                    selectionMenu.addSeparator();
-                    layout->addWidget(buttonBox);
+                    for (auto zone : availableZones) {
+                        auto zoneAction = selectionMenu.addAction(zone);
-                    QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
+                        zoneAction->setCheckable(true);
-                    QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
+                        zoneAction->setChecked(selectedZones.contains(zone));
+                        actionGroup.addAction(zoneAction);
-                    QObject::connect(listWidget, &QListWidget::itemChanged,
+                        zoneActions << zoneAction;
-                                     [&checkedItems, allowMultiSelection, listWidget](auto item) {
-                                         if (item->checkState() == Qt::Checked) {
-                                             if (!allowMultiSelection) {
+                    auto resultAction = selectionMenu.exec(QCursor::pos());
-                                                 for (auto checkedItem : checkedItems) {
-                                                     listWidget->blockSignals(true);
-                                                     checkedItem->setCheckState(Qt::Unchecked);
-                                                     listWidget->blockSignals(false);
-                                                 checkedItems.clear();
-                                             checkedItems << item;
-                                         else {
-                                             checkedItems.remove(item);
-                                     });
                     QStringList result;
-                    d.setMinimumWidth(120);
+                    if (resultAction == nullptr) {
-                    d.resize(d.minimumSizeHint());
+                        result = selectedZones;
-                    d.move(location);
-                    if (d.exec() == QDialog::Accepted) {
-                        for (auto item : checkedItems) {
-                            result += item->text();
                     }
                     else {
-                        result = selectedZones;
+                        for (auto zoneAction : zoneActions) {
+                            if (zoneAction->isChecked()) {
+                                result << zoneAction->text();
+                            }
+                        }
                     }
                     return result;
                         return;
                     }
+                    auto isNewZone = m_ZoneForGraphMode == NEW_ZONE_TEXT;
                     auto zone = tab->getZoneWithName(m_ZoneForGraphMode);
-                    if (!zone) {
+                    if (!isNewZone && !zone) {
                         qCWarning(LOG_CatalogueEventsWidget()) << "updateGraphMode: zone not found";
                         return;
                     }
                     m_CustomGraphs.clear();
                     // Closes the remaining graphs inside the zone
-                    zone->closeAllGraphs();
+                    if (zone) {
+                        zone->closeAllGraphs();
+                    }
+                    // Creates the zone if needed
+                    if (isNewZone) {
+                        zone = tab->createEmptyZone(0);
+                        m_ZoneForGraphMode = zone->name();
+                    }
                     // Calculates the range of each graph which will be created
                     auto graphRange = getGraphRanges(event);
                     if (checked) {
                         ui->btnChart->setChecked(false);
                         impl->m_ZonesForTimeMode
-                            = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
+                            = impl->selectZone(this, impl->m_ZonesForTimeMode, true, false,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->treeView);
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                         impl->m_ZoneForGraphMode
-                            = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
+                            = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false, true,
                                                this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                   .value(0);

gui/src/Catalogue/CatalogueExplorer.cpp +4 0

                 connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSaved, ui->events,
                         &CatalogueEventsWidget::refresh);
+                connect(ui->catalogues, &CatalogueSideBarWidget::catalogueListChanged,
+                        [this]() { impl->m_ActionManager.refreshCreateInCatalogueAction(); });
                 // Updates the inspectot when something is selected in the events
                 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
                     if (events.count() == 1) {
                 connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
                     sqpApp->catalogueController().updateCatalogue(catalogue);
                     ui->catalogues->setCatalogueChanges(catalogue, true);
+                    impl->m_ActionManager.refreshCreateInCatalogueAction();
                 });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated, [this](auto event) {

gui/src/Catalogue/CatalogueSideBarWidget.cpp +16 -2

             constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 3;
             constexpr auto DATABASE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 4;
+            const auto DEFAULT_CATALOGUE_NAME = QObject::tr("Catalogue");
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 ui->treeView->setModel(impl->m_TreeModel);
                 impl->configureTreeWidget(ui->treeView);
+                emit catalogueListChanged();
                 ui->treeView->header()->setStretchLastSection(false);
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 connect(ui->btnAdd, &QToolButton::clicked, [this]() {
                     auto catalogue = std::make_shared<DBCatalogue>();
-                    catalogue->setName(QString("Cat"));
+                    catalogue->setName(DEFAULT_CATALOGUE_NAME);
                     sqpApp->catalogueController().addCatalogue(catalogue);
                     auto item = this->addCatalogue(catalogue, REPOSITORY_DEFAULT);
                     this->setCatalogueChanges(catalogue, true);
                 connect(impl->m_TreeModel, &CatalogueTreeModel::itemDropped,
                         [this](auto index, auto mimeData, auto action) {
                             auto item = impl->m_TreeModel->item(index);
                             if (item && item->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
                                 this->setCatalogueChanges(catalogue, true);
                                     mimeData->data(MIME_TYPE_SOURCE_CATALOGUE_LIST));
                                 for (auto catalogue : sourceCatalogues) {
                                     if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
+                                        catalogueItem->replaceCatalogue(catalogue);
                                         this->setCatalogueChanges(catalogue, true);
                                     }
                                 }
+                                this->emitSelection();
                             }
                         });
                                     impl->m_TreeModel->indexOf(catalogueToItem.second->parent()));
                             }
                             emitSelection();
+                            emit catalogueListChanged();
                         }
                     }
                 });
                         this->emitSelection();
                     }
                     impl->setHasChanges(true, index, this);
+                    emit this->catalogueListChanged();
                 });
                 ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
                                                  const QString &repository)
             {
                 auto repositoryItem = impl->getDatabaseItem(repository);
-                return impl->addCatalogueItem(catalogue, impl->m_TreeModel->indexOf(repositoryItem));
+                auto catalogueItem
+                    = impl->addCatalogueItem(catalogue, impl->m_TreeModel->indexOf(repositoryItem));
+                emit catalogueListChanged();
+                return catalogueItem;
             }
             void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp +5 0

@@ -124,3 +124,8 std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const
124	{	124	{
125	return impl->m_Catalogue;	125	return impl->m_Catalogue;
126	}	126	}
		127
		128	void CatalogueTreeItem::replaceCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
		129	{
		130	impl->m_Catalogue = catalogue;
		131	}

gui/src/Visualization/VisualizationGraphWidget.cpp +30 -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);
             {
                 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);
                     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) {

gui/include/Catalogue/CreateEventDialog.h removed 0 -36

NO CONTENT: file was removed

gui/src/Catalogue/CreateEventDialog.cpp removed 0 -59

NO CONTENT: file was removed

gui/ui/Catalogue/CreateEventDialog.ui removed 0 -55

NO CONTENT: file was removed

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