@@ -1,53 +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 <QLoggingCategory> |
|
9 | 9 | #include <QWidget> |
|
10 | 10 | |
|
11 | 11 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget) |
|
12 | 12 | |
|
13 | 13 | class Variable; |
|
14 | 14 | class VisualizationZoneWidget; |
|
15 | 15 | |
|
16 | 16 | namespace Ui { |
|
17 | 17 | class VisualizationTabWidget; |
|
18 | 18 | } // namespace Ui |
|
19 | 19 | |
|
20 | 20 | class VisualizationTabWidget : public QWidget, public IVisualizationWidget { |
|
21 | 21 | Q_OBJECT |
|
22 | 22 | |
|
23 | 23 | public: |
|
24 | 24 | explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0); |
|
25 | 25 | virtual ~VisualizationTabWidget(); |
|
26 | 26 | |
|
27 | 27 | /// Add a zone widget |
|
28 | 28 | void addZone(VisualizationZoneWidget *zoneWidget); |
|
29 | 29 | |
|
30 | 30 | /** |
|
31 | 31 | * Creates a zone using a variable. The variable will be displayed in a new graph of the new |
|
32 | 32 | * zone. |
|
33 | 33 | * @param variable the variable for which to create the zone |
|
34 | 34 | * @return the pointer to the created zone |
|
35 | 35 | */ |
|
36 | 36 | VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable); |
|
37 | 37 | |
|
38 | /// Remove a zone | |
|
39 | void removeZone(VisualizationZoneWidget *zone); | |
|
40 | ||
|
41 | 38 | // IVisualizationWidget interface |
|
42 | 39 | void accept(IVisualizationWidgetVisitor *visitor) override; |
|
43 | 40 | bool canDrop(const Variable &variable) const override; |
|
44 | 41 | QString name() const override; |
|
45 | 42 | |
|
46 | 43 | private: |
|
47 | 44 | Ui::VisualizationTabWidget *ui; |
|
48 | 45 | |
|
49 | 46 | class VisualizationTabWidgetPrivate; |
|
50 | 47 | spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl; |
|
51 | 48 | }; |
|
52 | 49 | |
|
53 | 50 | #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H |
@@ -1,52 +1,43 | |||
|
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 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget) |
|
10 | 10 | |
|
11 | 11 | class QMenu; |
|
12 | 12 | class Variable; |
|
13 | 13 | class VisualizationTabWidget; |
|
14 | 14 | |
|
15 | 15 | namespace Ui { |
|
16 | 16 | class VisualizationWidget; |
|
17 | 17 | } // namespace Ui |
|
18 | 18 | |
|
19 | 19 | class VisualizationWidget : public QWidget, public IVisualizationWidget { |
|
20 | 20 | Q_OBJECT |
|
21 | 21 | |
|
22 | 22 | public: |
|
23 | 23 | explicit VisualizationWidget(QWidget *parent = 0); |
|
24 | 24 | virtual ~VisualizationWidget(); |
|
25 | 25 | |
|
26 | /// Add a zone widget | |
|
27 | virtual void addTab(VisualizationTabWidget *tabWidget); | |
|
28 | ||
|
29 | /// Create a tab using a Variable | |
|
30 | VisualizationTabWidget *createTab(); | |
|
31 | ||
|
32 | /// Remove a tab | |
|
33 | void removeTab(VisualizationTabWidget *tab); | |
|
34 | ||
|
35 | 26 | // IVisualizationWidget interface |
|
36 | 27 | void accept(IVisualizationWidgetVisitor *visitor) override; |
|
37 | 28 | bool canDrop(const Variable &variable) const override; |
|
38 | 29 | QString name() const override; |
|
39 | 30 | |
|
40 | 31 | public slots: |
|
41 | 32 | /** |
|
42 | 33 | * Attaches to a menu the menu relating to the visualization of a variable |
|
43 | 34 | * @param menu the parent menu of the generated menu |
|
44 | 35 | * @param variable the variable for which to generate the menu |
|
45 | 36 | */ |
|
46 | 37 | void attachVariableMenu(QMenu *menu, std::shared_ptr<Variable> variable) noexcept; |
|
47 | 38 | |
|
48 | 39 | private: |
|
49 | 40 | Ui::VisualizationWidget *ui; |
|
50 | 41 | }; |
|
51 | 42 | |
|
52 | 43 | #endif // VISUALIZATIONWIDGET_H |
@@ -1,47 +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 <QLoggingCategory> |
|
7 | 7 | #include <QWidget> |
|
8 | 8 | |
|
9 | 9 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget) |
|
10 | 10 | |
|
11 | 11 | namespace Ui { |
|
12 | 12 | class VisualizationZoneWidget; |
|
13 | 13 | } // Ui |
|
14 | 14 | |
|
15 | 15 | class Variable; |
|
16 | 16 | class VisualizationGraphWidget; |
|
17 | 17 | |
|
18 | 18 | class VisualizationZoneWidget : public QWidget, public IVisualizationWidget { |
|
19 | 19 | Q_OBJECT |
|
20 | 20 | |
|
21 | 21 | public: |
|
22 | 22 | explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0); |
|
23 | 23 | virtual ~VisualizationZoneWidget(); |
|
24 | 24 | |
|
25 | 25 | /// Add a graph widget |
|
26 | 26 | void addGraph(VisualizationGraphWidget *graphWidget); |
|
27 | 27 | |
|
28 | 28 | /** |
|
29 | 29 | * Creates a graph using a variable. The variable will be displayed in the new graph. |
|
30 | 30 | * @param variable the variable for which to create the graph |
|
31 | 31 | * @return the pointer to the created graph |
|
32 | 32 | */ |
|
33 | 33 | VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable); |
|
34 | 34 | |
|
35 | /// Remove a graph | |
|
36 | void removeGraph(VisualizationGraphWidget *graph); | |
|
37 | ||
|
38 | 35 | // IVisualizationWidget interface |
|
39 | 36 | void accept(IVisualizationWidgetVisitor *visitor) override; |
|
40 | 37 | bool canDrop(const Variable &variable) const override; |
|
41 | 38 | QString name() const override; |
|
42 | 39 | |
|
43 | 40 | private: |
|
44 | 41 | Ui::VisualizationZoneWidget *ui; |
|
45 | 42 | }; |
|
46 | 43 | |
|
47 | 44 | #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H |
@@ -1,102 +1,98 | |||
|
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 | Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget") |
|
8 | 8 | |
|
9 | 9 | namespace { |
|
10 | 10 | |
|
11 | 11 | /// Generates a default name for a new zone, according to the number of zones already displayed in |
|
12 | 12 | /// the tab |
|
13 | 13 | QString defaultZoneName(const QLayout &layout) |
|
14 | 14 | { |
|
15 | 15 | auto count = 0; |
|
16 | 16 | for (auto i = 0; i < layout.count(); ++i) { |
|
17 | 17 | if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) { |
|
18 | 18 | count++; |
|
19 | 19 | } |
|
20 | 20 | } |
|
21 | 21 | |
|
22 | 22 | return QObject::tr("Zone %1").arg(count + 1); |
|
23 | 23 | } |
|
24 | 24 | |
|
25 | 25 | } // namespace |
|
26 | 26 | |
|
27 | 27 | struct VisualizationTabWidget::VisualizationTabWidgetPrivate { |
|
28 | 28 | explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {} |
|
29 | 29 | |
|
30 | 30 | QString m_Name; |
|
31 | 31 | }; |
|
32 | 32 | |
|
33 | 33 | VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent) |
|
34 | 34 | : QWidget{parent}, |
|
35 | 35 | ui{new Ui::VisualizationTabWidget}, |
|
36 | 36 | impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)} |
|
37 | 37 | { |
|
38 | 38 | ui->setupUi(this); |
|
39 | 39 | |
|
40 | 40 | // Widget is deleted when closed |
|
41 | 41 | setAttribute(Qt::WA_DeleteOnClose); |
|
42 | 42 | } |
|
43 | 43 | |
|
44 | 44 | VisualizationTabWidget::~VisualizationTabWidget() |
|
45 | 45 | { |
|
46 | 46 | delete ui; |
|
47 | 47 | } |
|
48 | 48 | |
|
49 | 49 | void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget) |
|
50 | 50 | { |
|
51 | 51 | this->layout()->addWidget(zoneWidget); |
|
52 | 52 | } |
|
53 | 53 | |
|
54 | 54 | VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable) |
|
55 | 55 | { |
|
56 | 56 | auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this}; |
|
57 | 57 | this->addZone(zoneWidget); |
|
58 | 58 | |
|
59 | 59 | // Creates a new graph into the zone |
|
60 | 60 | zoneWidget->createGraph(variable); |
|
61 | 61 | |
|
62 | 62 | return zoneWidget; |
|
63 | 63 | } |
|
64 | 64 | |
|
65 | void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone) | |
|
66 | { | |
|
67 | } | |
|
68 | ||
|
69 | 65 | void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor) |
|
70 | 66 | { |
|
71 | 67 | if (visitor) { |
|
72 | 68 | visitor->visitEnter(this); |
|
73 | 69 | |
|
74 | 70 | // Apply visitor to zone children |
|
75 | 71 | for (auto i = 0; i < layout()->count(); ++i) { |
|
76 | 72 | if (auto item = layout()->itemAt(i)) { |
|
77 | 73 | // Widgets different from zones are not visited (no action) |
|
78 | 74 | if (auto visualizationZoneWidget |
|
79 | 75 | = dynamic_cast<VisualizationZoneWidget *>(item->widget())) { |
|
80 | 76 | visualizationZoneWidget->accept(visitor); |
|
81 | 77 | } |
|
82 | 78 | } |
|
83 | 79 | } |
|
84 | 80 | |
|
85 | 81 | visitor->visitLeave(this); |
|
86 | 82 | } |
|
87 | 83 | else { |
|
88 | 84 | qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null"); |
|
89 | 85 | } |
|
90 | 86 | } |
|
91 | 87 | |
|
92 | 88 | bool VisualizationTabWidget::canDrop(const Variable &variable) const |
|
93 | 89 | { |
|
94 | 90 | // A tab can always accomodate a variable |
|
95 | 91 | Q_UNUSED(variable); |
|
96 | 92 | return true; |
|
97 | 93 | } |
|
98 | 94 | |
|
99 | 95 | QString VisualizationTabWidget::name() const |
|
100 | 96 | { |
|
101 | 97 | return impl->m_Name; |
|
102 | 98 | } |
@@ -1,131 +1,115 | |||
|
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/operations/GenerateVariableMenuOperation.h" |
|
7 | 7 | #include "Visualization/qcustomplot.h" |
|
8 | 8 | |
|
9 | 9 | #include "ui_VisualizationWidget.h" |
|
10 | 10 | |
|
11 | 11 | #include <QToolButton> |
|
12 | 12 | |
|
13 | 13 | Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget") |
|
14 | 14 | |
|
15 | 15 | VisualizationWidget::VisualizationWidget(QWidget *parent) |
|
16 | 16 | : QWidget{parent}, ui{new Ui::VisualizationWidget} |
|
17 | 17 | { |
|
18 | 18 | ui->setupUi(this); |
|
19 | 19 | |
|
20 | 20 | auto addTabViewButton = new QToolButton{ui->tabWidget}; |
|
21 | 21 | addTabViewButton->setText(tr("Add View")); |
|
22 | 22 | addTabViewButton->setCursor(Qt::ArrowCursor); |
|
23 | 23 | ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner); |
|
24 | 24 | |
|
25 | 25 | auto enableMinimumCornerWidgetSize = [this](bool enable) { |
|
26 | 26 | |
|
27 | 27 | auto tabViewCornerWidget = ui->tabWidget->cornerWidget(); |
|
28 | 28 | auto width = enable ? tabViewCornerWidget->width() : 0; |
|
29 | 29 | auto height = enable ? tabViewCornerWidget->height() : 0; |
|
30 | 30 | tabViewCornerWidget->setMinimumHeight(height); |
|
31 | 31 | tabViewCornerWidget->setMinimumWidth(width); |
|
32 | 32 | ui->tabWidget->setMinimumHeight(height); |
|
33 | 33 | ui->tabWidget->setMinimumWidth(width); |
|
34 | 34 | }; |
|
35 | 35 | |
|
36 | 36 | auto addTabView = [this, enableMinimumCornerWidgetSize]() { |
|
37 | 37 | auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1), |
|
38 | 38 | ui->tabWidget}; |
|
39 | 39 | auto index = ui->tabWidget->addTab(widget, widget->name()); |
|
40 | 40 | if (ui->tabWidget->count() > 0) { |
|
41 | 41 | enableMinimumCornerWidgetSize(false); |
|
42 | 42 | } |
|
43 | 43 | qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index); |
|
44 | 44 | }; |
|
45 | 45 | |
|
46 | 46 | auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) { |
|
47 | 47 | if (ui->tabWidget->count() == 1) { |
|
48 | 48 | enableMinimumCornerWidgetSize(true); |
|
49 | 49 | } |
|
50 | 50 | |
|
51 | 51 | // Removes widget from tab and closes it |
|
52 | 52 | auto widget = ui->tabWidget->widget(index); |
|
53 | 53 | ui->tabWidget->removeTab(index); |
|
54 | 54 | if (widget) { |
|
55 | 55 | widget->close(); |
|
56 | 56 | } |
|
57 | 57 | |
|
58 | 58 | qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index); |
|
59 | 59 | |
|
60 | 60 | }; |
|
61 | 61 | |
|
62 | 62 | ui->tabWidget->setTabsClosable(true); |
|
63 | 63 | |
|
64 | 64 | connect(addTabViewButton, &QToolButton::clicked, addTabView); |
|
65 | 65 | connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView); |
|
66 | 66 | |
|
67 | 67 | // Adds default tab |
|
68 | 68 | addTabView(); |
|
69 | 69 | } |
|
70 | 70 | |
|
71 | 71 | VisualizationWidget::~VisualizationWidget() |
|
72 | 72 | { |
|
73 | 73 | delete ui; |
|
74 | 74 | } |
|
75 | 75 | |
|
76 | void VisualizationWidget::addTab(VisualizationTabWidget *tabWidget) | |
|
77 | { | |
|
78 | // NOTE: check is this method has to be deleted because of its dupplicated version visible as | |
|
79 | // lambda function (in the constructor) | |
|
80 | } | |
|
81 | ||
|
82 | VisualizationTabWidget *VisualizationWidget::createTab() | |
|
83 | { | |
|
84 | } | |
|
85 | ||
|
86 | void VisualizationWidget::removeTab(VisualizationTabWidget *tab) | |
|
87 | { | |
|
88 | // NOTE: check is this method has to be deleted because of its dupplicated version visible as | |
|
89 | // lambda function (in the constructor) | |
|
90 | } | |
|
91 | ||
|
92 | 76 | void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor) |
|
93 | 77 | { |
|
94 | 78 | if (visitor) { |
|
95 | 79 | visitor->visitEnter(this); |
|
96 | 80 | |
|
97 | 81 | // Apply visitor for tab children |
|
98 | 82 | for (auto i = 0; i < ui->tabWidget->count(); ++i) { |
|
99 | 83 | // Widgets different from tabs are not visited (no action) |
|
100 | 84 | if (auto visualizationTabWidget |
|
101 | 85 | = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) { |
|
102 | 86 | visualizationTabWidget->accept(visitor); |
|
103 | 87 | } |
|
104 | 88 | } |
|
105 | 89 | |
|
106 | 90 | visitor->visitLeave(this); |
|
107 | 91 | } |
|
108 | 92 | else { |
|
109 | 93 | qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null"); |
|
110 | 94 | } |
|
111 | 95 | } |
|
112 | 96 | |
|
113 | 97 | bool VisualizationWidget::canDrop(const Variable &variable) const |
|
114 | 98 | { |
|
115 | 99 | // The main widget can never accomodate a variable |
|
116 | 100 | Q_UNUSED(variable); |
|
117 | 101 | return false; |
|
118 | 102 | } |
|
119 | 103 | |
|
120 | 104 | QString VisualizationWidget::name() const |
|
121 | 105 | { |
|
122 | 106 | return QStringLiteral("MainView"); |
|
123 | 107 | } |
|
124 | 108 | |
|
125 | 109 | void VisualizationWidget::attachVariableMenu(QMenu *menu, |
|
126 | 110 | std::shared_ptr<Variable> variable) noexcept |
|
127 | 111 | { |
|
128 | 112 | // Generates the actions that make it possible to visualize the variable |
|
129 | 113 | auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable}; |
|
130 | 114 | accept(&generateVariableMenuOperation); |
|
131 | 115 | } |
@@ -1,101 +1,97 | |||
|
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 | #include <SqpApplication.h> |
|
8 | 8 | |
|
9 | 9 | Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget") |
|
10 | 10 | |
|
11 | 11 | namespace { |
|
12 | 12 | |
|
13 | 13 | /// Generates a default name for a new graph, according to the number of graphs already displayed in |
|
14 | 14 | /// the zone |
|
15 | 15 | QString defaultGraphName(const QLayout &layout) |
|
16 | 16 | { |
|
17 | 17 | auto count = 0; |
|
18 | 18 | for (auto i = 0; i < layout.count(); ++i) { |
|
19 | 19 | if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) { |
|
20 | 20 | count++; |
|
21 | 21 | } |
|
22 | 22 | } |
|
23 | 23 | |
|
24 | 24 | return QObject::tr("Graph %1").arg(count + 1); |
|
25 | 25 | } |
|
26 | 26 | |
|
27 | 27 | } // namespace |
|
28 | 28 | |
|
29 | 29 | VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent) |
|
30 | 30 | : QWidget{parent}, ui{new Ui::VisualizationZoneWidget} |
|
31 | 31 | { |
|
32 | 32 | ui->setupUi(this); |
|
33 | 33 | |
|
34 | 34 | ui->zoneNameLabel->setText(name); |
|
35 | 35 | |
|
36 | 36 | // 'Close' options : widget is deleted when closed |
|
37 | 37 | setAttribute(Qt::WA_DeleteOnClose); |
|
38 | 38 | connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close); |
|
39 | 39 | ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton)); |
|
40 | 40 | } |
|
41 | 41 | |
|
42 | 42 | VisualizationZoneWidget::~VisualizationZoneWidget() |
|
43 | 43 | { |
|
44 | 44 | delete ui; |
|
45 | 45 | } |
|
46 | 46 | |
|
47 | 47 | void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget) |
|
48 | 48 | { |
|
49 | 49 | ui->visualizationZoneFrame->layout()->addWidget(graphWidget); |
|
50 | 50 | } |
|
51 | 51 | |
|
52 | 52 | VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable) |
|
53 | 53 | { |
|
54 | 54 | auto graphWidget = new VisualizationGraphWidget{ |
|
55 | 55 | defaultGraphName(*ui->visualizationZoneFrame->layout()), this}; |
|
56 | 56 | this->addGraph(graphWidget); |
|
57 | 57 | |
|
58 | 58 | graphWidget->addVariable(variable); |
|
59 | 59 | |
|
60 | 60 | return graphWidget; |
|
61 | 61 | } |
|
62 | 62 | |
|
63 | void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph) | |
|
64 | { | |
|
65 | } | |
|
66 | ||
|
67 | 63 | void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor) |
|
68 | 64 | { |
|
69 | 65 | if (visitor) { |
|
70 | 66 | visitor->visitEnter(this); |
|
71 | 67 | |
|
72 | 68 | // Apply visitor to graph children |
|
73 | 69 | auto layout = ui->visualizationZoneFrame->layout(); |
|
74 | 70 | for (auto i = 0; i < layout->count(); ++i) { |
|
75 | 71 | if (auto item = layout->itemAt(i)) { |
|
76 | 72 | // Widgets different from graphs are not visited (no action) |
|
77 | 73 | if (auto visualizationGraphWidget |
|
78 | 74 | = dynamic_cast<VisualizationGraphWidget *>(item->widget())) { |
|
79 | 75 | visualizationGraphWidget->accept(visitor); |
|
80 | 76 | } |
|
81 | 77 | } |
|
82 | 78 | } |
|
83 | 79 | |
|
84 | 80 | visitor->visitLeave(this); |
|
85 | 81 | } |
|
86 | 82 | else { |
|
87 | 83 | qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null"); |
|
88 | 84 | } |
|
89 | 85 | } |
|
90 | 86 | |
|
91 | 87 | bool VisualizationZoneWidget::canDrop(const Variable &variable) const |
|
92 | 88 | { |
|
93 | 89 | // A tab can always accomodate a variable |
|
94 | 90 | Q_UNUSED(variable); |
|
95 | 91 | return true; |
|
96 | 92 | } |
|
97 | 93 | |
|
98 | 94 | QString VisualizationZoneWidget::name() const |
|
99 | 95 | { |
|
100 | 96 | return ui->zoneNameLabel->text(); |
|
101 | 97 | } |
General Comments 0
You need to be logged in to leave comments.
Login now