##// END OF EJS Templates
Merge branch 'feature/VariableMenu1' into develop
Alexandre Leroux -
r217:b575895e8245 merge
parent child
Show More
@@ -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
@@ -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
@@ -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 }
@@ -1,12 +1,16
1 # On ignore toutes les règles vera++ pour le fichier spimpl
1 # On ignore toutes les règles vera++ pour le fichier spimpl
2
2
3 .*IPSIS_S04_METHOD.*found: Q_DECLARE_LOGGING_CATEGORY.*
3 .*IPSIS_S04_METHOD.*found: Q_DECLARE_LOGGING_CATEGORY.*
4 .*IPSIS_S04_VARIABLE.*found: impl.*
4 .*IPSIS_S04_VARIABLE.*found: impl.*
5
5
6 # Ignore false positive relative to 'noexcept' keyword
6 # Ignore false positive relative to 'noexcept' keyword
7 .*IPSIS_S04_VARIABLE.*found: noexcept
7 .*IPSIS_S04_VARIABLE.*found: noexcept
8 .*IPSIS_S06.*found: noexcept
8 .*IPSIS_S06.*found: noexcept
9
9
10 # Ignore false positive relative to 'override' keyword
10 # Ignore false positive relative to 'override' keyword
11 .*IPSIS_S04_VARIABLE.*found: override
11 .*IPSIS_S04_VARIABLE.*found: override
12 .*IPSIS_S06.*found: override
12 .*IPSIS_S06.*found: override
13
14 # Ignore false positive relative to 'final' keyword
15 .*IPSIS_S04_VARIABLE.*found: final
16 .*IPSIS_S06.*found: final
@@ -1,24 +1,26
1 #ifndef SCIQLOP_IVISUALIZATIONWIDGET_H
1 #ifndef SCIQLOP_IVISUALIZATIONWIDGET_H
2 #define SCIQLOP_IVISUALIZATIONWIDGET_H
2 #define SCIQLOP_IVISUALIZATIONWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidgetVisitor.h"
4 #include "Visualization/IVariableContainer.h"
5
5
6 #include <QString>
6 #include <QString>
7 #include <memory>
7 #include <memory>
8
8
9 class IVisualizationWidgetVisitor;
10
9 /**
11 /**
10 * @brief The IVisualizationWidget handles the visualization widget.
12 * @brief The IVisualizationWidget handles the visualization widget.
11 */
13 */
12 class IVisualizationWidget {
14 class IVisualizationWidget : public IVariableContainer {
13
15
14 public:
16 public:
15 virtual ~IVisualizationWidget() = default;
17 virtual ~IVisualizationWidget() = default;
16
18
17 /// Initializes the plugin
19 /// Initializes the plugin
18 virtual void accept(IVisualizationWidget *visitor) = 0;
20 virtual void accept(IVisualizationWidgetVisitor *visitor) = 0;
19 virtual void close() = 0;
21 virtual void close() = 0;
20 virtual QString name() const = 0;
22 virtual QString name() const = 0;
21 };
23 };
22
24
23
25
24 #endif // SCIQLOP_IVISUALIZATIONWIDGET_H
26 #endif // SCIQLOP_IVISUALIZATIONWIDGET_H
@@ -1,25 +1,28
1 #ifndef SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
1 #ifndef SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
2 #define SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
2 #define SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
3
3
4
4
5 class VisualizationWidget;
5 class VisualizationWidget;
6 class VisualizationTabWidget;
6 class VisualizationTabWidget;
7 class VisualizationZoneWidget;
7 class VisualizationZoneWidget;
8 class VisualizationGraphWidget;
8 class VisualizationGraphWidget;
9
9
10 /**
10 /**
11 * @brief The IVisualizationWidgetVisitor handles the visualization widget vistor pattern.
11 * @brief The IVisualizationWidgetVisitor handles the visualization widget vistor pattern.
12 */
12 */
13 class IVisualizationWidgetVisitor {
13 class IVisualizationWidgetVisitor {
14
14
15 public:
15 public:
16 virtual ~IVisualizationWidgetVisitor() = default;
16 virtual ~IVisualizationWidgetVisitor() = default;
17
17
18 virtual void visit(VisualizationWidget *widget) = 0;
18 virtual void visitEnter(VisualizationWidget *widget) = 0;
19 virtual void visit(VisualizationTabWidget *tabWidget) = 0;
19 virtual void visitLeave(VisualizationWidget *widget) = 0;
20 virtual void visit(VisualizationZoneWidget *zoneWidget) = 0;
20 virtual void visitEnter(VisualizationTabWidget *tabWidget) = 0;
21 virtual void visitLeave(VisualizationTabWidget *tabWidget) = 0;
22 virtual void visitEnter(VisualizationZoneWidget *zoneWidget) = 0;
23 virtual void visitLeave(VisualizationZoneWidget *zoneWidget) = 0;
21 virtual void visit(VisualizationGraphWidget *graphWidget) = 0;
24 virtual void visit(VisualizationGraphWidget *graphWidget) = 0;
22 };
25 };
23
26
24
27
25 #endif // SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
28 #endif // SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
@@ -1,43 +1,44
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5
5
6 #include <QWidget>
6 #include <QWidget>
7
7
8 #include <memory>
8 #include <memory>
9
9
10 #include <Common/spimpl.h>
10 #include <Common/spimpl.h>
11
11
12 class Variable;
12 class Variable;
13
13
14 namespace Ui {
14 namespace Ui {
15 class VisualizationGraphWidget;
15 class VisualizationGraphWidget;
16 } // namespace Ui
16 } // namespace Ui
17
17
18 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
18 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
19 Q_OBJECT
19 Q_OBJECT
20
20
21 public:
21 public:
22 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
22 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
23 virtual ~VisualizationGraphWidget();
23 virtual ~VisualizationGraphWidget();
24
24
25 void addVariable(std::shared_ptr<Variable> variable);
25 void addVariable(std::shared_ptr<Variable> variable);
26
26
27 // IVisualizationWidget interface
27 // IVisualizationWidget interface
28 void accept(IVisualizationWidget *visitor) override;
28 void accept(IVisualizationWidgetVisitor *visitor) override;
29 bool canDrop(const Variable &variable) const override;
29 void close() override;
30 void close() override;
30 QString name() const;
31 QString name() const;
31
32
32 private:
33 private:
33 Ui::VisualizationGraphWidget *ui;
34 Ui::VisualizationGraphWidget *ui;
34
35
35 class VisualizationGraphWidgetPrivate;
36 class VisualizationGraphWidgetPrivate;
36 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
37 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
37
38
38 private slots:
39 private slots:
39 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
40 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
40 void onMouseWheel(QWheelEvent *event) noexcept;
41 void onMouseWheel(QWheelEvent *event) noexcept;
41 };
42 };
42
43
43 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
44 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
@@ -1,50 +1,51
1 #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
2 #define SCIQLOP_VISUALIZATIONTABWIDGET_H
2 #define SCIQLOP_VISUALIZATIONTABWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5
5
6 #include <Common/spimpl.h>
6 #include <Common/spimpl.h>
7
7
8 #include <QWidget>
8 #include <QWidget>
9
9
10 class Variable;
10 class Variable;
11 class VisualizationZoneWidget;
11 class VisualizationZoneWidget;
12
12
13 namespace Ui {
13 namespace Ui {
14 class VisualizationTabWidget;
14 class VisualizationTabWidget;
15 } // namespace Ui
15 } // namespace Ui
16
16
17 class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
17 class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
18 Q_OBJECT
18 Q_OBJECT
19
19
20 public:
20 public:
21 explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
21 explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
22 virtual ~VisualizationTabWidget();
22 virtual ~VisualizationTabWidget();
23
23
24 /// Add a zone widget
24 /// Add a zone widget
25 void addZone(VisualizationZoneWidget *zoneWidget);
25 void addZone(VisualizationZoneWidget *zoneWidget);
26
26
27 /**
27 /**
28 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
28 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
29 * zone.
29 * zone.
30 * @param variable the variable for which to create the zone
30 * @param variable the variable for which to create the zone
31 * @return the pointer to the created zone
31 * @return the pointer to the created zone
32 */
32 */
33 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
33 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
34
34
35 /// Remove a zone
35 /// Remove a zone
36 void removeZone(VisualizationZoneWidget *zone);
36 void removeZone(VisualizationZoneWidget *zone);
37
37
38 // IVisualizationWidget interface
38 // IVisualizationWidget interface
39 void accept(IVisualizationWidget *visitor) override;
39 void accept(IVisualizationWidgetVisitor *visitor) override;
40 bool canDrop(const Variable &variable) const override;
40 void close() override;
41 void close() override;
41 QString name() const override;
42 QString name() const override;
42
43
43 private:
44 private:
44 Ui::VisualizationTabWidget *ui;
45 Ui::VisualizationTabWidget *ui;
45
46
46 class VisualizationTabWidgetPrivate;
47 class VisualizationTabWidgetPrivate;
47 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
48 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
48 };
49 };
49
50
50 #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H
51 #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H
@@ -1,52 +1,53
1 #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
2 #define SCIQLOP_VISUALIZATIONWIDGET_H
2 #define SCIQLOP_VISUALIZATIONWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5
5
6 #include <QLoggingCategory>
6 #include <QLoggingCategory>
7 #include <QWidget>
7 #include <QWidget>
8
8
9 class Variable;
9 class Variable;
10 class VisualizationTabWidget;
10 class VisualizationTabWidget;
11
11
12 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
12 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
13
13
14 namespace Ui {
14 namespace Ui {
15 class VisualizationWidget;
15 class VisualizationWidget;
16 } // namespace Ui
16 } // namespace Ui
17
17
18 class VisualizationWidget : public QWidget, public IVisualizationWidget {
18 class VisualizationWidget : public QWidget, public IVisualizationWidget {
19 Q_OBJECT
19 Q_OBJECT
20
20
21 public:
21 public:
22 explicit VisualizationWidget(QWidget *parent = 0);
22 explicit VisualizationWidget(QWidget *parent = 0);
23 virtual ~VisualizationWidget();
23 virtual ~VisualizationWidget();
24
24
25 /// Add a zone widget
25 /// Add a zone widget
26 virtual void addTab(VisualizationTabWidget *tabWidget);
26 virtual void addTab(VisualizationTabWidget *tabWidget);
27
27
28 /// Create a tab using a Variable
28 /// Create a tab using a Variable
29 VisualizationTabWidget *createTab();
29 VisualizationTabWidget *createTab();
30
30
31 /// Remove a tab
31 /// Remove a tab
32 void removeTab(VisualizationTabWidget *tab);
32 void removeTab(VisualizationTabWidget *tab);
33
33
34 // IVisualizationWidget interface
34 // IVisualizationWidget interface
35 void accept(IVisualizationWidget *visitor) override;
35 void accept(IVisualizationWidgetVisitor *visitor) override;
36 bool canDrop(const Variable &variable) const override;
36 void close() override;
37 void close() override;
37 QString name() const;
38 QString name() const;
38
39
39 public slots:
40 public slots:
40 /**
41 /**
41 * Displays a variable in a new graph of a new zone of the current tab
42 * Displays a variable in a new graph of a new zone of the current tab
42 * @param variable the variable to display
43 * @param variable the variable to display
43 * @todo this is a temporary method that will be replaced by own actions for each type of
44 * @todo this is a temporary method that will be replaced by own actions for each type of
44 * visualization widget
45 * visualization widget
45 */
46 */
46 void displayVariable(std::shared_ptr<Variable> variable) noexcept;
47 void displayVariable(std::shared_ptr<Variable> variable) noexcept;
47
48
48 private:
49 private:
49 Ui::VisualizationWidget *ui;
50 Ui::VisualizationWidget *ui;
50 };
51 };
51
52
52 #endif // VISUALIZATIONWIDGET_H
53 #endif // VISUALIZATIONWIDGET_H
@@ -1,44 +1,45
1 #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5
5
6 #include <QWidget>
6 #include <QWidget>
7
7
8 namespace Ui {
8 namespace Ui {
9 class VisualizationZoneWidget;
9 class VisualizationZoneWidget;
10 } // Ui
10 } // Ui
11
11
12 class Variable;
12 class Variable;
13 class VisualizationGraphWidget;
13 class VisualizationGraphWidget;
14
14
15 class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
15 class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
16 Q_OBJECT
16 Q_OBJECT
17
17
18 public:
18 public:
19 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
19 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
20 virtual ~VisualizationZoneWidget();
20 virtual ~VisualizationZoneWidget();
21
21
22 /// Add a graph widget
22 /// Add a graph widget
23 void addGraph(VisualizationGraphWidget *graphWidget);
23 void addGraph(VisualizationGraphWidget *graphWidget);
24
24
25 /**
25 /**
26 * Creates a graph using a variable. The variable will be displayed in the new graph.
26 * Creates a graph using a variable. The variable will be displayed in the new graph.
27 * @param variable the variable for which to create the graph
27 * @param variable the variable for which to create the graph
28 * @return the pointer to the created graph
28 * @return the pointer to the created graph
29 */
29 */
30 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
30 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
31
31
32 /// Remove a graph
32 /// Remove a graph
33 void removeGraph(VisualizationGraphWidget *graph);
33 void removeGraph(VisualizationGraphWidget *graph);
34
34
35 // IVisualizationWidget interface
35 // IVisualizationWidget interface
36 void accept(IVisualizationWidget *visitor) override;
36 void accept(IVisualizationWidgetVisitor *visitor) override;
37 bool canDrop(const Variable &variable) const override;
37 void close() override;
38 void close() override;
38 QString name() const override;
39 QString name() const override;
39
40
40 private:
41 private:
41 Ui::VisualizationZoneWidget *ui;
42 Ui::VisualizationZoneWidget *ui;
42 };
43 };
43
44
44 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
45 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
@@ -1,95 +1,105
1 #include "Visualization/VisualizationGraphWidget.h"
1 #include "Visualization/VisualizationGraphWidget.h"
2 #include "Visualization/GraphPlottablesFactory.h"
2 #include "Visualization/GraphPlottablesFactory.h"
3 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "ui_VisualizationGraphWidget.h"
4 #include "ui_VisualizationGraphWidget.h"
4
5
5 #include <Variable/Variable.h>
6 #include <Variable/Variable.h>
6
7
7 #include <unordered_map>
8 #include <unordered_map>
8
9
9 namespace {
10 namespace {
10
11
11 /// Key pressed to enable zoom on horizontal axis
12 /// Key pressed to enable zoom on horizontal axis
12 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
13 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
13
14
14 /// Key pressed to enable zoom on vertical axis
15 /// Key pressed to enable zoom on vertical axis
15 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
16 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
16
17
17 } // namespace
18 } // namespace
18
19
19 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
20 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
20
21
21 // 1 variable -> n qcpplot
22 // 1 variable -> n qcpplot
22 std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
23 std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
23 };
24 };
24
25
25 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
26 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
26 : QWidget{parent},
27 : QWidget{parent},
27 ui{new Ui::VisualizationGraphWidget},
28 ui{new Ui::VisualizationGraphWidget},
28 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
29 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
29 {
30 {
30 ui->setupUi(this);
31 ui->setupUi(this);
31
32
32 // qcpplot title
33 // qcpplot title
33 ui->widget->plotLayout()->insertRow(0);
34 ui->widget->plotLayout()->insertRow(0);
34 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
35 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
35
36
36 // Set qcpplot properties :
37 // Set qcpplot properties :
37 // - Drag (on x-axis) and zoom are enabled
38 // - Drag (on x-axis) and zoom are enabled
38 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
39 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
39 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
40 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
40 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
41 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
41 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
42 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
42 }
43 }
43
44
44 VisualizationGraphWidget::~VisualizationGraphWidget()
45 VisualizationGraphWidget::~VisualizationGraphWidget()
45 {
46 {
46 delete ui;
47 delete ui;
47 }
48 }
48
49
49 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
50 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
50 {
51 {
51 // Uses delegate to create the qcpplot components according to the variable
52 // Uses delegate to create the qcpplot components according to the variable
52 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
53 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
53
54
54 for (auto createdPlottable : qAsConst(createdPlottables)) {
55 for (auto createdPlottable : qAsConst(createdPlottables)) {
55 impl->m_VariableToPlotMap.insert({variable, createdPlottable});
56 impl->m_VariableToPlotMap.insert({variable, createdPlottable});
56 }
57 }
57 }
58 }
58
59
59 void VisualizationGraphWidget::accept(IVisualizationWidget *visitor)
60 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
60 {
61 {
61 // TODO: manage the visitor
62 if (visitor) {
63 visitor->visit(this);
64 }
65 }
66
67 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
68 {
69 /// @todo : for the moment, a graph can always accomodate a variable
70 Q_UNUSED(variable);
71 return true;
62 }
72 }
63
73
64 void VisualizationGraphWidget::close()
74 void VisualizationGraphWidget::close()
65 {
75 {
66 // The main view cannot be directly closed.
76 // The main view cannot be directly closed.
67 return;
77 return;
68 }
78 }
69
79
70 QString VisualizationGraphWidget::name() const
80 QString VisualizationGraphWidget::name() const
71 {
81 {
72 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
82 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
73 return title->text();
83 return title->text();
74 }
84 }
75 else {
85 else {
76 return QString{};
86 return QString{};
77 }
87 }
78 }
88 }
79
89
80 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
90 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
81 {
91 {
82 auto zoomOrientations = QFlags<Qt::Orientation>{};
92 auto zoomOrientations = QFlags<Qt::Orientation>{};
83
93
84 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
94 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
85 // been pressed
95 // been pressed
86 auto enableOrientation
96 auto enableOrientation
87 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
97 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
88 auto orientationEnabled = event->modifiers().testFlag(modifier);
98 auto orientationEnabled = event->modifiers().testFlag(modifier);
89 zoomOrientations.setFlag(orientation, orientationEnabled);
99 zoomOrientations.setFlag(orientation, orientationEnabled);
90 };
100 };
91 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
101 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
92 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
102 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
93
103
94 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
104 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
95 }
105 }
@@ -1,77 +1,99
1 #include "Visualization/VisualizationTabWidget.h"
1 #include "Visualization/VisualizationTabWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "ui_VisualizationTabWidget.h"
3 #include "ui_VisualizationTabWidget.h"
3
4
4 #include "Visualization/VisualizationZoneWidget.h"
5 #include "Visualization/VisualizationZoneWidget.h"
5
6
6 namespace {
7 namespace {
7
8
8 /// Generates a default name for a new zone, according to the number of zones already displayed in
9 /// Generates a default name for a new zone, according to the number of zones already displayed in
9 /// the tab
10 /// the tab
10 QString defaultZoneName(const QLayout &layout)
11 QString defaultZoneName(const QLayout &layout)
11 {
12 {
12 auto count = 0;
13 auto count = 0;
13 for (auto i = 0; i < layout.count(); ++i) {
14 for (auto i = 0; i < layout.count(); ++i) {
14 if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
15 if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
15 count++;
16 count++;
16 }
17 }
17 }
18 }
18
19
19 return QObject::tr("Zone %1").arg(count + 1);
20 return QObject::tr("Zone %1").arg(count + 1);
20 }
21 }
21
22
22 } // namespace
23 } // namespace
23
24
24 struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
25 struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
25 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
26 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
26
27
27 QString m_Name;
28 QString m_Name;
28 };
29 };
29
30
30 VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
31 VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
31 : QWidget{parent},
32 : QWidget{parent},
32 ui{new Ui::VisualizationTabWidget},
33 ui{new Ui::VisualizationTabWidget},
33 impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
34 impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
34 {
35 {
35 ui->setupUi(this);
36 ui->setupUi(this);
36 }
37 }
37
38
38 VisualizationTabWidget::~VisualizationTabWidget()
39 VisualizationTabWidget::~VisualizationTabWidget()
39 {
40 {
40 delete ui;
41 delete ui;
41 }
42 }
42
43
43 void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
44 void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
44 {
45 {
45 this->layout()->addWidget(zoneWidget);
46 this->layout()->addWidget(zoneWidget);
46 }
47 }
47
48
48 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
49 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
49 {
50 {
50 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
51 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
51 this->addZone(zoneWidget);
52 this->addZone(zoneWidget);
52
53
53 // Creates a new graph into the zone
54 // Creates a new graph into the zone
54 zoneWidget->createGraph(variable);
55 zoneWidget->createGraph(variable);
55
56
56 return zoneWidget;
57 return zoneWidget;
57 }
58 }
58
59
59 void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
60 void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
60 {
61 {
61 }
62 }
62
63
63 void VisualizationTabWidget::accept(IVisualizationWidget *visitor)
64 void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
64 {
65 {
65 // TODO: manage the visitor
66 if (visitor) {
67 visitor->visitEnter(this);
68
69 // Apply visitor to zone children
70 for (auto i = 0; i < layout()->count(); ++i) {
71 if (auto item = layout()->itemAt(i)) {
72 if (auto visualizationZoneWidget
73 = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
74 visualizationZoneWidget->accept(visitor);
75 }
76 }
77 }
78
79 visitor->visitLeave(this);
80 }
81 }
82
83 bool VisualizationTabWidget::canDrop(const Variable &variable) const
84 {
85 // A tab can always accomodate a variable
86 Q_UNUSED(variable);
87 return true;
66 }
88 }
67
89
68 void VisualizationTabWidget::close()
90 void VisualizationTabWidget::close()
69 {
91 {
70 // The main view cannot be directly closed.
92 // The main view cannot be directly closed.
71 return;
93 return;
72 }
94 }
73
95
74 QString VisualizationTabWidget::name() const
96 QString VisualizationTabWidget::name() const
75 {
97 {
76 return impl->m_Name;
98 return impl->m_Name;
77 }
99 }
@@ -1,112 +1,132
1 #include "Visualization/VisualizationWidget.h"
1 #include "Visualization/VisualizationWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "Visualization/VisualizationGraphWidget.h"
3 #include "Visualization/VisualizationGraphWidget.h"
3 #include "Visualization/VisualizationTabWidget.h"
4 #include "Visualization/VisualizationTabWidget.h"
4 #include "Visualization/VisualizationZoneWidget.h"
5 #include "Visualization/VisualizationZoneWidget.h"
5 #include "Visualization/qcustomplot.h"
6 #include "Visualization/qcustomplot.h"
6
7
7 #include "ui_VisualizationWidget.h"
8 #include "ui_VisualizationWidget.h"
8
9
9 #include <QToolButton>
10 #include <QToolButton>
10
11
11 Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
12 Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
12
13
13 VisualizationWidget::VisualizationWidget(QWidget *parent)
14 VisualizationWidget::VisualizationWidget(QWidget *parent)
14 : QWidget{parent}, ui{new Ui::VisualizationWidget}
15 : QWidget{parent}, ui{new Ui::VisualizationWidget}
15 {
16 {
16 ui->setupUi(this);
17 ui->setupUi(this);
17
18
18 auto addTabViewButton = new QToolButton{ui->tabWidget};
19 auto addTabViewButton = new QToolButton{ui->tabWidget};
19 addTabViewButton->setText(tr("Add View"));
20 addTabViewButton->setText(tr("Add View"));
20 addTabViewButton->setCursor(Qt::ArrowCursor);
21 addTabViewButton->setCursor(Qt::ArrowCursor);
21 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
22 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
22
23
23 auto enableMinimumCornerWidgetSize = [this](bool enable) {
24 auto enableMinimumCornerWidgetSize = [this](bool enable) {
24
25
25 auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
26 auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
26 auto width = enable ? tabViewCornerWidget->width() : 0;
27 auto width = enable ? tabViewCornerWidget->width() : 0;
27 auto height = enable ? tabViewCornerWidget->height() : 0;
28 auto height = enable ? tabViewCornerWidget->height() : 0;
28 tabViewCornerWidget->setMinimumHeight(height);
29 tabViewCornerWidget->setMinimumHeight(height);
29 tabViewCornerWidget->setMinimumWidth(width);
30 tabViewCornerWidget->setMinimumWidth(width);
30 ui->tabWidget->setMinimumHeight(height);
31 ui->tabWidget->setMinimumHeight(height);
31 ui->tabWidget->setMinimumWidth(width);
32 ui->tabWidget->setMinimumWidth(width);
32 };
33 };
33
34
34 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
35 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
35 auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
36 auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
36 ui->tabWidget};
37 ui->tabWidget};
37 auto index = ui->tabWidget->addTab(widget, widget->name());
38 auto index = ui->tabWidget->addTab(widget, widget->name());
38 if (ui->tabWidget->count() > 0) {
39 if (ui->tabWidget->count() > 0) {
39 enableMinimumCornerWidgetSize(false);
40 enableMinimumCornerWidgetSize(false);
40 }
41 }
41 qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
42 qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
42 };
43 };
43
44
44 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
45 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
45 if (ui->tabWidget->count() == 1) {
46 if (ui->tabWidget->count() == 1) {
46 enableMinimumCornerWidgetSize(true);
47 enableMinimumCornerWidgetSize(true);
47 }
48 }
48
49
49 ui->tabWidget->removeTab(index);
50 ui->tabWidget->removeTab(index);
50 qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
51 qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
51
52
52 };
53 };
53
54
54 ui->tabWidget->setTabsClosable(true);
55 ui->tabWidget->setTabsClosable(true);
55
56
56 connect(addTabViewButton, &QToolButton::clicked, addTabView);
57 connect(addTabViewButton, &QToolButton::clicked, addTabView);
57 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
58 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
58
59
59 // Adds default tab
60 // Adds default tab
60 addTabView();
61 addTabView();
61 }
62 }
62
63
63 VisualizationWidget::~VisualizationWidget()
64 VisualizationWidget::~VisualizationWidget()
64 {
65 {
65 delete ui;
66 delete ui;
66 }
67 }
67
68
68 void VisualizationWidget::addTab(VisualizationTabWidget *tabWidget)
69 void VisualizationWidget::addTab(VisualizationTabWidget *tabWidget)
69 {
70 {
70 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
71 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
71 // lambda function (in the constructor)
72 // lambda function (in the constructor)
72 }
73 }
73
74
74 VisualizationTabWidget *VisualizationWidget::createTab()
75 VisualizationTabWidget *VisualizationWidget::createTab()
75 {
76 {
76 }
77 }
77
78
78 void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
79 void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
79 {
80 {
80 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
81 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
81 // lambda function (in the constructor)
82 // lambda function (in the constructor)
82 }
83 }
83
84
84 void VisualizationWidget::accept(IVisualizationWidget *visitor)
85 void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
85 {
86 {
86 // TODO: manage the visitor
87 if (visitor) {
88 visitor->visitEnter(this);
89
90 // Apply visitor for tab children
91 for (auto i = 0; i < ui->tabWidget->count(); ++i) {
92 if (auto visualizationTabWidget
93 = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
94 visualizationTabWidget->accept(visitor);
95 }
96 }
97
98 visitor->visitLeave(this);
99 }
100 }
101
102 bool VisualizationWidget::canDrop(const Variable &variable) const
103 {
104 // The main widget can never accomodate a variable
105 Q_UNUSED(variable);
106 return false;
87 }
107 }
88
108
89 void VisualizationWidget::close()
109 void VisualizationWidget::close()
90 {
110 {
91 // The main view cannot be directly closed.
111 // The main view cannot be directly closed.
92 return;
112 return;
93 }
113 }
94
114
95 QString VisualizationWidget::name() const
115 QString VisualizationWidget::name() const
96 {
116 {
97 return QStringLiteral("MainView");
117 return QStringLiteral("MainView");
98 }
118 }
99
119
100 void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
120 void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
101 {
121 {
102 if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
122 if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
103 if (!currentTab->createZone(variable)) {
123 if (!currentTab->createZone(variable)) {
104 qCCritical(LOG_VisualizationWidget())
124 qCCritical(LOG_VisualizationWidget())
105 << tr("Can't display the variable : can't create a new zone in the current tab");
125 << tr("Can't display the variable : can't create a new zone in the current tab");
106 }
126 }
107 }
127 }
108 else {
128 else {
109 qCCritical(LOG_VisualizationWidget())
129 qCCritical(LOG_VisualizationWidget())
110 << tr("Can't display the variable : there is no current tab");
130 << tr("Can't display the variable : there is no current tab");
111 }
131 }
112 }
132 }
@@ -1,71 +1,94
1 #include "Visualization/VisualizationZoneWidget.h"
1 #include "Visualization/VisualizationZoneWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "ui_VisualizationZoneWidget.h"
3 #include "ui_VisualizationZoneWidget.h"
3
4
4 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationGraphWidget.h"
5
6
6 namespace {
7 namespace {
7
8
8 /// Generates a default name for a new graph, according to the number of graphs already displayed in
9 /// Generates a default name for a new graph, according to the number of graphs already displayed in
9 /// the zone
10 /// the zone
10 QString defaultGraphName(const QLayout &layout)
11 QString defaultGraphName(const QLayout &layout)
11 {
12 {
12 auto count = 0;
13 auto count = 0;
13 for (auto i = 0; i < layout.count(); ++i) {
14 for (auto i = 0; i < layout.count(); ++i) {
14 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
15 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
15 count++;
16 count++;
16 }
17 }
17 }
18 }
18
19
19 return QObject::tr("Graph %1").arg(count + 1);
20 return QObject::tr("Graph %1").arg(count + 1);
20 }
21 }
21
22
22 } // namespace
23 } // namespace
23
24
24 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
25 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
25 : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
26 : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
26 {
27 {
27 ui->setupUi(this);
28 ui->setupUi(this);
28
29
29 ui->zoneNameLabel->setText(name);
30 ui->zoneNameLabel->setText(name);
30 }
31 }
31
32
32 VisualizationZoneWidget::~VisualizationZoneWidget()
33 VisualizationZoneWidget::~VisualizationZoneWidget()
33 {
34 {
34 delete ui;
35 delete ui;
35 }
36 }
36
37
37 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
38 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
38 {
39 {
39 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
40 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
40 }
41 }
41
42
42 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
43 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
43 {
44 {
44 auto graphWidget = new VisualizationGraphWidget{
45 auto graphWidget = new VisualizationGraphWidget{
45 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
46 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
46 this->addGraph(graphWidget);
47 this->addGraph(graphWidget);
47
48
48 graphWidget->addVariable(variable);
49 graphWidget->addVariable(variable);
49
50
50 return graphWidget;
51 return graphWidget;
51 }
52 }
52
53
53 void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
54 void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
54 {
55 {
55 }
56 }
56
57
57 void VisualizationZoneWidget::accept(IVisualizationWidget *visitor)
58 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
58 {
59 {
59 // TODO: manage the visitor
60 if (visitor) {
61 visitor->visitEnter(this);
62
63 // Apply visitor to graph children
64 auto layout = ui->visualizationZoneFrame->layout();
65 for (auto i = 0; i < layout->count(); ++i) {
66 if (auto item = layout->itemAt(i)) {
67 if (auto visualizationGraphWidget
68 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
69 visualizationGraphWidget->accept(visitor);
70 }
71 }
72 }
73
74 visitor->visitLeave(this);
75 }
76 }
77
78 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
79 {
80 // A tab can always accomodate a variable
81 Q_UNUSED(variable);
82 return true;
60 }
83 }
61
84
62 void VisualizationZoneWidget::close()
85 void VisualizationZoneWidget::close()
63 {
86 {
64 // The main view cannot be directly closed.
87 // The main view cannot be directly closed.
65 return;
88 return;
66 }
89 }
67
90
68 QString VisualizationZoneWidget::name() const
91 QString VisualizationZoneWidget::name() const
69 {
92 {
70 return ui->zoneNameLabel->text();
93 return ui->zoneNameLabel->text();
71 }
94 }
@@ -1,13 +1,14
1 \.h:\d+:.IPSIS_S04.*found: ui
1 \.h:\d+:.IPSIS_S04.*found: ui
2 qcustomplot\.h:\d+:.IPSIS
2 qcustomplot\.h:\d+:.IPSIS
3 qcustomplot\.cpp:\d+:.IPSIS
3 qcustomplot\.cpp:\d+:.IPSIS
4
4
5 # Ignore false positive relative to App macro
5 # Ignore false positive relative to App macro
6 SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
6 SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
7 SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp
7 SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp
8
8
9 # Ignore false positive relative to unnamed namespace
9 # Ignore false positive relative to unnamed namespace
10 DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*
10 DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*
11 GenerateVariableMenuOperation\.cpp:\d+:.*IPSIS_F13.*
11 VisualizationTabWidget\.cpp:\d+:.*IPSIS_F13.*
12 VisualizationTabWidget\.cpp:\d+:.*IPSIS_F13.*
12 VisualizationZoneWidget\.cpp:\d+:.*IPSIS_F13.*
13 VisualizationZoneWidget\.cpp:\d+:.*IPSIS_F13.*
13
14
General Comments 0
You need to be logged in to leave comments. Login now