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