@@ -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 |
@@ -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 |
@@ -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 |
@@ -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 |
@@ -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 |
@@ -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 |
@@ -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 | } |
@@ -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 | } |
@@ -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 | } |
@@ -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