GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r311:c155354de1ae

Merge branch 'feature/VariableDeletion' into develop

Alexandre Leroux -

r311:c155354de1ae

parent child

Context file:

r311:c155354de1ae

Expand all files

gui/include/Visualization/operations/RemoveVariableOperation.h created 644 +41 0

@@ -0,0 +1,41
	1	#ifndef SCIQLOP_REMOVEVARIABLEOPERATION_H
	2	#define SCIQLOP_REMOVEVARIABLEOPERATION_H
	3
	4	#include "Visualization/IVisualizationWidgetVisitor.h"
	5
	6	#include <Common/spimpl.h>
	7
	8	#include <QLoggingCategory>
	9
	10	#include <memory>
	11
	12	class Variable;
	13
	14	Q_DECLARE_LOGGING_CATEGORY(LOG_RemoveVariableOperation)
	15
	16	/**
	17	* @brief The RemoveVariableOperation class defines an operation that traverses all of visualization
	18	* widgets to remove a variable if they contain it
	19	*/
	20	class RemoveVariableOperation : public IVisualizationWidgetVisitor {
	21	public:
	22	/**
	23	* Ctor
	24	* @param variable the variable to remove from widgets
	25	*/
	26	explicit RemoveVariableOperation(std::shared_ptr<Variable> variable);
	27
	28	void visitEnter(VisualizationWidget *widget) override final;
	29	void visitLeave(VisualizationWidget *widget) override final;
	30	void visitEnter(VisualizationTabWidget *tabWidget) override final;
	31	void visitLeave(VisualizationTabWidget *tabWidget) override final;
	32	void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
	33	void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
	34	void visit(VisualizationGraphWidget *graphWidget) override final;
	35
	36	private:
	37	class RemoveVariableOperationPrivate;
	38	spimpl::unique_impl_ptr<RemoveVariableOperationPrivate> impl;
	39	};
	40
	41	#endif // SCIQLOP_REMOVEVARIABLEOPERATION_H

gui/resources/icones/plot.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/unplot.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/src/Visualization/operations/RemoveVariableOperation.cpp created 644 +70 0

@@ -0,0 +1,70
	1	#include "Visualization/operations/RemoveVariableOperation.h"
	2	#include "Visualization/VisualizationGraphWidget.h"
	3
	4	#include <Variable/Variable.h>
	5
	6	Q_LOGGING_CATEGORY(LOG_RemoveVariableOperation, "RemoveVariableOperation")
	7
	8	struct RemoveVariableOperation::RemoveVariableOperationPrivate {
	9	explicit RemoveVariableOperationPrivate(std::shared_ptr<Variable> variable)
	10	: m_Variable(variable)
	11	{
	12	}
	13
	14	std::shared_ptr<Variable> m_Variable;
	15	};
	16
	17	RemoveVariableOperation::RemoveVariableOperation(std::shared_ptr<Variable> variable)
	18	: impl{spimpl::make_unique_impl<RemoveVariableOperationPrivate>(variable)}
	19	{
	20	}
	21
	22	void RemoveVariableOperation::visitEnter(VisualizationWidget *widget)
	23	{
	24	// VisualizationWidget is not intended to contain a variable
	25	Q_UNUSED(widget)
	26	}
	27
	28	void RemoveVariableOperation::visitLeave(VisualizationWidget *widget)
	29	{
	30	// VisualizationWidget is not intended to contain a variable
	31	Q_UNUSED(widget)
	32	}
	33
	34	void RemoveVariableOperation::visitEnter(VisualizationTabWidget *tabWidget)
	35	{
	36	// VisualizationTabWidget is not intended to contain a variable
	37	Q_UNUSED(tabWidget)
	38	}
	39
	40	void RemoveVariableOperation::visitLeave(VisualizationTabWidget *tabWidget)
	41	{
	42	// VisualizationTabWidget is not intended to contain a variable
	43	Q_UNUSED(tabWidget)
	44	}
	45
	46	void RemoveVariableOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
	47	{
	48	// VisualizationZoneWidget is not intended to contain a variable
	49	Q_UNUSED(zoneWidget)
	50	}
	51
	52	void RemoveVariableOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
	53	{
	54	// VisualizationZoneWidget is not intended to contain a variable
	55	Q_UNUSED(zoneWidget)
	56	}
	57
	58	void RemoveVariableOperation::visit(VisualizationGraphWidget *graphWidget)
	59	{
	60	if (graphWidget) {
	61	// If the widget contains the variable, removes it
	62	if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
	63	graphWidget->removeVariable(impl->m_Variable);
	64	}
	65	}
	66	else {
	67	qCCritical(LOG_RemoveVariableOperation(),
	68	"Can't visit VisualizationGraphWidget : the widget is null");
	69	}
	70	}

app/src/MainWindow.cpp +8 -2

                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
+                // Controllers / controllers connections
+                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
+                        &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
-                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
+                // Visualization
-                        &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
+                connect(&sqpApp->visualizationController(),
+                        SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
+                        SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 // Widgets / widgets connections

core/include/Variable/VariableCacheController.h +6 0

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
+            #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <Common/spimpl.h>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             class Variable;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+                /// Clears cache concerning a variable
+                void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);

core/include/Variable/VariableController.h +21 0

@@ -30,8 +30,29 public:
30		30
31	void setTimeController(TimeController *timeController) noexcept;	31	void setTimeController(TimeController *timeController) noexcept;
32		32
		33	/**
		34	* Deletes from the controller the variable passed in parameter.
		35	*
		36	* Delete a variable includes:
		37	* - the deletion of the various references to the variable in SciQlop
		38	* - the deletion of the model variable
		39	* - the deletion of the provider associated with the variable
		40	* - removing the cache associated with the variable
		41	*
		42	* @param variable the variable to delete from the controller.
		43	*/
		44	void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
		45
		46	/**
		47	* Deletes from the controller the variables passed in parameter.
		48	* @param variables the variables to delete from the controller.
		49	* @sa deleteVariable()
		50	*/
		51	void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
33		52
34	signals:	53	signals:
		54	/// Signal emitted when a variable is about to be deleted from the controller
		55	void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
35	/// Signal emitted when a variable has been created	56	/// Signal emitted when a variable has been created
36	void variableCreated(std::shared_ptr<Variable> variable);	57	void variableCreated(std::shared_ptr<Variable> variable);
37		58

core/include/Variable/VariableModel.h +6 0

                 std::shared_ptr<Variable> createVariable(const QString &name,
                                                          const SqpDateTime &dateTime) noexcept;
+                /**
+                 * Deletes a variable from the model, if it exists
+                 * @param variable the variable to delete
+                 */
+                void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 // /////////////////////////// //

core/include/Visualization/VisualizationController.h +2 0

                 virtual ~VisualizationController();
             signals:
+                /// Signal emitted when a variable is about to be deleted from SciQlop
+                void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a variable has been created in SciQlop
                 void variableCreated(std::shared_ptr<Variable> variable);

core/src/Variable/VariableCacheController.cpp +16 0

@@ -61,6 +61,22 void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
61	}	61	}
62	}	62	}
63		63
		64	void VariableCacheController::clear(std::shared_ptr<Variable> variable) noexcept
		65	{
		66	if (!variable) {
		67	qCCritical(LOG_VariableCacheController()) << "Can't clear variable cache: variable is null";
		68	return;
		69	}
		70
		71	auto nbEntries = impl->m_VariableToSqpDateTimeListMap.erase(variable);
		72
		73	auto clearCacheMessage
		74	= (nbEntries != 0)
		75	? tr("Variable cache cleared for variable %1").arg(variable->name())
		76	: tr("No deletion of variable cache: no cache was associated with the variable");
		77	qCDebug(LOG_VariableCacheController()) << clearCacheMessage;
		78	}
		79
64	QVector<SqpDateTime>	80	QVector<SqpDateTime>
65	VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,	81	VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
66	const SqpDateTime &dateTime)	82	const SqpDateTime &dateTime)

core/src/Variable/VariableController.cpp +32 0

@@ -82,6 +82,38 void VariableController::setTimeController(TimeController *timeController) noexc
82	impl->m_TimeController = timeController;	82	impl->m_TimeController = timeController;
83	}	83	}
84		84
		85	void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
		86	{
		87	if (!variable) {
		88	qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
		89	return;
		90	}
		91
		92	// Spreads in SciQlop that the variable will be deleted, so that potential receivers can
		93	// make some treatments before the deletion
		94	emit variableAboutToBeDeleted(variable);
		95
		96	// Deletes provider
		97	auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
		98	qCDebug(LOG_VariableController())
		99	<< tr("Number of providers deleted for variable %1: %2")
		100	.arg(variable->name(), QString::number(nbProvidersDeleted));
		101
		102	// Clears cache
		103	impl->m_VariableCacheController->clear(variable);
		104
		105	// Deletes from model
		106	impl->m_VariableModel->deleteVariable(variable);
		107	}
		108
		109	void VariableController::deleteVariables(
		110	const QVector<std::shared_ptr<Variable> > &variables) noexcept
		111	{
		112	for (auto variable : qAsConst(variables)) {
		113	deleteVariable(variable);
		114	}
		115	}
		116
85	void VariableController::createVariable(const QString &name,	117	void VariableController::createVariable(const QString &name,
86	std::shared_ptr<IDataProvider> provider) noexcept	118	std::shared_ptr<IDataProvider> provider) noexcept
87	{	119	{

core/src/Variable/VariableModel.cpp +26 0

@@ -69,6 +69,32 std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
69	return variable;	69	return variable;
70	}	70	}
71		71
		72	void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
		73	{
		74	if (!variable) {
		75	qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
		76	return;
		77	}
		78
		79	// Finds variable in the model
		80	auto begin = impl->m_Variables.cbegin();
		81	auto end = impl->m_Variables.cend();
		82	auto it = std::find(begin, end, variable);
		83	if (it != end) {
		84	auto removeIndex = std::distance(begin, it);
		85
		86	// Deletes variable
		87	beginRemoveRows({}, removeIndex, removeIndex);
		88	impl->m_Variables.erase(it);
		89	endRemoveRows();
		90	}
		91	else {
		92	qCritical(LOG_VariableModel())
		93	<< tr("Can't delete variable %1 from the model: the variable is not in the model")
		94	.arg(variable->name());
		95	}
		96	}
		97
72	std::shared_ptr<Variable> VariableModel::variable(int index) const	98	std::shared_ptr<Variable> VariableModel::variable(int index) const
73	{	99	{
74	return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;	100	return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;

gui/include/Visualization/IVariableContainer.h +3 0

                 /// Checks if the container can handle the variable passed in parameter
                 virtual bool canDrop(const Variable &variable) const = 0;
+                /// Checks if the container contains the variable passed in parameter
+                virtual bool contains(const Variable &variable) const = 0;
             };

gui/include/Visualization/VisualizationGraphWidget.h +1 0

                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
+                bool contains(const Variable &variable) const override;
                 QString name() const override;
                 void updateDisplay(std::shared_ptr<Variable> variable);

gui/include/Visualization/VisualizationTabWidget.h +1 0

                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
+                bool contains(const Variable &variable) const override;
                 QString name() const override;
             private:

gui/include/Visualization/VisualizationWidget.h +4 0

                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
+                bool contains(const Variable &variable) const override;
                 QString name() const override;
             public slots:
                 void attachVariableMenu(QMenu *menu,
                                         const QVector<std::shared_ptr<Variable> > &variables) noexcept;
+                /// Slot called when a variable is about to be deleted from SciQlop
+                void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
             private:
                 Ui::VisualizationWidget *ui;
             };

gui/include/Visualization/VisualizationZoneWidget.h +1 0

                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
+                bool contains(const Variable &variable) const override;
                 QString name() const override;
             private:

gui/include/Visualization/operations/MenuBuilder.h +2 -1

                 /**
                  * Adds a new menu to the current menu
                  * @param name the name of the menu
+                 * @param icon the icon of the menu (can be null)
                  */
-                void addMenu(const QString &name);
+                void addMenu(const QString &name, const QIcon &icon = {});
                 /// Adds a separator to the current menu. The separator is added only if the menu already
                 /// contains entries

gui/resources/sqpguiresources.qrc +2 0

             		<file>icones/delete.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
+                    <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
+                    <file>icones/unplot.png</file>
                 </qresource>
             </RCC>

gui/src/SqpApplication.cpp +4 0

                     connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableCreated(std::shared_ptr<Variable>)));
+                    connect(m_VariableController.get(),
+                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
+                            m_VisualizationController.get(),
+                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);

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

                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     // 'Delete' action
-                    auto deleteFun = []() {
+                    auto deleteFun = [&selectedVariables]() {
-                        /// @todo ALX : call variable deletion
+                        sqpApp->variableController().deleteVariables(selectedVariables);
                     };
                     tableMenu.addSeparator();

gui/src/Visualization/VisualizationGraphWidget.cpp +12 0

@@ -141,6 +141,18 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
141	return true;	141	return true;
142	}	142	}
143		143
		144	bool VisualizationGraphWidget::contains(const Variable &variable) const
		145	{
		146	// Finds the variable among the keys of the map
		147	auto variablePtr = &variable;
		148	auto findVariable
		149	= [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
		150
		151	auto end = impl->m_VariableToPlotMultiMap.cend();
		152	auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
		153	return it != end;
		154	}
		155
144	QString VisualizationGraphWidget::name() const	156	QString VisualizationGraphWidget::name() const
145	{	157	{
146	return ui->graphNameLabel->text();	158	return ui->graphNameLabel->text();

gui/src/Visualization/VisualizationTabWidget.cpp +6 0

                 return true;
             }
+            bool VisualizationTabWidget::contains(const Variable &variable) const
+            {
+                Q_UNUSED(variable);
+                return false;
+            }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;

gui/src/Visualization/VisualizationWidget.cpp +14 0

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
+            #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
                 return false;
             }
+            bool VisualizationWidget::contains(const Variable &variable) const
+            {
+                Q_UNUSED(variable);
+                return false;
+            }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
                               "selected");
                 }
             }
+            void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
+            {
+                // Calls the operation of removing all references to the variable in the visualization
+                auto removeVariableOperation = RemoveVariableOperation{variable};
+                accept(&removeVariableOperation);
+            }

gui/src/Visualization/VisualizationZoneWidget.cpp +6 0

                 return true;
             }
+            bool VisualizationZoneWidget::contains(const Variable &variable) const
+            {
+                Q_UNUSED(variable);
+                return false;
+            }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +53 -16

             struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
                 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
-                        : m_Variable{variable}, m_MenuBuilder{menu}
+                        : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
-                    m_MenuBuilder.addMenu(QObject::tr("Plot"));
+                    m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"});
+                    m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
                 }
                 void visitRootLeave()
                 {
                     // Closes the root menu
-                    m_MenuBuilder.closeMenu();
+                    m_PlotMenuBuilder.closeMenu();
+                    m_UnplotMenuBuilder.closeMenu();
                 }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
-                    m_MenuBuilder.addMenu(container.name());
+                    m_PlotMenuBuilder.addMenu(container.name());
+                    m_UnplotMenuBuilder.addMenu(container.name());
                 }
                 template <typename ActionFun>
-                void visitNodeLeave(const IVisualizationWidget &container, const QString &actionName,
+                void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
-                                    ActionFun actionFunction)
+                                        ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
-                        m_MenuBuilder.addSeparator();
+                        m_PlotMenuBuilder.addSeparator();
-                        m_MenuBuilder.addAction(actionName, actionFunction);
+                        m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                     // Closes the menu associated to the node
-                    m_MenuBuilder.closeMenu();
+                    m_PlotMenuBuilder.closeMenu();
+                }
+                void visitNodeLeaveUnplot()
+                {
+                    // Closes the menu associated to the node
+                    m_UnplotMenuBuilder.closeMenu();
                 }
                 template <typename ActionFun>
-                void visitLeaf(const IVisualizationWidget &container, const QString &actionName,
+                void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
-                               ActionFun actionFunction)
+                                   ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
-                        m_MenuBuilder.addAction(actionName, actionFunction);
+                        m_PlotMenuBuilder.addAction(actionName, actionFunction);
+                    }
+                }
+                template <typename ActionFun>
+                void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
+                                     ActionFun actionFunction)
+                {
+                    if (m_Variable && container.contains(*m_Variable)) {
+                        m_UnplotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 std::shared_ptr<Variable> m_Variable;
-                MenuBuilder m_MenuBuilder;
+                MenuBuilder m_PlotMenuBuilder;   ///< Builder for the 'Plot' menu
+                MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
             GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                // 'Plot' and 'Unplot' menus
                 impl->visitRootEnter();
             }
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                // 'Plot' and 'Unplot' menus
                 impl->visitRootLeave();
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
+                    // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*tabWidget);
                 }
                 else {
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
-                    impl->visitNodeLeave(
+                    // 'Plot' menu
+                    impl->visitNodeLeavePlot(
                         *tabWidget, QObject::tr("Open in a new zone"),
                         [ var = impl->m_Variable, tabWidget ]() { tabWidget->createZone(var); });
+                    // 'Unplot' menu
+                    impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
+                    // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*zoneWidget);
                 }
                 else {
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
-                    impl->visitNodeLeave(
+                    // 'Plot' menu
+                    impl->visitNodeLeavePlot(
                         *zoneWidget, QObject::tr("Open in a new graph"),
                         [ var = impl->m_Variable, zoneWidget ]() { zoneWidget->createGraph(var); });
+                    // 'Unplot' menu
+                    impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
-                    impl->visitLeaf(
+                    // 'Plot' menu
+                    impl->visitLeafPlot(
                         *graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
                         [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariableUsingGraph(var); });
+                    // 'Unplot' menu
+                    impl->visitLeafUnplot(
+                        *graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
+                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->removeVariable(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),

gui/src/Visualization/operations/MenuBuilder.cpp +2 -2

                 }
             }
-            void MenuBuilder::addMenu(const QString &name)
+            void MenuBuilder::addMenu(const QString &name, const QIcon &icon)
             {
                 if (auto currMenu = currentMenu()) {
-                    m_Menus.push(currMenu->addMenu(name));
+                    m_Menus.push(currMenu->addMenu(icon, name));
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the new menu");

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