HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r404:40749dfba67d

Disables 'plot' menu when variable data have not been loaded yet

Alexandre Leroux -

r404:40749dfba67d

parent child

Context file:

r404:40749dfba67d

Collapse all files

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

             #ifndef SCIQLOP_MENUBUILDER_H
             #define SCIQLOP_MENUBUILDER_H
             #include <QLoggingCategory>
             #include <QMenu>
             #include <QStack>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MenuBuilder)
             /// Helper assigned to build a hierarchical menu
             class MenuBuilder {
             public:
                 /**
                  * Ctor
                  * @param menu the parent menu
                  */
                 explicit MenuBuilder(QMenu *menu);
                 /**
                  * Adds action to the current menu
                  * @param actionName the name of the action
                  * @param actionFunction the function that will be executed when the action is triggered
                  */
                 template <typename ActionFun>
                 void addAction(const QString &actionName, ActionFun actionFunction);
                 /**
-                 * Adds a new menu to the current menu
+                 * Adds a new menu to the current menu and returns it
                  * @param name the name of the menu
                  * @param icon the icon of the menu (can be null)
+                 * @returns the created menu, nullptr if it couldn't be created
                  */
-                void addMenu(const QString &name, const QIcon &icon = {});
+                QMenu *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
                 void addSeparator();
                 /// Closes the current menu
                 void closeMenu();
             private:
                 /// @return the current menu (i.e. the top menu of the stack), nullptr if there is no menu
                 QMenu *currentMenu() const;
                 /// Stack of all menus currently opened
                 QStack<QMenu *> m_Menus{};
             };
             template <typename ActionFun>
             void MenuBuilder::addAction(const QString &actionName, ActionFun actionFunction)
             {
                 if (auto currMenu = currentMenu()) {
                     currMenu->addAction(actionName, actionFunction);
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the action");
                 }
             }
             #endif // SCIQLOP_MENUBUILDER_H

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +5 -1

             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/MenuBuilder.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include <Variable/Variable.h>
             #include <QMenu>
             #include <QStack>
             Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
             struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
                 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
                         : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
-                    m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"});
+                    if (auto plotMenu
+                        = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"})) {
+                        plotMenu->setEnabled(m_Variable && m_Variable->dataSeries() != nullptr);
+                    }
                     m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
                 }
                 void visitRootLeave()
                 {
                     // Closes the root menu
                     m_PlotMenuBuilder.closeMenu();
                     m_UnplotMenuBuilder.closeMenu();
                 }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
                     m_PlotMenuBuilder.addMenu(container.name());
                     m_UnplotMenuBuilder.addMenu(container.name());
                 }
                 template <typename ActionFun>
                 void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
                                         ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
                         m_PlotMenuBuilder.addSeparator();
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                     // Closes the menu associated to the node
                     m_PlotMenuBuilder.closeMenu();
                 }
                 void visitNodeLeaveUnplot()
                 {
                     // Closes the menu associated to the node
                     m_UnplotMenuBuilder.closeMenu();
                 }
                 template <typename ActionFun>
                 void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
                                    ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
                         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_PlotMenuBuilder;   ///< Builder for the 'Plot' menu
                 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
             GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
                                                                          std::shared_ptr<Variable> variable)
                     : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
             {
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
                 // 'Plot' and 'Unplot' menus
                 impl->visitRootEnter();
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
             {
                 // 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 {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
                     // 'Plot' menu
                     impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
                                              [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
                                                  if (auto var = varW.lock()) {
                                                      tabWidget->createZone(var);
                                                  }
                                              });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*zoneWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     // 'Plot' menu
                     impl->visitNodeLeavePlot(
                         *zoneWidget, QObject::tr("Open in a new graph"),
                         [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
                             if (auto var = varW.lock()) {
                                 zoneWidget->createGraph(var);
                             }
                         });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
                     // 'Plot' menu
                     impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
                                         [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
                                             if (auto var = varW.lock()) {
                                                 graphWidget->addVariableUsingGraph(var);
                                             }
                                         });
                     // 'Unplot' menu
                     impl->visitLeafUnplot(*graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
                                           [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
                                               if (auto var = varW.lock()) {
                                                   graphWidget->removeVariable(var);
                                               }
                                           });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

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

             #include "Visualization/operations/MenuBuilder.h"
             Q_LOGGING_CATEGORY(LOG_MenuBuilder, "MenuBuilder")
             MenuBuilder::MenuBuilder(QMenu *menu)
             {
                 if (menu) {
                     m_Menus.push(menu);
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No parent menu has been defined");
                 }
             }
-            void MenuBuilder::addMenu(const QString &name, const QIcon &icon)
+            QMenu *MenuBuilder::addMenu(const QString &name, const QIcon &icon)
             {
                 if (auto currMenu = currentMenu()) {
-                    m_Menus.push(currMenu->addMenu(icon, name));
+                    auto menu = currMenu->addMenu(icon, name);
+                    m_Menus.push(menu);
+                    return menu;
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the new menu");
+                    return nullptr;
                 }
             }
             void MenuBuilder::addSeparator()
             {
                 if (auto currMenu = currentMenu()) {
                     if (!currMenu->isEmpty()) {
                         currMenu->addSeparator();
                     }
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the separator");
                 }
             }
             void MenuBuilder::closeMenu()
             {
                 if (!m_Menus.isEmpty()) {
                     if (auto closedMenu = m_Menus.pop()) {
                         // Purge menu : if the closed menu has no entries, we remove it from its parent (the
                         // current menu)
                         if (auto currMenu = currentMenu()) {
                             if (closedMenu->isEmpty()) {
                                 currMenu->removeAction(closedMenu->menuAction());
                             }
                         }
                     }
                 }
             }
             QMenu *MenuBuilder::currentMenu() const
             {
                 return !m_Menus.isEmpty() ? m_Menus.top() : nullptr;
             }

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