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