GraphVisualizerGuiPlugin.h
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  *
19  * @package ArmarX::RobotAPI
20  * @author Raphael Grimm <raphael dot grimm at kit dot edu>
21  * @date 2014
22  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
23  * GNU General Public License
24  */
25 
26 #pragma once
27 
28 // ArmarX
32 
33 #include <RobotAPI/interface/visualization/DebugDrawerInterface.h>
35 
37 #include <MemoryX/interface/gui/GraphVisualizerInterface.h>
38 
39 //qt
40 #include <QMainWindow>
41 #include <QDialog>
42 #include <QGraphicsScene>
43 #include <QGraphicsLineItem>
44 #include <QGraphicsEllipseItem>
45 #include <QMouseEvent>
46 #include <MemoryX/interface/components/GraphNodePoseResolverInterface.h>
47 //std
48 #include <string>
49 #include <map>
50 #include <vector>
51 #include <tuple>
52 
53 //boost
54 
55 
56 
57 #include <MemoryX/gui-plugins/GraphVisualizerPlugin/ui_GraphVisualizerGuiPlugin.h>
59 
60 namespace memoryx
61 {
62  class GraphVisualizerGraphicsEllipseItem;
63  class GraphVisualizerGraphicsLineItem;
64 
65  class GraphVisualizerConfigDialog;
66  class GraphVisualizerWidget;
67 
68  class MouseEventProcessor;
69 
70  /**
71  * @class GraphVisualizerGuiPlugin
72  * @brief This plugin provides a widget used to visualize an undirected graph and draw it to a debug layer.
73  * @see GraphVisualizerWidget
74  */
77  {
78  Q_OBJECT
79  Q_INTERFACES(ArmarXGuiInterface)
80  Q_PLUGIN_METADATA(IID "ArmarXGuiInterface/1.00")
81  public:
83  QString getPluginName() override
84  {
85  return "GraphVisualizerGuiPlugin";
86  }
87  };
88 
89 
90  /**
91  \page MemoryX-GuiPlugins-GraphVisualizer GraphVisualizer
92  \brief A widget used to visualize an undirected graph and draw it to a debug layer.
93 
94  This widget implements the ice interface GraphVisualizerInterface and therefore
95  can be provided with an undirected graph.
96 
97  The graph is drawn to a debug layer and a scene located in the widget.
98  The widget has tables containing information about the nodes and edges.
99  Nodes on the debug layer are visualized as coordinate systems.
100  Nodes on the scene are visualized as circles.
101  Edges on the debug layer and scene are visualized with lines.
102 
103  Nodes can be added with
104  @code{.cpp}
105  addNode(const ::armarx::FramedPoseBasePtr& p)
106  @endcode
107  and are identified with the string stored in p.
108 
109  Edges can be added with
110  @code{.cpp}
111  addEdge(const ::std::string& fst, const ::std::string& snd)
112  @endcode
113  and are identified with {fst,snd}.
114  fst and snd have to be the names of already existing nodes.
115  The order of fst and snd does not matter.
116 
117  The existence can be checked with the following methods:
118  @code{.cpp}
119  hasNode(const ::std::string& name)
120  hasEdge(const ::std::string& fst, const ::std::string& snd)
121  @endcode
122 
123  All edges (the whole graph) can be deleted with:
124  @code{.cpp}
125  clearEdges()
126  clearGraph()
127  @endcode
128 
129  If the graph has to be redrawn to the debug layer, use
130  @code{.cpp}
131  redraw()
132  @endcode
133 
134  Edges and nodes have four states: {selected, not selected}X{highlighted, not highlighted}
135 
136  Selection affects the width of lines and the size of nodes. Selected lines are thicker and nodes have an increased size.
137  Selection can be toggled by double clicking the element in the table or the scene.
138 
139  Highlighting affects the color. If not highlighted, elements are blue. If highlighted, elements are green.
140  (nodes drawn on a debug layer can't change color)
141  The highlight can be set and cleared with the functions:
142  @code{.cpp}
143  highlightNode(const ::std::string& name, bool highlighted)
144  highlightEdge(const ::std::string& fst, const ::std::string& snd, bool highlighted)
145  resetHilight()
146  @endcode
147 
148 
149  The graph used in the following examples can be created with the following code:
150  @code{.cpp}
151  static ::armarx::FramedPosePtr table {new ::armarx::FramedPose{Eigen::Vector3f{3400.f,7300.f,1000.f}, "table" }};
152  static ::armarx::FramedPosePtr fridge {new ::armarx::FramedPose{Eigen::Vector3f{2150.f,7750.f,1000.f}, "fridge" }};
153  static ::armarx::FramedPosePtr sink {new ::armarx::FramedPose{Eigen::Vector3f{2500.f,9700.f,1000.f}, "sink" }};
154  static ::armarx::FramedPosePtr hub2 {new ::armarx::FramedPose{Eigen::Vector3f{3750.f,5150.f,5000.f}, "hub2" }};
155  static ::armarx::FramedPosePtr hub1 {new ::armarx::FramedPose{Eigen::Vector3f{2900.f,8000.f,1000.f}, "hub1" }};
156  static ::armarx::FramedPosePtr hub3 {new ::armarx::FramedPose{Eigen::Vector3f{3400.f,2200.f,1000.f}, "hub3" }};
157  static ::armarx::FramedPosePtr hub4 {new ::armarx::FramedPose{Eigen::Vector3f{1900.f,3000.f,1000.f}, "hub4" }};
158  static ::armarx::FramedPosePtr counter{new ::armarx::FramedPose{Eigen::Vector3f{1890.f,4050.f,1000.f}, "counter"}};
159 
160  //prx is a proxy passing the commands to the plugin
161  //add nodes
162  prx->addNode(table);
163  prx->addNode(fridge);
164  prx->addNode(sink);
165  prx->addNode(hub2);
166  prx->addNode(hub1);
167  prx->addNode(hub3);
168  prx->addNode(hub4);
169  prx->addNode(counter);
170 
171  //add edges
172  prx->addEdge("hub1","hub2");
173  prx->addEdge("hub1","table");
174  prx->addEdge("hub1","sink");
175  prx->addEdge("hub1","fridge");
176  prx->addEdge("hub2","hub3");
177  prx->addEdge("hub3","hub4");
178  prx->addEdge("hub4","counter");
179 
180  //highlight a node and an edge
181  prx->highlightEdge("hub2","hub3");
182  prx->highlightNode("table");
183  @endcode
184 
185  @image html GraphVisualizerGuiPlugin_ConfigDialog.png "The config dialog for the plugin." width=300px
186  You can set the topic of the used debug drawer and the used debug layer.
187 
188  @image html GraphVisualizerGuiPlugin_Simulation_800.png "The graph drawn to the debug layer." width=300px
189  @image html GraphVisualizerGuiPlugin_Widget_800.png "The plugin's ui." width=300px
190 
191  The ui has 5 sections
192  -# Display options for the graph.
193  - a. Rotate the graph clockwise
194  - b. Rotate the graph counter clockwise
195  - c. Zoom factor for the graph
196  - d. Rotate and zoom the graph to display most of it. (The rotation is a multiple of pi/4)
197  -# Is the scene containing the graph
198  -# The table of nodes.
199  -# The table of edges.
200  -# Triggers a repaint for the debug layer.
201 
202  - A) Shows a highlighted and selected node
203  - B) Shows a selected edge
204  - C) Shows a highlighted edge
205  - D) Shows a node. (no highlight or selection)
206  - E) Shows the tool tip of an edge.
207 
208  @see GraphVisualizerGuiPlugin
209  */
210 
211  /**
212  * @brief The GraphVisualizerWidget class
213  */
215  public armarx::ArmarXComponentWidgetControllerTemplate<GraphVisualizerWidget>,
216  public GraphVisualizerInterface
217  {
218  Q_OBJECT
219  friend class MouseEventProcessor;
220  public:
221 
222  /**
223  * @brief The type of node ids. (This type implies the node exists)
224  */
225  using NodeId = const std::string;
226 
227  /**
228  * @brief The type of edge ids. (This type implies the edge exists)
229  */
230  using EdgeId = const std::pair<const std::string, const std::string>;
231 
232 
234  ~GraphVisualizerWidget() override;
235 
236  // inherited from Component
237  void onInitComponent() override;
238  void onConnectComponent() override;
239  void onExitComponent() override;
240 
241  // inherited of ArmarXWidget
242  static QString GetWidgetName()
243  {
244  return "MemoryX.GraphVisualizerGUI";
245  }
246  static QIcon GetWidgetIcon()
247  {
248  return QIcon {"://icons/graph_visu.svg"};
249  }
250 
251  QPointer<QDialog> getConfigDialog(QWidget* parent = 0) override;
252  void loadSettings(QSettings* settings) override;
253  void saveSettings(QSettings* settings) override;
254 
255  //because the above load/save functions are *obviously* for "Save/Load Gui Config." :/
256  virtual void loadAutomaticSettings();
257  virtual void saveAutomaticSettings();
258 
259  void configured() override;
260 
261  // slice interface implementation
262  bool hasEdge(const std::string& node1, const std::string& node2, const Ice::Current& = Ice::emptyCurrent) override
263  {
264  return (edges.find(toEdge(node1, node2)) != edges.end());
265  }
266 
267  bool hasNode(const std::string& id, const Ice::Current& = Ice::emptyCurrent) override
268  {
269  return (nodes.find(id) != nodes.end());
270  }
271 
272  public slots:
273  // slice interface implementation
274  void addEdge(const std::string& node1Id, const std::string& node2Id, const Ice::Current& = Ice::emptyCurrent) override;
275  void addNode(const GraphNodeBasePtr& node, const Ice::Current& = Ice::emptyCurrent) override;
276 
277  void highlightEdge(const std::string& node1Id, const std::string& node2Id, bool highlighted = true, const Ice::Current& = Ice::emptyCurrent) override;
278  void highlightNode(const std::string& nodeId, bool highlighted = true, const Ice::Current& = Ice::emptyCurrent) override;
279 
280  void clearEdges(const Ice::Current& = Ice::emptyCurrent) override;
281  void clearGraph(const Ice::Current& = Ice::emptyCurrent) override;
282 
283  void resetHighlight(const Ice::Current& = Ice::emptyCurrent) override;
284 
285  void redraw(const Ice::Current& = Ice::emptyCurrent) override;
286  void refreshGraph();
287 
288  void tableWidgetNodesCustomContextMenu(QPoint pos);
289  void tableWidgetEdgesCustomContextMenu(QPoint pos);
290 
291  protected:
292  /**
293  * @brief Contains the ui.
294  */
295  Ui::GraphVisualizerGuiPlugin ui;
296 
297  private slots:
298  /**
299  * @brief add kitchen graph (H2T Armar3a robot kitchen)
300  */
301  void addKitchenGraph();
302 
303  void selectedSceneChanged(int i);
304  void updateSceneList();
305 
306  void drawScene();
307 
308  /**
309  * @brief Toggles the double clicked node's selection state.
310  * @param row Identifies the node.
311  */
312  void nodeTableDoubleClicked(int row, int);
313  /**
314  * @brief Toggles the double clicked edge's selection state.
315  * @param row Identifies the edge.
316  */
317  void edgeTableDoubleClicked(int row, int);
318 
319  /**
320  * @brief Toggles the double clicked node's selection state.
321  * @param id Identifies the node.
322  */
323  void nodeDoubleClicked(NodeId id);
324 
325  /**
326  * @brief Toggles the double clicked edge's selection state.
327  * @param id Identifies the edge.
328  */
329  void edgeDoubleClicked(EdgeId id);
330 
331  /**
332  * @brief Rotates the view clockwise.
333  *
334  * Stepsize set by VIEW_ROTATE_STEP_SIZE_CC in GraphVisualizerGuiPlugin.cpp
335  */
336  void viewRotatedClock();
337 
338  /**
339  * @brief Rotates the view counter clockwise.
340  *
341  * Stepsize set by VIEW_ROTATE_STEP_SIZE_CC in GraphVisualizerGuiPlugin.cpp
342  */
343  void viewRotatedCounterClock();
344 
345  /**
346  * @brief Applies the current transforamtion to the view.
347  */
348  void transformView();
349 
350  /**
351  * @brief Adjusts the view's zoom and rotation to display most of the graph.
352  */
353  void adjustView();
354 
355  bool addNewEdge(const std::string& from, const std::string& to);
356  void addNewEdgeBoth();
357  void addNewEdgeStartEnd();
358  void addNewEdgeEndStart();
359 
360  void addNewGraphNode();
361  void editGraphNode();
362 
363  private:
364  /**
365  * @brief The NodeData struct holds data required for the node.
366  * The name is stored in the key used in the map nodes.
367  */
368  struct NodeData
369  {
370  /**
371  * @brief The Entity of the graph segment this struct represents
372  */
373  GraphNodeBasePtr node;
374 
375  /**
376  * @brief The pose drawn to debugDrawer.
377  */
379 
380  /**
381  * @brief The ellipse in the scene.
382  */
383  QGraphicsEllipseItem* graphicsItem;
384 
385  /**
386  * @brief The row in the table tableWidgetNodes.
387  */
388  int tableWidgetNodesIndex;
389 
390  /**
391  * @brief Whether the node is highlighted.
392  */
393  bool highlighted;
394  };
395 
396  /**
397  * @brief The EdgeData struct holds data required for the edge.
398  * The name is stored in the key used in the map edges.
399  */
400  struct EdgeData
401  {
402  /**
403  * @brief The line in the scene.
404  */
405  QGraphicsLineItem* graphicsItem;
406  /**
407  * @brief The row in the table tableWidgetEdges.
408  */
409  int tableWidgetEdgesIndex;
410 
411  /**
412  * @brief Whether the edge is highlighted.
413  */
414  bool highlighted;
415  };
416 
417 
418  /**
419  * @brief Returns the EdgeId corresponding to two nodes.
420  * @param node1 First node id.
421  * @param node2 Second node id.
422  * @return The EdgeId corresponding to two nodes.
423  */
424  static EdgeId toEdge(const std::string& node1, const std::string& node2)
425  {
426  return EdgeId {node1, node2};
427  }
428 
429  /**
430  * @brief Updates an edge.
431  * @param The edge to update.
432  */
433  void updateEdge(const EdgeId& id);
434 
435  /**
436  * @brief Updates a node.
437  * @param The node to update.
438  */
439  void updateNode(const NodeId& id);
440 
441  void setEditFields(const NodeData& node);
442 
443  /**
444  * @brief The topic name used by debugDrawer.
445  */
446  std::string debugDrawerTopicName;
447 
448  /**
449  * @brief Used to draw onto debug layers.
450  */
452 
453  /**
454  * @brief The config dialog.
455  */
456  QPointer<GraphVisualizerConfigDialog> dialog;
457 
458  float getYawAngle(const armarx::PoseBasePtr& pose) const;
459 
460  /**
461  * @brief The scene displayed in the widget.
462  *
463  * For y coordinates -pos->y is used to mirror the scene on the y axis.
464  * If pos->y would be used the graph displayed in the scene would not
465  * match the graph drawn to the debug layer.
466  */
467  QPointer<QGraphicsScene> scene;
468 
469  /**
470  * @brief The nodes.
471  */
472  std::map<std::string, NodeData> nodes;
473 
474  /**
475  * @brief The edges.
476  */
477  std::map<EdgeId, EdgeData> edges;
478 
479  /**
480  * @brief The view's rotation angle.
481  */
482  qreal viewAngle;
483 
484  /**
485  * @brief The layer to draw on.
486  */
487  std::string debugDrawerLayerName;
488 
489  bool editStartNodeNext;
490 
491  std::string priorKnowledgeProxyName;
492  memoryx::PriorKnowledgeInterfacePrx priorKnowledgePrx;
493  memoryx::GraphNodePoseResolverInterfacePrx gnpr;
494  memoryx::GraphMemorySegmentBasePrx graphSeg;
495  QSettings settings;
496  QString lastSelectedSceneName;
497 
498  /**
499  * selectScene(): private function called when button load is pushed, and calls the function loadScene()
500  */
501  void selectScene();
502 
503  /**
504  * @brief loadScene Private function that parses XML file to load a scene
505  * @param xmlFile
506  */
507  void loadScene(const std::string& xmlFile);
508 
509 
512  };
513  /**
514  * @brief Boost shared pointer to a GraphVisualizerWidget.
515  */
516  using GraphVisualizerGuiPluginPtr = std::shared_ptr<GraphVisualizerWidget>;
517 
518 
519  /**
520  * @brief Required to override the double click event. This is required to toggle the select state.
521  */
522  class GraphVisualizerGraphicsEllipseItem: public QGraphicsEllipseItem
523  {
524  public:
526 
527  GraphVisualizerGraphicsEllipseItem(GraphVisualizerWidget& visuWidget, NodeId name, qreal x, qreal y, qreal width, qreal height, QGraphicsItem* parent = nullptr):
528  QGraphicsEllipseItem {x, y, width, height, parent},
529  id {name},
530  parentVisuWidget(visuWidget)
531  {
532  }
533 
535  {
536  }
537  protected:
538  void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) override
539  {
540  parentVisuWidget.nodeDoubleClicked(id);
541  }
542  private:
543  /**
544  * @brief Required to identify the element.
545  */
546  const NodeId id;
547 
548  /**
549  * @brief Required to call nodeDoubleClicked on it. (This class is no QObject so it does not support signals)
550  */
551  GraphVisualizerWidget& parentVisuWidget;
552  };
553 
554  /**
555  * @brief Required to override the double click event. This is required to toggle the select state.
556  */
557  class GraphVisualizerGraphicsLineItem: public QGraphicsLineItem
558  {
559  public:
561 
562  GraphVisualizerGraphicsLineItem(GraphVisualizerWidget& visuWidget, EdgeId name, qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem* parent = 0):
563  QGraphicsLineItem {x1, y1, x2, y2, parent},
564  id {name},
565  parentVisuWidget(visuWidget)
566  {
567  }
568 
570  {
571  }
572  signals:
573  protected:
574  void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) override
575  {
576  parentVisuWidget.edgeDoubleClicked(id);
577  }
578  private:
579  /**
580  * @brief Required to identify the element.
581  */
582  const EdgeId id;
583 
584  /**
585  * @brief Required to call edgeDoubleClicked on it. (This class is no QObject so it does not support signals)
586  */
587  GraphVisualizerWidget& parentVisuWidget;
588  };
589 
590  class MouseEventProcessor : public QObject
591  {
592  Q_OBJECT
593  public:
595  protected:
597  bool eventFilter(QObject* obj, QEvent* event) override;
598  };
599 }
600 
memoryx::GraphVisualizerWidget::onInitComponent
void onInitComponent() override
Pure virtual hook for the subclass.
Definition: GraphVisualizerGuiPlugin.cpp:168
memoryx::GraphVisualizerWidget::GetWidgetName
static QString GetWidgetName()
Definition: GraphVisualizerGuiPlugin.h:242
memoryx::GraphVisualizerWidget::ui
Ui::GraphVisualizerGuiPlugin ui
Contains the ui.
Definition: GraphVisualizerGuiPlugin.h:295
memoryx::GraphVisualizerGuiPlugin::getPluginName
QString getPluginName() override
Definition: GraphVisualizerGuiPlugin.h:83
memoryx::GraphVisualizerGraphicsLineItem::GraphVisualizerGraphicsLineItem
GraphVisualizerGraphicsLineItem(GraphVisualizerWidget &visuWidget, EdgeId name, qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent=0)
Definition: GraphVisualizerGuiPlugin.h:562
memoryx::GraphVisualizerGraphicsEllipseItem
Required to override the double click event.
Definition: GraphVisualizerGuiPlugin.h:522
memoryx::GraphVisualizerGuiPlugin
This plugin provides a widget used to visualize an undirected graph and draw it to a debug layer.
Definition: GraphVisualizerGuiPlugin.h:75
memoryx::GraphVisualizerWidget::getConfigDialog
QPointer< QDialog > getConfigDialog(QWidget *parent=0) override
getConfigDialog returns a pointer to the a configuration widget of this controller.
Definition: GraphVisualizerGuiPlugin.cpp:246
memoryx::GraphVisualizerGraphicsLineItem
Required to override the double click event.
Definition: GraphVisualizerGuiPlugin.h:557
armarx::ArmarXGuiPlugin
Definition: ArmarXGuiPlugin.h:46
memoryx::MouseEventProcessor
Definition: GraphVisualizerGuiPlugin.h:590
memoryx::GraphVisualizerGraphicsEllipseItem::GraphVisualizerGraphicsEllipseItem
GraphVisualizerGraphicsEllipseItem(GraphVisualizerWidget &visuWidget, NodeId name, qreal x, qreal y, qreal width, qreal height, QGraphicsItem *parent=nullptr)
Definition: GraphVisualizerGuiPlugin.h:527
memoryx::GraphVisualizerWidget::resetHighlight
void resetHighlight(const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:457
memoryx::GraphVisualizerWidget::saveSettings
void saveSettings(QSettings *settings) override
Implement to save the settings as part of the GUI configuration.
Definition: GraphVisualizerGuiPlugin.cpp:273
memoryx
VirtualRobot headers.
Definition: CommonPlacesTester.cpp:48
memoryx::GraphVisualizerGraphicsEllipseItem::mouseDoubleClickEvent
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *) override
Definition: GraphVisualizerGuiPlugin.h:538
armarx::ArmarXComponentWidgetControllerTemplate
Definition: ArmarXComponentWidgetController.h:69
memoryx::GraphVisualizerWidget::GraphVisualizerWidget
GraphVisualizerWidget()
Definition: GraphVisualizerGuiPlugin.cpp:141
memoryx::GraphVisualizerGraphicsLineItem::~GraphVisualizerGraphicsLineItem
~GraphVisualizerGraphicsLineItem() override
Definition: GraphVisualizerGuiPlugin.h:569
memoryx::GraphVisualizerWidget::addNode
void addNode(const GraphNodeBasePtr &node, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:342
memoryx::GraphVisualizerWidget::NodeId
const std::string NodeId
The type of node ids.
Definition: GraphVisualizerGuiPlugin.h:225
ArmarXGuiInterface
The main gui interface.
Definition: ArmarXGuiInterface.h:74
IceInternal::Handle< FramedPose >
ArmarXGuiPlugin.h
PriorKnowledge.h
GraphVisualizerConfigDialog.h
ArmarXComponentWidgetController.h
memoryx::GraphVisualizerWidget::highlightEdge
void highlightEdge(const std::string &node1Id, const std::string &node2Id, bool highlighted=true, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:618
memoryx::GraphVisualizerWidget
The GraphVisualizerWidget class.
Definition: GraphVisualizerGuiPlugin.h:214
FramedPose.h
memoryx::GraphVisualizerWidget::loadSettings
void loadSettings(QSettings *settings) override
Implement to load the settings that are part of the GUI configuration.
Definition: GraphVisualizerGuiPlugin.cpp:267
memoryx::GraphVisualizerWidget::hasNode
bool hasNode(const std::string &id, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.h:267
memoryx::GraphVisualizerWidget::configured
void configured() override
This function must be implemented by the user, if he supplies a config dialog.
Definition: GraphVisualizerGuiPlugin.cpp:259
memoryx::GraphVisualizerWidget::clearGraph
void clearGraph(const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:429
memoryx::GraphVisualizerWidget::highlightNode
void highlightNode(const std::string &nodeId, bool highlighted=true, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:635
memoryx::GraphVisualizerWidget::redraw
void redraw(const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:689
memoryx::GraphVisualizerGraphicsLineItem::mouseDoubleClickEvent
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *) override
Definition: GraphVisualizerGuiPlugin.h:574
memoryx::GraphVisualizerWidget::saveAutomaticSettings
virtual void saveAutomaticSettings()
Definition: GraphVisualizerGuiPlugin.cpp:284
Component.h
memoryx::GraphVisualizerGraphicsLineItem::EdgeId
GraphVisualizerWidget::EdgeId EdgeId
Definition: GraphVisualizerGuiPlugin.h:560
memoryx::GraphVisualizerWidget::hasEdge
bool hasEdge(const std::string &node1, const std::string &node2, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.h:262
memoryx::GraphVisualizerGraphicsEllipseItem::NodeId
GraphVisualizerWidget::NodeId NodeId
Definition: GraphVisualizerGuiPlugin.h:525
memoryx::GraphVisualizerWidget::loadAutomaticSettings
virtual void loadAutomaticSettings()
Definition: GraphVisualizerGuiPlugin.cpp:279
memoryx::GraphVisualizerWidget::refreshGraph
void refreshGraph()
Definition: GraphVisualizerGuiPlugin.cpp:713
memoryx::GraphVisualizerGuiPluginPtr
std::shared_ptr< GraphVisualizerWidget > GraphVisualizerGuiPluginPtr
Boost shared pointer to a GraphVisualizerWidget.
Definition: GraphVisualizerGuiPlugin.h:516
memoryx::GraphVisualizerGraphicsEllipseItem::~GraphVisualizerGraphicsEllipseItem
~GraphVisualizerGraphicsEllipseItem() override
Definition: GraphVisualizerGuiPlugin.h:534
memoryx::MouseEventProcessor::MouseEventProcessor
MouseEventProcessor(GraphVisualizerWidget *gvw)
Definition: GraphVisualizerGuiPlugin.h:594
memoryx::GraphVisualizerWidget::onExitComponent
void onExitComponent() override
Hook for subclass.
Definition: GraphVisualizerGuiPlugin.cpp:242
IceInternal::ProxyHandle<::IceProxy::armarx::DebugDrawerInterface >
memoryx::GraphVisualizerWidget::tableWidgetEdgesCustomContextMenu
void tableWidgetEdgesCustomContextMenu(QPoint pos)
Definition: GraphVisualizerGuiPlugin.cpp:1080
memoryx::GraphVisualizerGuiPlugin::GraphVisualizerGuiPlugin
GraphVisualizerGuiPlugin()
Definition: GraphVisualizerGuiPlugin.cpp:134
memoryx::MouseEventProcessor::gvw
GraphVisualizerWidget * gvw
Definition: GraphVisualizerGuiPlugin.h:596
memoryx::GraphVisualizerWidget::tableWidgetNodesCustomContextMenu
void tableWidgetNodesCustomContextMenu(QPoint pos)
Definition: GraphVisualizerGuiPlugin.cpp:1062
memoryx::GraphVisualizerWidget::~GraphVisualizerWidget
~GraphVisualizerWidget() override
Definition: GraphVisualizerGuiPlugin.cpp:163
memoryx::MouseEventProcessor::eventFilter
bool eventFilter(QObject *obj, QEvent *event) override
Definition: GraphVisualizerGuiPlugin.cpp:1098
memoryx::GraphVisualizerWidget::onConnectComponent
void onConnectComponent() override
Pure virtual hook for the subclass.
Definition: GraphVisualizerGuiPlugin.cpp:177
memoryx::GraphVisualizerWidget::GetWidgetIcon
static QIcon GetWidgetIcon()
Definition: GraphVisualizerGuiPlugin.h:246
memoryx::GraphVisualizerWidget::clearEdges
void clearEdges(const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:411
memoryx::GraphVisualizerWidget::addEdge
void addEdge(const std::string &node1Id, const std::string &node2Id, const Ice::Current &=Ice::emptyCurrent) override
Definition: GraphVisualizerGuiPlugin.cpp:289
memoryx::GraphVisualizerWidget::EdgeId
const std::pair< const std::string, const std::string > EdgeId
The type of edge ids.
Definition: GraphVisualizerGuiPlugin.h:230