##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Fixes for review
trabillard -
r846:3f7ba55eb4d2
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,42 +1,42
1 #ifndef VISUALIZATIONDRAGDROPCONTAINER_H
1 #ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
2 #define VISUALIZATIONDRAGDROPCONTAINER_H
2 #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
3
3
4 #include <Common/spimpl.h>
4 #include <Common/spimpl.h>
5 #include <QMimeData>
5 #include <QMimeData>
6 #include <QVBoxLayout>
6 #include <QVBoxLayout>
7 #include <QWidget>
7 #include <QWidget>
8
8
9 class VisualizationDragWidget;
9 class VisualizationDragWidget;
10
10
11 class VisualizationDragDropContainer : public QWidget {
11 class VisualizationDragDropContainer : public QWidget {
12 Q_OBJECT
12 Q_OBJECT
13
13
14 signals:
14 signals:
15 void dropOccured(int dropIndex, const QMimeData *mimeData);
15 void dropOccured(int dropIndex, const QMimeData *mimeData);
16
16
17 public:
17 public:
18 VisualizationDragDropContainer(QWidget *parent = nullptr);
18 VisualizationDragDropContainer(QWidget *parent = nullptr);
19
19
20 void addDragWidget(VisualizationDragWidget *dragWidget);
20 void addDragWidget(VisualizationDragWidget *dragWidget);
21 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
21 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
22
22
23 void setAcceptedMimeTypes(const QStringList &mimeTypes);
23 void setAcceptedMimeTypes(const QStringList &mimeTypes);
24 void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
24 void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
25
25
26 int countDragWidget() const;
26 int countDragWidget() const;
27
27
28 protected:
28 protected:
29 void dragEnterEvent(QDragEnterEvent *event);
29 void dragEnterEvent(QDragEnterEvent *event);
30 void dragLeaveEvent(QDragLeaveEvent *event);
30 void dragLeaveEvent(QDragLeaveEvent *event);
31 void dragMoveEvent(QDragMoveEvent *event);
31 void dragMoveEvent(QDragMoveEvent *event);
32 void dropEvent(QDropEvent *event);
32 void dropEvent(QDropEvent *event);
33
33
34 private:
34 private:
35 class VisualizationDragDropContainerPrivate;
35 class VisualizationDragDropContainerPrivate;
36 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
36 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
37
37
38 private slots:
38 private slots:
39 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
39 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
40 };
40 };
41
41
42 #endif // VISUALIZATIONDRAGDROPCONTAINER_H
42 #endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
Show file before | Show file after | Hide comments
@@ -1,29 +1,29
1 #ifndef VISUALIZATIONDRAGWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONDRAGWIDGET_H
2 #define VISUALIZATIONDRAGWIDGET_H
2 #define SCIQLOP_VISUALIZATIONDRAGWIDGET_H
3
3
4 #include <Common/spimpl.h>
4 #include <Common/spimpl.h>
5 #include <QMimeData>
5 #include <QMimeData>
6 #include <QWidget>
6 #include <QWidget>
7
7
8 class VisualizationDragWidget : public QWidget {
8 class VisualizationDragWidget : public QWidget {
9 Q_OBJECT
9 Q_OBJECT
10
10
11 public:
11 public:
12 VisualizationDragWidget(QWidget *parent = nullptr);
12 VisualizationDragWidget(QWidget *parent = nullptr);
13
13
14 virtual QMimeData *mimeData() const = 0;
14 virtual QMimeData *mimeData() const = 0;
15 virtual bool isDragAllowed() const = 0;
15 virtual bool isDragAllowed() const = 0;
16
16
17 protected:
17 protected:
18 virtual void mousePressEvent(QMouseEvent *event) override;
18 virtual void mousePressEvent(QMouseEvent *event) override;
19 virtual void mouseMoveEvent(QMouseEvent *event) override;
19 virtual void mouseMoveEvent(QMouseEvent *event) override;
20
20
21 private:
21 private:
22 class VisualizationDragWidgetPrivate;
22 class VisualizationDragWidgetPrivate;
23 spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
23 spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
24
24
25 signals:
25 signals:
26 void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
26 void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
27 };
27 };
28
28
29 #endif // VISUALIZATIONDRAGWIDGET_H
29 #endif // SCIQLOP_VISUALIZATIONDRAGWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,302 +1,302
1 #include "Visualization/VisualizationDragDropContainer.h"
1 #include "Visualization/VisualizationDragDropContainer.h"
2 #include "DragDropHelper.h"
2 #include "DragDropHelper.h"
3 #include "SqpApplication.h"
3 #include "SqpApplication.h"
4 #include "Visualization/VisualizationDragWidget.h"
4 #include "Visualization/VisualizationDragWidget.h"
5
5
6 #include <QDrag>
6 #include <QDrag>
7 #include <QDragEnterEvent>
7 #include <QDragEnterEvent>
8 #include <QVBoxLayout>
8 #include <QVBoxLayout>
9
9
10 #include <cmath>
10 #include <cmath>
11 #include <memory>
11 #include <memory>
12
12
13 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
13 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
14
14
15 QVBoxLayout *m_Layout;
15 QVBoxLayout *m_Layout;
16 QStringList m_AcceptedMimeTypes;
16 QStringList m_AcceptedMimeTypes;
17 QStringList m_MergeAllowedMimeTypes;
17 QStringList m_MergeAllowedMimeTypes;
18
18
19 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
19 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
20 {
20 {
21 m_Layout = new QVBoxLayout(widget);
21 m_Layout = new QVBoxLayout(widget);
22 m_Layout->setContentsMargins(0, 0, 0, 0);
22 m_Layout->setContentsMargins(0, 0, 0, 0);
23 }
23 }
24
24
25 bool acceptMimeData(const QMimeData *data) const
25 bool acceptMimeData(const QMimeData *data) const
26 {
26 {
27 for (const auto &type : m_AcceptedMimeTypes) {
27 for (const auto &type : m_AcceptedMimeTypes) {
28 if (data->hasFormat(type)) {
28 if (data->hasFormat(type)) {
29 return true;
29 return true;
30 }
30 }
31 }
31 }
32
32
33 return false;
33 return false;
34 }
34 }
35
35
36 bool allowMergeMimeData(const QMimeData *data) const
36 bool allowMergeMimeData(const QMimeData *data) const
37 {
37 {
38 for (const auto &type : m_MergeAllowedMimeTypes) {
38 for (const auto &type : m_MergeAllowedMimeTypes) {
39 if (data->hasFormat(type)) {
39 if (data->hasFormat(type)) {
40 return true;
40 return true;
41 }
41 }
42 }
42 }
43
43
44 return false;
44 return false;
45 }
45 }
46
46
47 bool hasPlaceHolder() const
47 bool hasPlaceHolder() const
48 {
48 {
49 return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
49 return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
50 }
50 }
51
51
52 VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
52 VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
53 {
53 {
54 VisualizationDragWidget *dragWidget = nullptr;
54 VisualizationDragWidget *dragWidget = nullptr;
55
55
56 for (auto child : parent->children()) {
56 for (auto child : parent->children()) {
57 auto widget = qobject_cast<VisualizationDragWidget *>(child);
57 auto widget = qobject_cast<VisualizationDragWidget *>(child);
58 if (widget && widget->isVisible()) {
58 if (widget && widget->isVisible()) {
59 if (widget->frameGeometry().contains(pos)) {
59 if (widget->frameGeometry().contains(pos)) {
60 dragWidget = widget;
60 dragWidget = widget;
61 break;
61 break;
62 }
62 }
63 }
63 }
64 }
64 }
65
65
66 return dragWidget;
66 return dragWidget;
67 }
67 }
68
68
69 bool cursorIsInContainer(QWidget *container) const
69 bool cursorIsInContainer(QWidget *container) const
70 {
70 {
71 auto adustNum = 18; // to be safe, in case of scrollbar on the side
71 auto adustNum = 18; // to be safe, in case of scrollbar on the side
72 auto containerRect = QRect(QPoint(), container->contentsRect().size())
72 auto containerRect = QRect(QPoint(), container->contentsRect().size())
73 .adjusted(adustNum, adustNum, -adustNum, -adustNum);
73 .adjusted(adustNum, adustNum, -adustNum, -adustNum);
74 qDebug() << containerRect << container->mapFromGlobal(QCursor::pos());
75 return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
74 return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
76 }
75 }
77 };
76 };
78
77
79 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
78 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
80 : QWidget{parent},
79 : QWidget{parent},
81 impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
80 impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
82 {
81 {
83 setAcceptDrops(true);
82 setAcceptDrops(true);
84 }
83 }
85
84
86 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
85 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
87 {
86 {
88 impl->m_Layout->addWidget(dragWidget);
87 impl->m_Layout->addWidget(dragWidget);
89 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
88 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
90 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
89 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
91 &VisualizationDragDropContainer::startDrag);
90 &VisualizationDragDropContainer::startDrag);
92 }
91 }
93
92
94 void VisualizationDragDropContainer::insertDragWidget(int index,
93 void VisualizationDragDropContainer::insertDragWidget(int index,
95 VisualizationDragWidget *dragWidget)
94 VisualizationDragWidget *dragWidget)
96 {
95 {
97 impl->m_Layout->insertWidget(index, dragWidget);
96 impl->m_Layout->insertWidget(index, dragWidget);
98 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
97 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
99 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
98 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
100 &VisualizationDragDropContainer::startDrag);
99 &VisualizationDragDropContainer::startDrag);
101 }
100 }
102
101
103 void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
102 void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
104 {
103 {
105 impl->m_AcceptedMimeTypes = mimeTypes;
104 impl->m_AcceptedMimeTypes = mimeTypes;
106 }
105 }
107
106
108 void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
107 void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
109 {
108 {
110 impl->m_MergeAllowedMimeTypes = mimeTypes;
109 impl->m_MergeAllowedMimeTypes = mimeTypes;
111 }
110 }
112
111
113 int VisualizationDragDropContainer::countDragWidget() const
112 int VisualizationDragDropContainer::countDragWidget() const
114 {
113 {
115 auto nbGraph = 0;
114 auto nbGraph = 0;
116 for (auto child : children()) {
115 for (auto child : children()) {
117 auto widget = qobject_cast<VisualizationDragWidget *>(child);
116 if (qobject_cast<VisualizationDragWidget *>(child)) {
118 if (widget) {
119 nbGraph += 1;
117 nbGraph += 1;
120 }
118 }
121 }
119 }
122
120
123 return nbGraph;
121 return nbGraph;
124 }
122 }
125
123
126 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
124 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
127 const QPoint &dragPosition)
125 const QPoint &dragPosition)
128 {
126 {
129 auto &helper = sqpApp->dragDropHelper();
127 auto &helper = sqpApp->dragDropHelper();
130
128
131 // Note: The management of the drag object is done by Qt
129 // Note: The management of the drag object is done by Qt
132 auto *drag = new QDrag{dragWidget};
130 auto drag = new QDrag{dragWidget};
133 drag->setHotSpot(dragPosition);
131 drag->setHotSpot(dragPosition);
134
132
135 auto mimeData = dragWidget->mimeData();
133 auto mimeData = dragWidget->mimeData();
136 drag->setMimeData(mimeData);
134 drag->setMimeData(mimeData);
137
135
138 auto pixmap = QPixmap(dragWidget->size());
136 auto pixmap = QPixmap(dragWidget->size());
139 dragWidget->render(&pixmap);
137 dragWidget->render(&pixmap);
140 drag->setPixmap(pixmap);
138 drag->setPixmap(pixmap);
141
139
142 auto image = pixmap.toImage();
140 auto image = pixmap.toImage();
143 mimeData->setImageData(image);
141 mimeData->setImageData(image);
144 mimeData->setUrls({helper.imageTemporaryUrl(image)});
142 mimeData->setUrls({helper.imageTemporaryUrl(image)});
145
143
146 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
144 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
147 helper.setCurrentDragWidget(dragWidget);
145 helper.setCurrentDragWidget(dragWidget);
148
146
149 if (impl->cursorIsInContainer(this)) {
147 if (impl->cursorIsInContainer(this)) {
150 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
148 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
151 helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
149 helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
152 dragWidget->setVisible(false);
150 dragWidget->setVisible(false);
153 }
151 }
154 }
152 }
155
153
156 // Note: The exec() is blocking on windows but not on linux and macOS
154 // Note: The exec() is blocking on windows but not on linux and macOS
157 drag->exec(Qt::MoveAction | Qt::CopyAction);
155 drag->exec(Qt::MoveAction | Qt::CopyAction);
158 }
156 }
159
157
160 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
158 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
161 {
159 {
162 if (impl->acceptMimeData(event->mimeData())) {
160 if (impl->acceptMimeData(event->mimeData())) {
163 event->acceptProposedAction();
161 event->acceptProposedAction();
164
162
165 auto &helper = sqpApp->dragDropHelper();
163 auto &helper = sqpApp->dragDropHelper();
166
164
167 if (!impl->hasPlaceHolder()) {
165 if (!impl->hasPlaceHolder()) {
168 auto dragWidget = helper.getCurrentDragWidget();
166 auto dragWidget = helper.getCurrentDragWidget();
169 auto parentWidget
167 auto parentWidget
170 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
168 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
171 if (parentWidget) {
169 if (parentWidget) {
172 dragWidget->setVisible(false);
170 dragWidget->setVisible(false);
173 }
171 }
174
172
175 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
173 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
176
174
177 if (dragWidgetHovered) {
175 if (dragWidgetHovered) {
178 auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
176 auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
179 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
177 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
180 if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
178 if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
181 hoveredWidgetIndex
179 hoveredWidgetIndex
182 += 1; // Correction of the index if the drop occurs in the same container
180 += 1; // Correction of the index if the drop occurs in the same container
183 }
181 }
184
182
185 helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
183 helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
186 }
184 }
187 else {
185 else {
188 helper.insertPlaceHolder(impl->m_Layout, 0);
186 helper.insertPlaceHolder(impl->m_Layout, 0);
189 }
187 }
190 }
188 }
191 }
189 }
192 else
190 else {
193 event->ignore();
191 event->ignore();
192 }
194
193
195 QWidget::dragEnterEvent(event);
194 QWidget::dragEnterEvent(event);
196 }
195 }
197
196
198 void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
197 void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
199 {
198 {
200 Q_UNUSED(event);
199 Q_UNUSED(event);
201
200
202 auto &helper = sqpApp->dragDropHelper();
201 auto &helper = sqpApp->dragDropHelper();
203
202
204 if (!impl->cursorIsInContainer(this)) {
203 if (!impl->cursorIsInContainer(this)) {
205 helper.removePlaceHolder();
204 helper.removePlaceHolder();
206
205
207 bool isInternal = true;
206 bool isInternal = true;
208 if (isInternal) {
207 if (isInternal) {
209 // Only if the drag is strated from the visualization
208 // Only if the drag is started from the visualization
210 // Show the drag widget at its original place
209 // Show the drag widget at its original place
211 // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
210 // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
212 // drop zone (It is not possible to catch a drop event outside of the application)
211 // drop zone (It is not possible to catch a drop event outside of the application)
213
212
214 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
213 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
215 if (dragWidget) {
214 if (dragWidget) {
216 dragWidget->setVisible(true);
215 dragWidget->setVisible(true);
217 }
216 }
218 }
217 }
219 }
218 }
220
219
221 QWidget::dragLeaveEvent(event);
220 QWidget::dragLeaveEvent(event);
222 }
221 }
223
222
224 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
223 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
225 {
224 {
226 if (impl->acceptMimeData(event->mimeData())) {
225 if (impl->acceptMimeData(event->mimeData())) {
227 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
226 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
228 if (dragWidgetHovered) {
227 if (dragWidgetHovered) {
229 auto canMerge = impl->allowMergeMimeData(event->mimeData());
228 auto canMerge = impl->allowMergeMimeData(event->mimeData());
230
229
231 auto nbDragWidget = countDragWidget();
230 auto nbDragWidget = countDragWidget();
232 if (nbDragWidget > 0) {
231 if (nbDragWidget > 0) {
233 auto graphHeight = size().height() / nbDragWidget;
232 auto graphHeight = size().height() / nbDragWidget;
234 auto dropIndex = floor(event->pos().y() / graphHeight);
233 auto dropIndex = floor(event->pos().y() / graphHeight);
235 auto zoneSize = qMin(graphHeight / 3.0, 150.0);
234 auto zoneSize = qMin(graphHeight / 3.0, 150.0);
236
235
237 auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
236 auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
238 auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
237 auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
239
238
240 auto &helper = sqpApp->dragDropHelper();
239 auto &helper = sqpApp->dragDropHelper();
241 auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
240 auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
242
241
243 if (isOnTop || isOnBottom) {
242 if (isOnTop || isOnBottom) {
244 if (isOnBottom) {
243 if (isOnBottom) {
245 dropIndex += 1;
244 dropIndex += 1;
246 }
245 }
247
246
248 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
247 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
249 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
248 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
250 dropIndex += 1; // Correction of the index if the drop occurs in the same
249 dropIndex += 1; // Correction of the index if the drop occurs in the same
251 // container
250 // container
252 }
251 }
253
252
254 if (dropIndex != placeHolderIndex) {
253 if (dropIndex != placeHolderIndex) {
255 helper.insertPlaceHolder(impl->m_Layout, dropIndex);
254 helper.insertPlaceHolder(impl->m_Layout, dropIndex);
256 }
255 }
257 }
256 }
258 else if (canMerge) {
257 else if (canMerge) {
259 // drop on the middle -> merge
258 // drop on the middle -> merge
260 if (impl->hasPlaceHolder()) {
259 if (impl->hasPlaceHolder()) {
261 helper.removePlaceHolder();
260 helper.removePlaceHolder();
262 }
261 }
263 }
262 }
264 }
263 }
265 }
264 }
266 }
265 }
267 else
266 else {
268 event->ignore();
267 event->ignore();
268 }
269
269
270 QWidget::dragMoveEvent(event);
270 QWidget::dragMoveEvent(event);
271 }
271 }
272
272
273 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
273 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
274 {
274 {
275 if (impl->acceptMimeData(event->mimeData())) {
275 if (impl->acceptMimeData(event->mimeData())) {
276 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
276 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
277 if (impl->hasPlaceHolder() && dragWidget) {
277 if (impl->hasPlaceHolder() && dragWidget) {
278 auto &helper = sqpApp->dragDropHelper();
278 auto &helper = sqpApp->dragDropHelper();
279
279
280 auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
280 auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
281
281
282 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
282 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
283 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
283 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
284 droppedIndex
284 droppedIndex
285 -= 1; // Correction of the index if the drop occurs in the same container
285 -= 1; // Correction of the index if the drop occurs in the same container
286 }
286 }
287
287
288 dragWidget->setVisible(true);
288 dragWidget->setVisible(true);
289 dragWidget->setStyleSheet("");
290
289
291 event->acceptProposedAction();
290 event->acceptProposedAction();
292
291
293 helper.removePlaceHolder();
292 helper.removePlaceHolder();
294
293
295 emit dropOccured(droppedIndex, event->mimeData());
294 emit dropOccured(droppedIndex, event->mimeData());
296 }
295 }
297 }
296 }
298 else
297 else {
299 event->ignore();
298 event->ignore();
299 }
300
300
301 QWidget::dropEvent(event);
301 QWidget::dropEvent(event);
302 }
302 }
Show file before | Show file after | Hide comments
@@ -1,384 +1,384
1 #include "Visualization/VisualizationGraphWidget.h"
1 #include "Visualization/VisualizationGraphWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "Visualization/VisualizationDefs.h"
3 #include "Visualization/VisualizationDefs.h"
4 #include "Visualization/VisualizationGraphHelper.h"
4 #include "Visualization/VisualizationGraphHelper.h"
5 #include "Visualization/VisualizationGraphRenderingDelegate.h"
5 #include "Visualization/VisualizationGraphRenderingDelegate.h"
6 #include "Visualization/VisualizationZoneWidget.h"
6 #include "Visualization/VisualizationZoneWidget.h"
7 #include "ui_VisualizationGraphWidget.h"
7 #include "ui_VisualizationGraphWidget.h"
8
8
9 #include <Data/ArrayData.h>
9 #include <Data/ArrayData.h>
10 #include <Data/IDataSeries.h>
10 #include <Data/IDataSeries.h>
11 #include <DragDropHelper.h>
11 #include <DragDropHelper.h>
12 #include <Settings/SqpSettingsDefs.h>
12 #include <Settings/SqpSettingsDefs.h>
13 #include <SqpApplication.h>
13 #include <SqpApplication.h>
14 #include <Variable/Variable.h>
14 #include <Variable/Variable.h>
15 #include <Variable/VariableController.h>
15 #include <Variable/VariableController.h>
16
16
17 #include <unordered_map>
17 #include <unordered_map>
18
18
19 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
19 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
20
20
21 namespace {
21 namespace {
22
22
23 /// Key pressed to enable zoom on horizontal axis
23 /// Key pressed to enable zoom on horizontal axis
24 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
24 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
25
25
26 /// Key pressed to enable zoom on vertical axis
26 /// Key pressed to enable zoom on vertical axis
27 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
27 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
28
28
29 } // namespace
29 } // namespace
30
30
31 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
31 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
32
32
33 explicit VisualizationGraphWidgetPrivate(const QString &name)
33 explicit VisualizationGraphWidgetPrivate(const QString &name)
34 : m_Name{name},
34 : m_Name{name},
35 m_DoAcquisition{true},
35 m_DoAcquisition{true},
36 m_IsCalibration{false},
36 m_IsCalibration{false},
37 m_RenderingDelegate{nullptr}
37 m_RenderingDelegate{nullptr}
38 {
38 {
39 }
39 }
40
40
41 QString m_Name;
41 QString m_Name;
42 // 1 variable -> n qcpplot
42 // 1 variable -> n qcpplot
43 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
43 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
44 bool m_DoAcquisition;
44 bool m_DoAcquisition;
45 bool m_IsCalibration;
45 bool m_IsCalibration;
46 QCPItemTracer *m_TextTracer;
46 QCPItemTracer *m_TextTracer;
47 /// Delegate used to attach rendering features to the plot
47 /// Delegate used to attach rendering features to the plot
48 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
48 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
49 };
49 };
50
50
51 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
51 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
52 : VisualizationDragWidget{parent},
52 : VisualizationDragWidget{parent},
53 ui{new Ui::VisualizationGraphWidget},
53 ui{new Ui::VisualizationGraphWidget},
54 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
54 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
55 {
55 {
56 ui->setupUi(this);
56 ui->setupUi(this);
57
57
58 // 'Close' options : widget is deleted when closed
58 // 'Close' options : widget is deleted when closed
59 setAttribute(Qt::WA_DeleteOnClose);
59 setAttribute(Qt::WA_DeleteOnClose);
60
60
61 // Set qcpplot properties :
61 // Set qcpplot properties :
62 // - Drag (on x-axis) and zoom are enabled
62 // - Drag (on x-axis) and zoom are enabled
63 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
63 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
64 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
64 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
65 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
65 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
66
66
67 // The delegate must be initialized after the ui as it uses the plot
67 // The delegate must be initialized after the ui as it uses the plot
68 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
68 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
69
69
70 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
70 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
71 connect(ui->widget, &QCustomPlot::mouseRelease, this,
71 connect(ui->widget, &QCustomPlot::mouseRelease, this,
72 &VisualizationGraphWidget::onMouseRelease);
72 &VisualizationGraphWidget::onMouseRelease);
73 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
73 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
74 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
74 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
75 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
75 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
76 &QCPAxis::rangeChanged),
76 &QCPAxis::rangeChanged),
77 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
77 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
78
78
79 // Activates menu when right clicking on the graph
79 // Activates menu when right clicking on the graph
80 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
80 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
81 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
81 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
82 &VisualizationGraphWidget::onGraphMenuRequested);
82 &VisualizationGraphWidget::onGraphMenuRequested);
83
83
84 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
84 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
85 &VariableController::onRequestDataLoading);
85 &VariableController::onRequestDataLoading);
86
86
87 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
87 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
88 &VisualizationGraphWidget::onUpdateVarDisplaying);
88 &VisualizationGraphWidget::onUpdateVarDisplaying);
89 }
89 }
90
90
91
91
92 VisualizationGraphWidget::~VisualizationGraphWidget()
92 VisualizationGraphWidget::~VisualizationGraphWidget()
93 {
93 {
94 delete ui;
94 delete ui;
95 }
95 }
96
96
97 VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
97 VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
98 {
98 {
99 auto parent = parentWidget();
99 auto parent = parentWidget();
100 do {
100 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
101 parent = parent->parentWidget();
101 parent = parent->parentWidget();
102 } while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent));
102 }
103
103
104 return qobject_cast<VisualizationZoneWidget *>(parent);
104 return qobject_cast<VisualizationZoneWidget *>(parent);
105 }
105 }
106
106
107 void VisualizationGraphWidget::enableAcquisition(bool enable)
107 void VisualizationGraphWidget::enableAcquisition(bool enable)
108 {
108 {
109 impl->m_DoAcquisition = enable;
109 impl->m_DoAcquisition = enable;
110 }
110 }
111
111
112 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
112 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
113 {
113 {
114 // Uses delegate to create the qcpplot components according to the variable
114 // Uses delegate to create the qcpplot components according to the variable
115 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
115 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
116 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
116 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
117
117
118 // Set axes properties according to the units of the data series
118 // Set axes properties according to the units of the data series
119 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
119 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
120 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
120 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
121 auto xAxisUnit = Unit{};
121 auto xAxisUnit = Unit{};
122 auto valuesUnit = Unit{};
122 auto valuesUnit = Unit{};
123
123
124 if (auto dataSeries = variable->dataSeries()) {
124 if (auto dataSeries = variable->dataSeries()) {
125 dataSeries->lockRead();
125 dataSeries->lockRead();
126 xAxisUnit = dataSeries->xAxisUnit();
126 xAxisUnit = dataSeries->xAxisUnit();
127 valuesUnit = dataSeries->valuesUnit();
127 valuesUnit = dataSeries->valuesUnit();
128 dataSeries->unlock();
128 dataSeries->unlock();
129 }
129 }
130 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
130 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
131
131
132 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
132 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
133
133
134 this->enableAcquisition(false);
134 this->enableAcquisition(false);
135 this->setGraphRange(range);
135 this->setGraphRange(range);
136 this->enableAcquisition(true);
136 this->enableAcquisition(true);
137
137
138 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
138 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
139
139
140 emit variableAdded(variable);
140 emit variableAdded(variable);
141 }
141 }
142
142
143 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
143 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
144 {
144 {
145 // Each component associated to the variable :
145 // Each component associated to the variable :
146 // - is removed from qcpplot (which deletes it)
146 // - is removed from qcpplot (which deletes it)
147 // - is no longer referenced in the map
147 // - is no longer referenced in the map
148 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
148 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
149 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
149 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
150 emit variableAboutToBeRemoved(variable);
150 emit variableAboutToBeRemoved(variable);
151
151
152 auto &plottablesMap = variableIt->second;
152 auto &plottablesMap = variableIt->second;
153
153
154 for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
154 for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
155 plottableIt != plottableEnd;) {
155 plottableIt != plottableEnd;) {
156 ui->widget->removePlottable(plottableIt->second);
156 ui->widget->removePlottable(plottableIt->second);
157 plottableIt = plottablesMap.erase(plottableIt);
157 plottableIt = plottablesMap.erase(plottableIt);
158 }
158 }
159
159
160 impl->m_VariableToPlotMultiMap.erase(variableIt);
160 impl->m_VariableToPlotMultiMap.erase(variableIt);
161 }
161 }
162
162
163 // Updates graph
163 // Updates graph
164 ui->widget->replot();
164 ui->widget->replot();
165 }
165 }
166
166
167 QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
167 QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
168 {
168 {
169 auto variables = QList<std::shared_ptr<Variable> >{};
169 auto variables = QList<std::shared_ptr<Variable> >{};
170 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
170 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
171 it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
171 it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
172 variables << it->first;
172 variables << it->first;
173 }
173 }
174
174
175 return variables;
175 return variables;
176 }
176 }
177
177
178 void VisualizationGraphWidget::setYRange(const SqpRange &range)
178 void VisualizationGraphWidget::setYRange(const SqpRange &range)
179 {
179 {
180 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
180 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
181 }
181 }
182
182
183 SqpRange VisualizationGraphWidget::graphRange() const noexcept
183 SqpRange VisualizationGraphWidget::graphRange() const noexcept
184 {
184 {
185 auto graphRange = ui->widget->xAxis->range();
185 auto graphRange = ui->widget->xAxis->range();
186 return SqpRange{graphRange.lower, graphRange.upper};
186 return SqpRange{graphRange.lower, graphRange.upper};
187 }
187 }
188
188
189 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
189 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
190 {
190 {
191 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
191 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
192 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
192 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
193 ui->widget->replot();
193 ui->widget->replot();
194 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
194 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
195 }
195 }
196
196
197 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
197 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
198 {
198 {
199 if (visitor) {
199 if (visitor) {
200 visitor->visit(this);
200 visitor->visit(this);
201 }
201 }
202 else {
202 else {
203 qCCritical(LOG_VisualizationGraphWidget())
203 qCCritical(LOG_VisualizationGraphWidget())
204 << tr("Can't visit widget : the visitor is null");
204 << tr("Can't visit widget : the visitor is null");
205 }
205 }
206 }
206 }
207
207
208 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
208 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
209 {
209 {
210 /// @todo : for the moment, a graph can always accomodate a variable
210 /// @todo : for the moment, a graph can always accomodate a variable
211 Q_UNUSED(variable);
211 Q_UNUSED(variable);
212 return true;
212 return true;
213 }
213 }
214
214
215 bool VisualizationGraphWidget::contains(const Variable &variable) const
215 bool VisualizationGraphWidget::contains(const Variable &variable) const
216 {
216 {
217 // Finds the variable among the keys of the map
217 // Finds the variable among the keys of the map
218 auto variablePtr = &variable;
218 auto variablePtr = &variable;
219 auto findVariable
219 auto findVariable
220 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
220 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
221
221
222 auto end = impl->m_VariableToPlotMultiMap.cend();
222 auto end = impl->m_VariableToPlotMultiMap.cend();
223 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
223 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
224 return it != end;
224 return it != end;
225 }
225 }
226
226
227 QString VisualizationGraphWidget::name() const
227 QString VisualizationGraphWidget::name() const
228 {
228 {
229 return impl->m_Name;
229 return impl->m_Name;
230 }
230 }
231
231
232 QMimeData *VisualizationGraphWidget::mimeData() const
232 QMimeData *VisualizationGraphWidget::mimeData() const
233 {
233 {
234 auto *mimeData = new QMimeData;
234 auto mimeData = new QMimeData;
235 mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
235 mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
236
236
237 return mimeData;
237 return mimeData;
238 }
238 }
239
239
240 bool VisualizationGraphWidget::isDragAllowed() const
240 bool VisualizationGraphWidget::isDragAllowed() const
241 {
241 {
242 return true;
242 return true;
243 }
243 }
244
244
245 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
245 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
246 {
246 {
247 Q_UNUSED(event);
247 Q_UNUSED(event);
248
248
249 // Prevents that all variables will be removed from graph when it will be closed
249 // Prevents that all variables will be removed from graph when it will be closed
250 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
250 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
251 emit variableAboutToBeRemoved(variableEntry.first);
251 emit variableAboutToBeRemoved(variableEntry.first);
252 }
252 }
253 }
253 }
254
254
255 void VisualizationGraphWidget::enterEvent(QEvent *event)
255 void VisualizationGraphWidget::enterEvent(QEvent *event)
256 {
256 {
257 Q_UNUSED(event);
257 Q_UNUSED(event);
258 impl->m_RenderingDelegate->showGraphOverlay(true);
258 impl->m_RenderingDelegate->showGraphOverlay(true);
259 }
259 }
260
260
261 void VisualizationGraphWidget::leaveEvent(QEvent *event)
261 void VisualizationGraphWidget::leaveEvent(QEvent *event)
262 {
262 {
263 Q_UNUSED(event);
263 Q_UNUSED(event);
264 impl->m_RenderingDelegate->showGraphOverlay(false);
264 impl->m_RenderingDelegate->showGraphOverlay(false);
265 }
265 }
266
266
267 QCustomPlot &VisualizationGraphWidget::plot() noexcept
267 QCustomPlot &VisualizationGraphWidget::plot() noexcept
268 {
268 {
269 return *ui->widget;
269 return *ui->widget;
270 }
270 }
271
271
272 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
272 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
273 {
273 {
274 QMenu graphMenu{};
274 QMenu graphMenu{};
275
275
276 // Iterates on variables (unique keys)
276 // Iterates on variables (unique keys)
277 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
277 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
278 end = impl->m_VariableToPlotMultiMap.cend();
278 end = impl->m_VariableToPlotMultiMap.cend();
279 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
279 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
280 // 'Remove variable' action
280 // 'Remove variable' action
281 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
281 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
282 [ this, var = it->first ]() { removeVariable(var); });
282 [ this, var = it->first ]() { removeVariable(var); });
283 }
283 }
284
284
285 if (!graphMenu.isEmpty()) {
285 if (!graphMenu.isEmpty()) {
286 graphMenu.exec(QCursor::pos());
286 graphMenu.exec(QCursor::pos());
287 }
287 }
288 }
288 }
289
289
290 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
290 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
291 {
291 {
292 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
292 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
293 << QThread::currentThread()->objectName() << "DoAcqui"
293 << QThread::currentThread()->objectName() << "DoAcqui"
294 << impl->m_DoAcquisition;
294 << impl->m_DoAcquisition;
295
295
296 auto graphRange = SqpRange{t1.lower, t1.upper};
296 auto graphRange = SqpRange{t1.lower, t1.upper};
297 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
297 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
298
298
299 if (impl->m_DoAcquisition) {
299 if (impl->m_DoAcquisition) {
300 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
300 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
301
301
302 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
302 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
303 end = impl->m_VariableToPlotMultiMap.end();
303 end = impl->m_VariableToPlotMultiMap.end();
304 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
304 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
305 variableUnderGraphVector.push_back(it->first);
305 variableUnderGraphVector.push_back(it->first);
306 }
306 }
307 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
307 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
308 !impl->m_IsCalibration);
308 !impl->m_IsCalibration);
309
309
310 if (!impl->m_IsCalibration) {
310 if (!impl->m_IsCalibration) {
311 qCDebug(LOG_VisualizationGraphWidget())
311 qCDebug(LOG_VisualizationGraphWidget())
312 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
312 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
313 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
313 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
314 emit synchronize(graphRange, oldGraphRange);
314 emit synchronize(graphRange, oldGraphRange);
315 }
315 }
316 }
316 }
317 }
317 }
318
318
319 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
319 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
320 {
320 {
321 // Handles plot rendering when mouse is moving
321 // Handles plot rendering when mouse is moving
322 impl->m_RenderingDelegate->onMouseMove(event);
322 impl->m_RenderingDelegate->onMouseMove(event);
323
323
324 VisualizationDragWidget::mouseMoveEvent(event);
324 VisualizationDragWidget::mouseMoveEvent(event);
325 }
325 }
326
326
327 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
327 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
328 {
328 {
329 auto zoomOrientations = QFlags<Qt::Orientation>{};
329 auto zoomOrientations = QFlags<Qt::Orientation>{};
330
330
331 // Lambda that enables a zoom orientation if the key modifier related to this orientation
331 // Lambda that enables a zoom orientation if the key modifier related to this orientation
332 // has
332 // has
333 // been pressed
333 // been pressed
334 auto enableOrientation
334 auto enableOrientation
335 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
335 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
336 auto orientationEnabled = event->modifiers().testFlag(modifier);
336 auto orientationEnabled = event->modifiers().testFlag(modifier);
337 zoomOrientations.setFlag(orientation, orientationEnabled);
337 zoomOrientations.setFlag(orientation, orientationEnabled);
338 };
338 };
339 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
339 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
340 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
340 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
341
341
342 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
342 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
343 }
343 }
344
344
345 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
345 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
346 {
346 {
347 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
347 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
348
348
349 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
349 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
350
350
351 VisualizationDragWidget::mousePressEvent(event);
351 VisualizationDragWidget::mousePressEvent(event);
352 }
352 }
353
353
354 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
354 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
355 {
355 {
356 impl->m_IsCalibration = false;
356 impl->m_IsCalibration = false;
357 }
357 }
358
358
359 void VisualizationGraphWidget::onDataCacheVariableUpdated()
359 void VisualizationGraphWidget::onDataCacheVariableUpdated()
360 {
360 {
361 auto graphRange = ui->widget->xAxis->range();
361 auto graphRange = ui->widget->xAxis->range();
362 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
362 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
363
363
364 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
364 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
365 auto variable = variableEntry.first;
365 auto variable = variableEntry.first;
366 qCDebug(LOG_VisualizationGraphWidget())
366 qCDebug(LOG_VisualizationGraphWidget())
367 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
367 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
368 qCDebug(LOG_VisualizationGraphWidget())
368 qCDebug(LOG_VisualizationGraphWidget())
369 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
369 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
370 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
370 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
371 VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
371 VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
372 variable->range());
372 variable->range());
373 }
373 }
374 }
374 }
375 }
375 }
376
376
377 void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
377 void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
378 const SqpRange &range)
378 const SqpRange &range)
379 {
379 {
380 auto it = impl->m_VariableToPlotMultiMap.find(variable);
380 auto it = impl->m_VariableToPlotMultiMap.find(variable);
381 if (it != impl->m_VariableToPlotMultiMap.end()) {
381 if (it != impl->m_VariableToPlotMultiMap.end()) {
382 VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
382 VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
383 }
383 }
384 }
384 }
Show file before | Show file after | Hide comments
@@ -1,410 +1,410
1 #include "Visualization/VisualizationZoneWidget.h"
1 #include "Visualization/VisualizationZoneWidget.h"
2
2
3 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "Visualization/IVisualizationWidgetVisitor.h"
4 #include "Visualization/QCustomPlotSynchronizer.h"
4 #include "Visualization/QCustomPlotSynchronizer.h"
5 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationGraphWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
7
7
8 #include <Data/SqpRange.h>
8 #include <Data/SqpRange.h>
9 #include <Variable/Variable.h>
9 #include <Variable/Variable.h>
10 #include <Variable/VariableController.h>
10 #include <Variable/VariableController.h>
11
11
12 #include <DragDropHelper.h>
12 #include <DragDropHelper.h>
13 #include <QUuid>
13 #include <QUuid>
14 #include <SqpApplication.h>
14 #include <SqpApplication.h>
15 #include <cmath>
15 #include <cmath>
16
16
17 #include <QLayout>
17 #include <QLayout>
18
18
19 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
19 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
20
20
21 namespace {
21 namespace {
22
22
23 /// Minimum height for graph added in zones (in pixels)
23 /// Minimum height for graph added in zones (in pixels)
24 const auto GRAPH_MINIMUM_HEIGHT = 300;
24 const auto GRAPH_MINIMUM_HEIGHT = 300;
25
25
26 /// Generates a default name for a new graph, according to the number of graphs already displayed in
26 /// Generates a default name for a new graph, according to the number of graphs already displayed in
27 /// the zone
27 /// the zone
28 QString defaultGraphName(const QLayout &layout)
28 QString defaultGraphName(const QLayout &layout)
29 {
29 {
30 auto count = 0;
30 auto count = 0;
31 for (auto i = 0; i < layout.count(); ++i) {
31 for (auto i = 0; i < layout.count(); ++i) {
32 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
32 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
33 count++;
33 count++;
34 }
34 }
35 }
35 }
36
36
37 return QObject::tr("Graph %1").arg(count + 1);
37 return QObject::tr("Graph %1").arg(count + 1);
38 }
38 }
39
39
40 /**
40 /**
41 * Applies a function to all graphs of the zone represented by its layout
41 * Applies a function to all graphs of the zone represented by its layout
42 * @param layout the layout that contains graphs
42 * @param layout the layout that contains graphs
43 * @param fun the function to apply to each graph
43 * @param fun the function to apply to each graph
44 */
44 */
45 template <typename Fun>
45 template <typename Fun>
46 void processGraphs(QLayout &layout, Fun fun)
46 void processGraphs(QLayout &layout, Fun fun)
47 {
47 {
48 for (auto i = 0; i < layout.count(); ++i) {
48 for (auto i = 0; i < layout.count(); ++i) {
49 if (auto item = layout.itemAt(i)) {
49 if (auto item = layout.itemAt(i)) {
50 if (auto visualizationGraphWidget
50 if (auto visualizationGraphWidget
51 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
51 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
52 fun(*visualizationGraphWidget);
52 fun(*visualizationGraphWidget);
53 }
53 }
54 }
54 }
55 }
55 }
56 }
56 }
57
57
58 } // namespace
58 } // namespace
59
59
60 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
60 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
61
61
62 explicit VisualizationZoneWidgetPrivate()
62 explicit VisualizationZoneWidgetPrivate()
63 : m_SynchronisationGroupId{QUuid::createUuid()},
63 : m_SynchronisationGroupId{QUuid::createUuid()},
64 m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
64 m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
65 {
65 {
66 }
66 }
67 QUuid m_SynchronisationGroupId;
67 QUuid m_SynchronisationGroupId;
68 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
68 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
69 };
69 };
70
70
71 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
71 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
72 : VisualizationDragWidget{parent},
72 : VisualizationDragWidget{parent},
73 ui{new Ui::VisualizationZoneWidget},
73 ui{new Ui::VisualizationZoneWidget},
74 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
74 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
75 {
75 {
76 ui->setupUi(this);
76 ui->setupUi(this);
77
77
78 ui->zoneNameLabel->setText(name);
78 ui->zoneNameLabel->setText(name);
79
79
80 ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
80 ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
81 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
81 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
82 &VisualizationZoneWidget::dropMimeData);
82 &VisualizationZoneWidget::dropMimeData);
83
83
84 // 'Close' options : widget is deleted when closed
84 // 'Close' options : widget is deleted when closed
85 setAttribute(Qt::WA_DeleteOnClose);
85 setAttribute(Qt::WA_DeleteOnClose);
86 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
86 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
87 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
87 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
88
88
89 // Synchronisation id
89 // Synchronisation id
90 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
90 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
91 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
91 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
92 }
92 }
93
93
94 VisualizationZoneWidget::~VisualizationZoneWidget()
94 VisualizationZoneWidget::~VisualizationZoneWidget()
95 {
95 {
96 delete ui;
96 delete ui;
97 }
97 }
98
98
99 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
99 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
100 {
100 {
101 // Synchronize new graph with others in the zone
101 // Synchronize new graph with others in the zone
102 impl->m_Synchronizer->addGraph(*graphWidget);
102 impl->m_Synchronizer->addGraph(*graphWidget);
103
103
104 ui->dragDropContainer->addDragWidget(graphWidget);
104 ui->dragDropContainer->addDragWidget(graphWidget);
105 }
105 }
106
106
107 void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
107 void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
108 {
108 {
109 // Synchronize new graph with others in the zone
109 // Synchronize new graph with others in the zone
110 impl->m_Synchronizer->addGraph(*graphWidget);
110 impl->m_Synchronizer->addGraph(*graphWidget);
111
111
112 ui->dragDropContainer->insertDragWidget(index, graphWidget);
112 ui->dragDropContainer->insertDragWidget(index, graphWidget);
113 }
113 }
114
114
115 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
115 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
116 {
116 {
117 return createGraph(variable, -1);
117 return createGraph(variable, -1);
118 }
118 }
119
119
120 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
120 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
121 int index)
121 int index)
122 {
122 {
123 auto graphWidget
123 auto graphWidget
124 = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
124 = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
125
125
126
126
127 // Set graph properties
127 // Set graph properties
128 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
128 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
129 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
129 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
130
130
131
131
132 // Lambda to synchronize zone widget
132 // Lambda to synchronize zone widget
133 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
133 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
134 const SqpRange &oldGraphRange) {
134 const SqpRange &oldGraphRange) {
135
135
136 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
136 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
137 auto frameLayout = ui->dragDropContainer->layout();
137 auto frameLayout = ui->dragDropContainer->layout();
138 for (auto i = 0; i < frameLayout->count(); ++i) {
138 for (auto i = 0; i < frameLayout->count(); ++i) {
139 auto graphChild
139 auto graphChild
140 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
140 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
141 if (graphChild && (graphChild != graphWidget)) {
141 if (graphChild && (graphChild != graphWidget)) {
142
142
143 auto graphChildRange = graphChild->graphRange();
143 auto graphChildRange = graphChild->graphRange();
144 switch (zoomType) {
144 switch (zoomType) {
145 case AcquisitionZoomType::ZoomIn: {
145 case AcquisitionZoomType::ZoomIn: {
146 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
146 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
147 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
147 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
148 graphChildRange.m_TStart += deltaLeft;
148 graphChildRange.m_TStart += deltaLeft;
149 graphChildRange.m_TEnd -= deltaRight;
149 graphChildRange.m_TEnd -= deltaRight;
150 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
150 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
151 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
151 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
152 << deltaLeft;
152 << deltaLeft;
153 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
153 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
154 << deltaRight;
154 << deltaRight;
155 qCDebug(LOG_VisualizationZoneWidget())
155 qCDebug(LOG_VisualizationZoneWidget())
156 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
156 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
157
157
158 break;
158 break;
159 }
159 }
160
160
161 case AcquisitionZoomType::ZoomOut: {
161 case AcquisitionZoomType::ZoomOut: {
162 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
162 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
163 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
163 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
164 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
164 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
165 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
165 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
166 << deltaLeft;
166 << deltaLeft;
167 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
167 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
168 << deltaRight;
168 << deltaRight;
169 qCDebug(LOG_VisualizationZoneWidget())
169 qCDebug(LOG_VisualizationZoneWidget())
170 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
170 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
171 graphChildRange.m_TStart -= deltaLeft;
171 graphChildRange.m_TStart -= deltaLeft;
172 graphChildRange.m_TEnd += deltaRight;
172 graphChildRange.m_TEnd += deltaRight;
173 break;
173 break;
174 }
174 }
175 case AcquisitionZoomType::PanRight: {
175 case AcquisitionZoomType::PanRight: {
176 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
176 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
177 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
177 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
178 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
178 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
179 graphChildRange.m_TStart += deltaLeft;
179 graphChildRange.m_TStart += deltaLeft;
180 graphChildRange.m_TEnd += deltaRight;
180 graphChildRange.m_TEnd += deltaRight;
181 qCDebug(LOG_VisualizationZoneWidget())
181 qCDebug(LOG_VisualizationZoneWidget())
182 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
182 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
183 break;
183 break;
184 }
184 }
185 case AcquisitionZoomType::PanLeft: {
185 case AcquisitionZoomType::PanLeft: {
186 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
186 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
187 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
187 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
188 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
188 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
189 graphChildRange.m_TStart -= deltaLeft;
189 graphChildRange.m_TStart -= deltaLeft;
190 graphChildRange.m_TEnd -= deltaRight;
190 graphChildRange.m_TEnd -= deltaRight;
191 break;
191 break;
192 }
192 }
193 case AcquisitionZoomType::Unknown: {
193 case AcquisitionZoomType::Unknown: {
194 qCDebug(LOG_VisualizationZoneWidget())
194 qCDebug(LOG_VisualizationZoneWidget())
195 << tr("Impossible to synchronize: zoom type unknown");
195 << tr("Impossible to synchronize: zoom type unknown");
196 break;
196 break;
197 }
197 }
198 default:
198 default:
199 qCCritical(LOG_VisualizationZoneWidget())
199 qCCritical(LOG_VisualizationZoneWidget())
200 << tr("Impossible to synchronize: zoom type not take into account");
200 << tr("Impossible to synchronize: zoom type not take into account");
201 // No action
201 // No action
202 break;
202 break;
203 }
203 }
204 graphChild->enableAcquisition(false);
204 graphChild->enableAcquisition(false);
205 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
205 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
206 << graphChild->graphRange();
206 << graphChild->graphRange();
207 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
207 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
208 << graphChildRange;
208 << graphChildRange;
209 qCDebug(LOG_VisualizationZoneWidget())
209 qCDebug(LOG_VisualizationZoneWidget())
210 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
210 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
211 graphChild->setGraphRange(graphChildRange);
211 graphChild->setGraphRange(graphChildRange);
212 graphChild->enableAcquisition(true);
212 graphChild->enableAcquisition(true);
213 }
213 }
214 }
214 }
215 };
215 };
216
216
217 // connection for synchronization
217 // connection for synchronization
218 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
218 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
219 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
219 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
220 &VisualizationZoneWidget::onVariableAdded);
220 &VisualizationZoneWidget::onVariableAdded);
221 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
221 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
222 &VisualizationZoneWidget::onVariableAboutToBeRemoved);
222 &VisualizationZoneWidget::onVariableAboutToBeRemoved);
223
223
224 auto range = SqpRange{};
224 auto range = SqpRange{};
225
225
226 // Apply visitor to graph children
226 // Apply visitor to graph children
227 auto layout = ui->dragDropContainer->layout();
227 auto layout = ui->dragDropContainer->layout();
228 if (layout->count() > 0) {
228 if (layout->count() > 0) {
229 // Case of a new graph in a existant zone
229 // Case of a new graph in a existant zone
230 if (auto visualizationGraphWidget
230 if (auto visualizationGraphWidget
231 = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
231 = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
232 range = visualizationGraphWidget->graphRange();
232 range = visualizationGraphWidget->graphRange();
233 }
233 }
234 }
234 }
235 else {
235 else {
236 // Case of a new graph as the first of the zone
236 // Case of a new graph as the first of the zone
237 range = variable->range();
237 range = variable->range();
238 }
238 }
239
239
240 this->insertGraph(index, graphWidget);
240 this->insertGraph(index, graphWidget);
241
241
242 graphWidget->addVariable(variable, range);
242 graphWidget->addVariable(variable, range);
243
243
244 // get y using variable range
244 // get y using variable range
245 if (auto dataSeries = variable->dataSeries()) {
245 if (auto dataSeries = variable->dataSeries()) {
246 dataSeries->lockRead();
246 dataSeries->lockRead();
247 auto valuesBounds
247 auto valuesBounds
248 = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
248 = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
249 auto end = dataSeries->cend();
249 auto end = dataSeries->cend();
250 if (valuesBounds.first != end && valuesBounds.second != end) {
250 if (valuesBounds.first != end && valuesBounds.second != end) {
251 auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
251 auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
252
252
253 auto minValue = rangeValue(valuesBounds.first->minValue());
253 auto minValue = rangeValue(valuesBounds.first->minValue());
254 auto maxValue = rangeValue(valuesBounds.second->maxValue());
254 auto maxValue = rangeValue(valuesBounds.second->maxValue());
255
255
256 graphWidget->setYRange(SqpRange{minValue, maxValue});
256 graphWidget->setYRange(SqpRange{minValue, maxValue});
257 }
257 }
258 dataSeries->unlock();
258 dataSeries->unlock();
259 }
259 }
260
260
261 return graphWidget;
261 return graphWidget;
262 }
262 }
263
263
264 VisualizationGraphWidget *
264 VisualizationGraphWidget *
265 VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
265 VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
266 {
266 {
267 if (variables.isEmpty()) {
267 if (variables.isEmpty()) {
268 return nullptr;
268 return nullptr;
269 }
269 }
270
270
271 auto graphWidget = createGraph(variables.first(), index);
271 auto graphWidget = createGraph(variables.first(), index);
272 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
272 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
273 graphWidget->addVariable(*variableIt, graphWidget->graphRange());
273 graphWidget->addVariable(*variableIt, graphWidget->graphRange());
274 }
274 }
275
275
276 return graphWidget;
276 return graphWidget;
277 }
277 }
278
278
279 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
279 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
280 {
280 {
281 if (visitor) {
281 if (visitor) {
282 visitor->visitEnter(this);
282 visitor->visitEnter(this);
283
283
284 // Apply visitor to graph children: widgets different from graphs are not visited (no
284 // Apply visitor to graph children: widgets different from graphs are not visited (no
285 // action)
285 // action)
286 processGraphs(
286 processGraphs(
287 *ui->dragDropContainer->layout(),
287 *ui->dragDropContainer->layout(),
288 [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
288 [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
289
289
290 visitor->visitLeave(this);
290 visitor->visitLeave(this);
291 }
291 }
292 else {
292 else {
293 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
293 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
294 }
294 }
295 }
295 }
296
296
297 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
297 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
298 {
298 {
299 // A tab can always accomodate a variable
299 // A tab can always accomodate a variable
300 Q_UNUSED(variable);
300 Q_UNUSED(variable);
301 return true;
301 return true;
302 }
302 }
303
303
304 bool VisualizationZoneWidget::contains(const Variable &variable) const
304 bool VisualizationZoneWidget::contains(const Variable &variable) const
305 {
305 {
306 Q_UNUSED(variable);
306 Q_UNUSED(variable);
307 return false;
307 return false;
308 }
308 }
309
309
310 QString VisualizationZoneWidget::name() const
310 QString VisualizationZoneWidget::name() const
311 {
311 {
312 return ui->zoneNameLabel->text();
312 return ui->zoneNameLabel->text();
313 }
313 }
314
314
315 QMimeData *VisualizationZoneWidget::mimeData() const
315 QMimeData *VisualizationZoneWidget::mimeData() const
316 {
316 {
317 auto *mimeData = new QMimeData;
317 auto mimeData = new QMimeData;
318 mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
318 mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
319
319
320 return mimeData;
320 return mimeData;
321 }
321 }
322
322
323 bool VisualizationZoneWidget::isDragAllowed() const
323 bool VisualizationZoneWidget::isDragAllowed() const
324 {
324 {
325 return true;
325 return true;
326 }
326 }
327
327
328 void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
328 void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
329 {
329 {
330 // Closes graphs in the zone
330 // Closes graphs in the zone
331 processGraphs(*ui->dragDropContainer->layout(),
331 processGraphs(*ui->dragDropContainer->layout(),
332 [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
332 [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
333
333
334 // Delete synchronization group from variable controller
334 // Delete synchronization group from variable controller
335 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
335 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
336 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
336 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
337
337
338 QWidget::closeEvent(event);
338 QWidget::closeEvent(event);
339 }
339 }
340
340
341 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
341 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
342 {
342 {
343 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
343 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
344 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
344 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
345 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
345 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
346 }
346 }
347
347
348 void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
348 void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
349 {
349 {
350 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
350 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
351 Q_ARG(std::shared_ptr<Variable>, variable),
351 Q_ARG(std::shared_ptr<Variable>, variable),
352 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
352 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
353 }
353 }
354
354
355 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
355 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
356 {
356 {
357 auto &helper = sqpApp->dragDropHelper();
357 auto &helper = sqpApp->dragDropHelper();
358 if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
358 if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
359 auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
359 auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
360 auto parentDragDropContainer
360 auto parentDragDropContainer
361 = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
361 = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
362 Q_ASSERT(parentDragDropContainer);
362 Q_ASSERT(parentDragDropContainer);
363
363
364 const auto &variables = graphWidget->variables();
364 const auto &variables = graphWidget->variables();
365
365
366 if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
366 if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
367 // The drop didn't occur in the same zone
367 // The drop didn't occur in the same zone
368
368
369 // Abort the requests for the variables (if any)
369 // Abort the requests for the variables (if any)
370 // Commented, because it's not sure if it's needed or not
370 // Commented, because it's not sure if it's needed or not
371 // for (const auto& var : variables)
371 // for (const auto& var : variables)
372 //{
372 //{
373 // sqpApp->variableController().onAbortProgressRequested(var);
373 // sqpApp->variableController().onAbortProgressRequested(var);
374 //}
374 //}
375
375
376 auto previousParentZoneWidget = graphWidget->parentZoneWidget();
376 auto previousParentZoneWidget = graphWidget->parentZoneWidget();
377 auto nbGraph = parentDragDropContainer->countDragWidget();
377 auto nbGraph = parentDragDropContainer->countDragWidget();
378 if (nbGraph == 1) {
378 if (nbGraph == 1) {
379 // This is the only graph in the previous zone, close the zone
379 // This is the only graph in the previous zone, close the zone
380 previousParentZoneWidget->close();
380 previousParentZoneWidget->close();
381 }
381 }
382 else {
382 else {
383 // Close the graph
383 // Close the graph
384 graphWidget->close();
384 graphWidget->close();
385 }
385 }
386
386
387 // Creates the new graph in the zone
387 // Creates the new graph in the zone
388 createGraph(variables, index);
388 createGraph(variables, index);
389 }
389 }
390 else {
390 else {
391 // The drop occurred in the same zone or the graph is empty
391 // The drop occurred in the same zone or the graph is empty
392 // Simple move of the graph, no variable operation associated
392 // Simple move of the graph, no variable operation associated
393 parentDragDropContainer->layout()->removeWidget(graphWidget);
393 parentDragDropContainer->layout()->removeWidget(graphWidget);
394
394
395 if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
395 if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
396 // The graph is empty and dropped in a different zone.
396 // The graph is empty and dropped in a different zone.
397 // Take the range of the first graph in the zone (if existing).
397 // Take the range of the first graph in the zone (if existing).
398 auto layout = ui->dragDropContainer->layout();
398 auto layout = ui->dragDropContainer->layout();
399 if (layout->count() > 0) {
399 if (layout->count() > 0) {
400 if (auto visualizationGraphWidget
400 if (auto visualizationGraphWidget
401 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
401 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
402 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
402 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
403 }
403 }
404 }
404 }
405 }
405 }
406
406
407 ui->dragDropContainer->insertDragWidget(index, graphWidget);
407 ui->dragDropContainer->insertDragWidget(index, graphWidget);
408 }
408 }
409 }
409 }
410 }
410 }
General Comments 0
You need to be logged in to leave comments. Login now