GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r223:e10dbfb41b9a

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r223:e10dbfb41b9a

parent child

Context file:

r223:e10dbfb41b9a

Collapse all files

gui/include/Visualization/IVariableContainer.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_IVARIABLECONTAINER_H
	2	#define SCIQLOP_IVARIABLECONTAINER_H
	3
	4	class Variable;
	5
	6	/**
	7	* @brief The IVariableContainer interface represents an UI object that can accommodate a variable
	8	*/
	9	class IVariableContainer {
	10
	11	public:
	12	virtual ~IVariableContainer() = default;
	13
	14	/// Checks if the container can handle the variable passed in parameter
	15	virtual bool canDrop(const Variable &variable) const = 0;
	16	};
	17
	18
	19	#endif // SCIQLOP_IVARIABLECONTAINER_H

gui/include/Visualization/operations/GenerateVariableMenuOperation.h created 644 +42 0

@@ -0,0 +1,42
	1	#ifndef SCIQLOP_GENERATEVARIABLEMENUOPERATION_H
	2	#define SCIQLOP_GENERATEVARIABLEMENUOPERATION_H
	3
	4	#include "Visualization/IVisualizationWidgetVisitor.h"
	5
	6	#include <Common/spimpl.h>
	7
	8	#include <QLoggingCategory>
	9
	10	class QMenu;
	11	class Variable;
	12
	13	Q_DECLARE_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation)
	14
	15	/**
	16	* @brief The GenerateVariableMenuOperation class defines an operation that traverses all of
	17	* visualization widgets to determine which can accommodate a variable. The result of the operation
	18	* is a menu that contains actions to add the variable into the containers.
	19	*/
	20	class GenerateVariableMenuOperation : public IVisualizationWidgetVisitor {
	21	public:
	22	/**
	23	* Ctor
	24	* @param menu the menu to which to attach the generated menu
	25	* @param variable the variable for which to generate the menu
	26	*/
	27	explicit GenerateVariableMenuOperation(QMenu *menu, std::shared_ptr<Variable> variable);
	28
	29	void visitEnter(VisualizationWidget *widget) override final;
	30	void visitLeave(VisualizationWidget *widget) override final;
	31	void visitEnter(VisualizationTabWidget *tabWidget) override final;
	32	void visitLeave(VisualizationTabWidget *tabWidget) override final;
	33	void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
	34	void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
	35	void visit(VisualizationGraphWidget *graphWidget) override final;
	36
	37	private:
	38	class GenerateVariableMenuOperationPrivate;
	39	spimpl::unique_impl_ptr<GenerateVariableMenuOperationPrivate> impl;
	40	};
	41
	42	#endif // SCIQLOP_GENERATEVARIABLEMENUOPERATION_H

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp created 644 +200 0

@@ -0,0 +1,200
	1	#include "Visualization/operations/GenerateVariableMenuOperation.h"
	2
	3	#include "Visualization/VisualizationGraphWidget.h"
	4	#include "Visualization/VisualizationTabWidget.h"
	5	#include "Visualization/VisualizationZoneWidget.h"
	6
	7	#include <Variable/Variable.h>
	8
	9	#include <QMenu>
	10	#include <QStack>
	11
	12	Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
	13
	14	namespace {
	15
	16	/// Helper assigned to build the hierarchical menu associated with a variable
	17	struct MenuBuilder {
	18	/**
	19	* Ctor
	20	* @param menu the parent menu
	21	*/
	22	explicit MenuBuilder(QMenu *menu)
	23	{
	24	if (menu) {
	25	m_Menus.push(menu);
	26	}
	27	else {
	28	qCCritical(LOG_GenerateVariableMenuOperation())
	29	<< QObject::tr("No parent menu has been defined");
	30	}
	31	}
	32
	33	/**
	34	* Adds action to the current menu
	35	* @param actionName the name of the action
	36	* @param actionFunction the function that will be executed when the action is triggered
	37	*/
	38	template <typename ActionFun>
	39	void addAction(const QString &actionName, ActionFun actionFunction)
	40	{
	41	if (auto currMenu = currentMenu()) {
	42	currMenu->addAction(actionName, actionFunction);
	43	}
	44	else {
	45	qCCritical(LOG_GenerateVariableMenuOperation())
	46	<< QObject::tr("No current menu to attach the action");
	47	}
	48	}
	49
	50	/**
	51	* Adds a new menu to the current menu
	52	* @param name the name of the menu
	53	*/
	54	void addMenu(const QString &name)
	55	{
	56	if (auto currMenu = currentMenu()) {
	57	m_Menus.push(currMenu->addMenu(name));
	58	}
	59	else {
	60	qCCritical(LOG_GenerateVariableMenuOperation())
	61	<< QObject::tr("No current menu to attach the new menu");
	62	}
	63	}
	64
	65	/// Adds a separator to the current menu. The separator is added only if the menu already
	66	/// contains entries
	67	void addSeparator()
	68	{
	69	if (auto currMenu = currentMenu()) {
	70	if (!currMenu->isEmpty()) {
	71	currMenu->addSeparator();
	72	}
	73	}
	74	else {
	75	qCCritical(LOG_GenerateVariableMenuOperation())
	76	<< QObject::tr("No current menu to attach the separator");
	77	}
	78	}
	79
	80	/// Closes the current menu
	81	void closeMenu()
	82	{
	83	if (!m_Menus.isEmpty()) {
	84	if (auto closedMenu = m_Menus.pop()) {
	85	// Purge menu : if the closed menu has no entries, we remove it from its parent (the
	86	// current menu)
	87	if (auto currMenu = currentMenu()) {
	88	if (closedMenu->isEmpty()) {
	89	currMenu->removeAction(closedMenu->menuAction());
	90	}
	91	}
	92	}
	93	}
	94	}
	95
	96	/// Gets the current menu (i.e. the top menu of the stack)
	97	QMenu *currentMenu() const { return !m_Menus.isEmpty() ? m_Menus.top() : nullptr; }
	98
	99	/// Stack of all menus currently opened
	100	QStack<QMenu *> m_Menus{};
	101	};
	102
	103	} // namespace
	104
	105	struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
	106	explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
	107	: m_Variable{variable}, m_MenuBuilder{menu}
	108	{
	109	}
	110
	111	void visitNodeEnter(const IVisualizationWidget &container)
	112	{
	113	// Opens a new menu associated to the node
	114	m_MenuBuilder.addMenu(container.name());
	115	}
	116
	117	template <typename ActionFun>
	118	void visitNodeLeave(const IVisualizationWidget &container, const QString &actionName,
	119	ActionFun actionFunction)
	120	{
	121	if (m_Variable && container.canDrop(*m_Variable)) {
	122	m_MenuBuilder.addSeparator();
	123	m_MenuBuilder.addAction(actionName, actionFunction);
	124	}
	125
	126	// Closes the menu associated to the node
	127	m_MenuBuilder.closeMenu();
	128	}
	129
	130	template <typename ActionFun>
	131	void visitLeaf(const IVisualizationWidget &container, const QString &actionName,
	132	ActionFun actionFunction)
	133	{
	134	if (m_Variable && container.canDrop(*m_Variable)) {
	135	m_MenuBuilder.addAction(actionName, actionFunction);
	136	}
	137	}
	138
	139	std::shared_ptr<Variable> m_Variable;
	140	MenuBuilder m_MenuBuilder;
	141	};
	142
	143	GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
	144	std::shared_ptr<Variable> variable)
	145	: impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
	146	{
	147	}
	148
	149	void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
	150	{
	151	// VisualizationWidget is not intended to accommodate a variable
	152	Q_UNUSED(widget)
	153	}
	154
	155	void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
	156	{
	157	// VisualizationWidget is not intended to accommodate a variable
	158	Q_UNUSED(widget)
	159	}
	160
	161	void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
	162	{
	163	if (tabWidget) {
	164	impl->visitNodeEnter(*tabWidget);
	165	}
	166	}
	167
	168	void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
	169	{
	170	if (tabWidget) {
	171	impl->visitNodeLeave(
	172	*tabWidget, QObject::tr("Open in a new zone"),
	173	[ var = impl->m_Variable, tabWidget ]() { tabWidget->createZone(var); });
	174	}
	175	}
	176
	177	void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
	178	{
	179	if (zoneWidget) {
	180	impl->visitNodeEnter(*zoneWidget);
	181	}
	182	}
	183
	184	void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
	185	{
	186	if (zoneWidget) {
	187	impl->visitNodeLeave(
	188	*zoneWidget, QObject::tr("Open in a new graph"),
	189	[ var = impl->m_Variable, zoneWidget ]() { zoneWidget->createGraph(var); });
	190	}
	191	}
	192
	193	void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
	194	{
	195	if (graphWidget) {
	196	impl->visitLeaf(
	197	*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
	198	[ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariable(var); });
	199	}
	200	}

formatting/vera-exclusions/exclusions.txt +4 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             .*IPSIS_S04_METHOD.*found: Q_DECLARE_LOGGING_CATEGORY.*
             .*IPSIS_S04_VARIABLE.*found: impl.*
             # Ignore false positive relative to 'noexcept' keyword
             .*IPSIS_S04_VARIABLE.*found: noexcept
             .*IPSIS_S06.*found: noexcept
             # Ignore false positive relative to 'override' keyword
             .*IPSIS_S04_VARIABLE.*found: override
             .*IPSIS_S06.*found: override
+            # Ignore false positive relative to 'final' keyword
+            .*IPSIS_S04_VARIABLE.*found: final
+            .*IPSIS_S06.*found: final

gui/include/Visualization/IVisualizationWidget.h +5 -3

             #ifndef SCIQLOP_IVISUALIZATIONWIDGET_H
             #define SCIQLOP_IVISUALIZATIONWIDGET_H
-            #include "Visualization/IVisualizationWidgetVisitor.h"
+            #include "Visualization/IVariableContainer.h"
             #include <QString>
             #include <memory>
+            class IVisualizationWidgetVisitor;
             /**
              * @brief The IVisualizationWidget handles the visualization widget.
              */
-            class IVisualizationWidget {
+            class IVisualizationWidget : public IVariableContainer {
             public:
                 virtual ~IVisualizationWidget() = default;
                 /// Initializes the plugin
-                virtual void accept(IVisualizationWidget *visitor) = 0;
+                virtual void accept(IVisualizationWidgetVisitor *visitor) = 0;
                 virtual void close() = 0;
                 virtual QString name() const = 0;
             };
             #endif // SCIQLOP_IVISUALIZATIONWIDGET_H

gui/include/Visualization/IVisualizationWidgetVisitor.h +6 -3

             #ifndef SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
             #define SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
             class VisualizationWidget;
             class VisualizationTabWidget;
             class VisualizationZoneWidget;
             class VisualizationGraphWidget;
             /**
              * @brief The IVisualizationWidgetVisitor handles the visualization widget vistor pattern.
              */
             class IVisualizationWidgetVisitor {
             public:
                 virtual ~IVisualizationWidgetVisitor() = default;
-                virtual void visit(VisualizationWidget *widget) = 0;
+                virtual void visitEnter(VisualizationWidget *widget) = 0;
-                virtual void visit(VisualizationTabWidget *tabWidget) = 0;
+                virtual void visitLeave(VisualizationWidget *widget) = 0;
-                virtual void visit(VisualizationZoneWidget *zoneWidget) = 0;
+                virtual void visitEnter(VisualizationTabWidget *tabWidget) = 0;
+                virtual void visitLeave(VisualizationTabWidget *tabWidget) = 0;
+                virtual void visitEnter(VisualizationZoneWidget *zoneWidget) = 0;
+                virtual void visitLeave(VisualizationZoneWidget *zoneWidget) = 0;
                 virtual void visit(VisualizationGraphWidget *graphWidget) = 0;
             };
             #endif // SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H

gui/include/Visualization/VisualizationGraphWidget.h +2 -1

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 // IVisualizationWidget interface
-                void accept(IVisualizationWidget *visitor) override;
+                void accept(IVisualizationWidgetVisitor *visitor) override;
+                bool canDrop(const Variable &variable) const override;
                 void close() override;
                 QString name() const;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationTabWidget.h +2 -1

             #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
             #define SCIQLOP_VISUALIZATIONTABWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <Common/spimpl.h>
             #include <QWidget>
             class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationTabWidget;
             } // namespace Ui
             class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
                 /**
                  * Creates a zone using a variable. The variable will be displayed in a new graph of the new
                  * zone.
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
                 /// Remove a zone
                 void removeZone(VisualizationZoneWidget *zone);
                 // IVisualizationWidget interface
-                void accept(IVisualizationWidget *visitor) override;
+                void accept(IVisualizationWidgetVisitor *visitor) override;
+                bool canDrop(const Variable &variable) const override;
                 void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationTabWidget *ui;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationWidget.h +2 -1

             #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
             #define SCIQLOP_VISUALIZATIONWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             class Variable;
             class VisualizationTabWidget;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             namespace Ui {
             class VisualizationWidget;
             } // namespace Ui
             class VisualizationWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationWidget(QWidget *parent = 0);
                 virtual ~VisualizationWidget();
                 /// Add a zone widget
                 virtual void addTab(VisualizationTabWidget *tabWidget);
                 /// Create a tab using a Variable
                 VisualizationTabWidget *createTab();
                 /// Remove a tab
                 void removeTab(VisualizationTabWidget *tab);
                 // IVisualizationWidget interface
-                void accept(IVisualizationWidget *visitor) override;
+                void accept(IVisualizationWidgetVisitor *visitor) override;
+                bool canDrop(const Variable &variable) const override;
                 void close() override;
                 QString name() const;
             public slots:
                 /**
                  * Displays a variable in a new graph of a new zone of the current tab
                  * @param variable the variable to display
                  * @todo this is a temporary method that will be replaced by own actions for each type of
                  * visualization widget
                  */
                 void displayVariable(std::shared_ptr<Variable> variable) noexcept;
             private:
                 Ui::VisualizationWidget *ui;
             };
             #endif // VISUALIZATIONWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +2 -1

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QWidget>
             namespace Ui {
             class VisualizationZoneWidget;
             } // Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Add a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /// Remove a graph
                 void removeGraph(VisualizationGraphWidget *graph);
                 // IVisualizationWidget interface
-                void accept(IVisualizationWidget *visitor) override;
+                void accept(IVisualizationWidgetVisitor *visitor) override;
+                bool canDrop(const Variable &variable) const override;
                 void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationZoneWidget *ui;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/Visualization/VisualizationGraphWidget.cpp +12 -2

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/GraphPlottablesFactory.h"
+            #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Variable/Variable.h>
             #include <unordered_map>
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
                 std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // qcpplot title
                 ui->widget->plotLayout()->insertRow(0);
                 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMap.insert({variable, createdPlottable});
                 }
             }
-            void VisualizationGraphWidget::accept(IVisualizationWidget *visitor)
+            void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
-                // TODO: manage the visitor
+                if (visitor) {
+                    visitor->visit(this);
+                }
+            }
+            bool VisualizationGraphWidget::canDrop(const Variable &variable) const
+            {
+                /// @todo : for the moment, a graph can always accomodate a variable
+                Q_UNUSED(variable);
+                return true;
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
                 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
                     return title->text();
                 }
                 else {
                     return QString{};
                 }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }

gui/src/Visualization/VisualizationTabWidget.cpp +24 -2

             #include "Visualization/VisualizationTabWidget.h"
+            #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 this->layout()->addWidget(zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
                 this->addZone(zoneWidget);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variable);
                 return zoneWidget;
             }
             void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
             {
             }
-            void VisualizationTabWidget::accept(IVisualizationWidget *visitor)
+            void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
-                // TODO: manage the visitor
+                if (visitor) {
+                    visitor->visitEnter(this);
+                    // Apply visitor to zone children
+                    for (auto i = 0; i < layout()->count(); ++i) {
+                        if (auto item = layout()->itemAt(i)) {
+                            if (auto visualizationZoneWidget
+                                = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
+                                visualizationZoneWidget->accept(visitor);
+                            }
+                        }
+                    }
+                    visitor->visitLeave(this);
+                }
+            }
+            bool VisualizationTabWidget::canDrop(const Variable &variable) const
+            {
+                // A tab can always accomodate a variable
+                Q_UNUSED(variable);
+                return true;
             }
             void VisualizationTabWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }

gui/src/Visualization/VisualizationWidget.cpp +22 -2

             #include "Visualization/VisualizationWidget.h"
+            #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.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);
                     }
                     ui->tabWidget->removeTab(index);
                     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::addTab(VisualizationTabWidget *tabWidget)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
             VisualizationTabWidget *VisualizationWidget::createTab()
             {
             }
             void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
-            void VisualizationWidget::accept(IVisualizationWidget *visitor)
+            void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
-                // TODO: manage the visitor
+                if (visitor) {
+                    visitor->visitEnter(this);
+                    // Apply visitor for tab children
+                    for (auto i = 0; i < ui->tabWidget->count(); ++i) {
+                        if (auto visualizationTabWidget
+                            = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
+                            visualizationTabWidget->accept(visitor);
+                        }
+                    }
+                    visitor->visitLeave(this);
+                }
+            }
+            bool VisualizationWidget::canDrop(const Variable &variable) const
+            {
+                // The main widget can never accomodate a variable
+                Q_UNUSED(variable);
+                return false;
             }
             void VisualizationWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
                     if (!currentTab->createZone(variable)) {
                         qCCritical(LOG_VisualizationWidget())
                             << tr("Can't display the variable : can't create a new zone in the current tab");
                     }
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget())
                         << tr("Can't display the variable : there is no current tab");
                 }
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +25 -2

             #include "Visualization/VisualizationZoneWidget.h"
+            #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             } // namespace
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 auto graphWidget = new VisualizationGraphWidget{
                     defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                 this->addGraph(graphWidget);
                 graphWidget->addVariable(variable);
                 return graphWidget;
             }
             void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
             {
             }
-            void VisualizationZoneWidget::accept(IVisualizationWidget *visitor)
+            void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
-                // TODO: manage the visitor
+                if (visitor) {
+                    visitor->visitEnter(this);
+                    // Apply visitor to graph children
+                    auto layout = ui->visualizationZoneFrame->layout();
+                    for (auto i = 0; i < layout->count(); ++i) {
+                        if (auto item = layout->itemAt(i)) {
+                            if (auto visualizationGraphWidget
+                                = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
+                                visualizationGraphWidget->accept(visitor);
+                            }
+                        }
+                    }
+                    visitor->visitLeave(this);
+                }
+            }
+            bool VisualizationZoneWidget::canDrop(const Variable &variable) const
+            {
+                // A tab can always accomodate a variable
+                Q_UNUSED(variable);
+                return true;
             }
             void VisualizationZoneWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }

gui/vera-exclusions/exclusions.txt +1 0

             \.h:\d+:.IPSIS_S04.*found: ui
             qcustomplot\.h:\d+:.IPSIS
             qcustomplot\.cpp:\d+:.IPSIS
             # Ignore false positive relative to App macro
             SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
             SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp
             # Ignore false positive relative to unnamed namespace
             DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*
+            GenerateVariableMenuOperation\.cpp:\d+:.*IPSIS_F13.*
             VisualizationTabWidget\.cpp:\d+:.*IPSIS_F13.*
             VisualizationZoneWidget\.cpp:\d+:.*IPSIS_F13.*

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