GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r736:bca343a0ae6b

Prohibits the plot of a variable in several graphs (2)...

Alexandre Leroux -

r736:bca343a0ae6b

parent child

Context file:

r736:bca343a0ae6b

Collapse all files

gui/include/Visualization/operations/GenerateVariableMenuOperation.h +7 -1

             #ifndef SCIQLOP_GENERATEVARIABLEMENUOPERATION_H
             #define SCIQLOP_GENERATEVARIABLEMENUOPERATION_H
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
+            #include <set>
             class QMenu;
+            class IVisualizationWidget;
             class Variable;
             Q_DECLARE_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation)
             /**
              * @brief The GenerateVariableMenuOperation class defines an operation that traverses all of
              * visualization widgets to determine which can accommodate a variable. The result of the operation
              * is a menu that contains actions to add the variable into the containers.
              */
             class GenerateVariableMenuOperation : public IVisualizationWidgetVisitor {
             public:
                 /**
                  * Ctor
                  * @param menu the menu to which to attach the generated menu
                  * @param variable the variable for which to generate the menu
+                 * @param variableContainers the containers that already contain the variable for which to
+                 * generate the menu
                  */
-                explicit GenerateVariableMenuOperation(QMenu *menu, std::shared_ptr<Variable> variable);
+                explicit GenerateVariableMenuOperation(QMenu *menu, std::shared_ptr<Variable> variable,
+                                                       std::set<IVisualizationWidget *> variableContainers);
                 void visitEnter(VisualizationWidget *widget) override final;
                 void visitLeave(VisualizationWidget *widget) override final;
                 void visitEnter(VisualizationTabWidget *tabWidget) override final;
                 void visitLeave(VisualizationTabWidget *tabWidget) override final;
                 void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
                 void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
                 void visit(VisualizationGraphWidget *graphWidget) override final;
             private:
                 class GenerateVariableMenuOperationPrivate;
                 spimpl::unique_impl_ptr<GenerateVariableMenuOperationPrivate> impl;
             };
             #endif // SCIQLOP_GENERATEVARIABLEMENUOPERATION_H

gui/src/Visualization/VisualizationWidget.cpp +8 -1

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
+            #include "Visualization/operations/FindVariableOperation.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/operations/RescaleAxeOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                     auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                              ui->tabWidget};
                     auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                     if (ui->tabWidget->count() == 1) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
                     if (widget) {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
                 // Adds default tab
                 addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             {
                 delete ui;
             }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
                     for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
                             = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationWidget::canDrop(const Variable &variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
             bool VisualizationWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(
                 QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 // Menu is generated only if there is a single variable
                 if (variables.size() == 1) {
                     if (auto variable = variables.first()) {
+                        // Gets the containers of the variable
+                        FindVariableOperation findVariableOperation{variable};
+                        accept(&findVariableOperation);
+                        auto variableContainers = findVariableOperation.result();
                         // Generates the actions that make it possible to visualize the variable
-                        auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
+                        GenerateVariableMenuOperation generateVariableMenuOperation{
+                            menu, variable, std::move(variableContainers)};
                         accept(&generateVariableMenuOperation);
                     }
                     else {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "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);
             }
             void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
                                                      const SqpRange &range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation{variable, range};
                 accept(&rescaleVariableOperation);
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +26 -11

             #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)
+                explicit GenerateVariableMenuOperationPrivate(
-                        : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
+                    QMenu *menu, std::shared_ptr<Variable> variable,
+                    std::set<IVisualizationWidget *> variableContainers)
+                        : m_Variable{variable},
+                          m_PlotMenuBuilder{menu},
+                          m_UnplotMenuBuilder{menu},
+                          m_VariableContainers{std::move(variableContainers)}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
                     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)) {
+                    if (isValidContainer(container)) {
                         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)) {
+                    if (isValidContainer(container)) {
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 template <typename ActionFun>
-                void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
+                void visitLeafUnplot(IVisualizationWidget *container, const QString &actionName,
                                      ActionFun actionFunction)
                 {
-                    if (m_Variable && container.contains(*m_Variable)) {
+                    // If the container contains the variable, we generate 'unplot' action
+                    if (m_VariableContainers.count(container) == 1) {
                         m_UnplotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
+                bool isValidContainer(const IVisualizationWidget &container) const noexcept
+                {
+                    // A container is valid if it can contain the variable and if the variable is not already
+                    // contained in another container
+                    return m_Variable && m_VariableContainers.size() == 0 && container.canDrop(*m_Variable);
+                }
                 std::shared_ptr<Variable> m_Variable;
+                std::set<IVisualizationWidget *> m_VariableContainers;
                 MenuBuilder m_PlotMenuBuilder;   ///< Builder for the 'Plot' menu
                 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
-            GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
+            GenerateVariableMenuOperation::GenerateVariableMenuOperation(
-                                                                         std::shared_ptr<Variable> variable)
+                QMenu *menu, std::shared_ptr<Variable> variable,
-                    : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
+                std::set<IVisualizationWidget *> variableContainers)
+                    : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(
+                          menu, variable, std::move(variableContainers))}
             {
             }
             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)
             {
-                qCCritical(LOG_GenerateVariableMenuOperation(), "Open in a new graph DETECTED !!");
                 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->addVariable(var, graphWidget->graphRange());
                                             }
                                         });
                     // 'Unplot' menu
-                    impl->visitLeafUnplot(*graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
+                    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");
                 }
             }

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