##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

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