##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Merge pull request 315 from SciQLop-fork develop...
leroux -
r847:6af9a63cc3d0 merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,65
1 #ifndef SCIQLOP_DRAGDROPHELPER_H
2 #define SCIQLOP_DRAGDROPHELPER_H
3
4 #include <Common/spimpl.h>
5 #include <QWidget>
6
7 class QVBoxLayout;
8 class QScrollArea;
9 class VisualizationDragWidget;
10 class QMimeData;
11
12 /**
13 * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
14 * @note A QScrollArea inside an other QScrollArea is not fully supported.
15 */
16 class DragDropScroller : public QObject {
17 Q_OBJECT
18
19 public:
20 DragDropScroller(QObject *parent = nullptr);
21
22 void addScrollArea(QScrollArea *scrollArea);
23 void removeScrollArea(QScrollArea *scrollArea);
24
25 protected:
26 bool eventFilter(QObject *obj, QEvent *event);
27
28 private:
29 class DragDropScrollerPrivate;
30 spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
31
32 private slots:
33 void onTimer();
34 };
35
36 /**
37 * @brief Helper class for drag&drop operations.
38 */
39 class DragDropHelper {
40 public:
41 static const QString MIME_TYPE_GRAPH;
42 static const QString MIME_TYPE_ZONE;
43
44 DragDropHelper();
45 virtual ~DragDropHelper();
46
47 void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
48 VisualizationDragWidget *getCurrentDragWidget() const;
49
50 QWidget &placeHolder() const;
51 void insertPlaceHolder(QVBoxLayout *layout, int index);
52 void removePlaceHolder();
53 bool isPlaceHolderSet() const;
54
55 void addDragDropScrollArea(QScrollArea *scrollArea);
56 void removeDragDropScrollArea(QScrollArea *scrollArea);
57
58 QUrl imageTemporaryUrl(const QImage &image) const;
59
60 private:
61 class DragDropHelperPrivate;
62 spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
63 };
64
65 #endif // SCIQLOP_DRAGDROPHELPER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,42
1 #ifndef SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
2 #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
3
4 #include <Common/spimpl.h>
5 #include <QMimeData>
6 #include <QVBoxLayout>
7 #include <QWidget>
8
9 class VisualizationDragWidget;
10
11 class VisualizationDragDropContainer : public QWidget {
12 Q_OBJECT
13
14 signals:
15 void dropOccured(int dropIndex, const QMimeData *mimeData);
16
17 public:
18 VisualizationDragDropContainer(QWidget *parent = nullptr);
19
20 void addDragWidget(VisualizationDragWidget *dragWidget);
21 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
22
23 void setAcceptedMimeTypes(const QStringList &mimeTypes);
24 void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
25
26 int countDragWidget() const;
27
28 protected:
29 void dragEnterEvent(QDragEnterEvent *event);
30 void dragLeaveEvent(QDragLeaveEvent *event);
31 void dragMoveEvent(QDragMoveEvent *event);
32 void dropEvent(QDropEvent *event);
33
34 private:
35 class VisualizationDragDropContainerPrivate;
36 spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
37
38 private slots:
39 void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
40 };
41
42 #endif // SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,29
1 #ifndef SCIQLOP_VISUALIZATIONDRAGWIDGET_H
2 #define SCIQLOP_VISUALIZATIONDRAGWIDGET_H
3
4 #include <Common/spimpl.h>
5 #include <QMimeData>
6 #include <QWidget>
7
8 class VisualizationDragWidget : public QWidget {
9 Q_OBJECT
10
11 public:
12 VisualizationDragWidget(QWidget *parent = nullptr);
13
14 virtual QMimeData *mimeData() const = 0;
15 virtual bool isDragAllowed() const = 0;
16
17 protected:
18 virtual void mousePressEvent(QMouseEvent *event) override;
19 virtual void mouseMoveEvent(QMouseEvent *event) override;
20
21 private:
22 class VisualizationDragWidgetPrivate;
23 spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
24
25 signals:
26 void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
27 };
28
29 #endif // SCIQLOP_VISUALIZATIONDRAGWIDGET_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,230
1 #include "DragDropHelper.h"
2 #include "SqpApplication.h"
3 #include "Visualization/VisualizationDragWidget.h"
4
5 #include <QDir>
6 #include <QDragEnterEvent>
7 #include <QDragMoveEvent>
8 #include <QScrollArea>
9 #include <QScrollBar>
10 #include <QTimer>
11 #include <QVBoxLayout>
12
13 const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
14 const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
15
16 const int SCROLL_SPEED = 5;
17 const int SCROLL_ZONE_SIZE = 50;
18
19 struct DragDropScroller::DragDropScrollerPrivate {
20
21 QList<QScrollArea *> m_ScrollAreas;
22 QScrollArea *m_CurrentScrollArea = nullptr;
23 std::unique_ptr<QTimer> m_Timer = nullptr;
24
25
26 enum class ScrollDirection { up, down, unknown };
27 ScrollDirection m_Direction = ScrollDirection::unknown;
28
29 explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
30 {
31 m_Timer->setInterval(0);
32 }
33 };
34
35 DragDropScroller::DragDropScroller(QObject *parent)
36 : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
37 {
38 connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
39 }
40
41 void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
42 {
43 impl->m_ScrollAreas << scrollArea;
44 scrollArea->viewport()->setAcceptDrops(true);
45 }
46
47 void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
48 {
49 impl->m_ScrollAreas.removeAll(scrollArea);
50 scrollArea->viewport()->setAcceptDrops(false);
51 }
52
53 bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
54 {
55 if (event->type() == QEvent::DragMove) {
56 auto w = static_cast<QWidget *>(obj);
57
58 if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
59 auto moveEvent = static_cast<QDragMoveEvent *>(event);
60
61 auto pos = moveEvent->pos();
62 if (impl->m_CurrentScrollArea->viewport() != w) {
63 auto globalPos = w->mapToGlobal(moveEvent->pos());
64 pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
65 }
66
67 auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
68 - SCROLL_ZONE_SIZE;
69 auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
70
71 if (!isInTopZone && !isInBottomZone) {
72 impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
73 impl->m_Timer->stop();
74 }
75 else if (!impl->m_Timer->isActive()) {
76 impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
77 : DragDropScrollerPrivate::ScrollDirection::down;
78 impl->m_Timer->start();
79 }
80 }
81 }
82 else if (event->type() == QEvent::DragEnter) {
83 auto w = static_cast<QWidget *>(obj);
84
85 for (auto scrollArea : impl->m_ScrollAreas) {
86 if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
87 auto enterEvent = static_cast<QDragEnterEvent *>(event);
88 enterEvent->acceptProposedAction();
89 enterEvent->setDropAction(Qt::IgnoreAction);
90 impl->m_CurrentScrollArea = scrollArea;
91 break;
92 }
93 }
94 }
95 else if (event->type() == QEvent::DragLeave) {
96 if (impl->m_CurrentScrollArea) {
97 if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
98 .contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
99 impl->m_CurrentScrollArea = nullptr;
100 impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
101 impl->m_Timer->stop();
102 }
103 }
104 }
105 else if (event->type() == QEvent::Drop) {
106 if (impl->m_CurrentScrollArea) {
107 impl->m_CurrentScrollArea = nullptr;
108 impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
109 impl->m_Timer->stop();
110 }
111 }
112
113 return false;
114 }
115
116 void DragDropScroller::onTimer()
117 {
118 if (impl->m_CurrentScrollArea) {
119 auto mvt = 0;
120 switch (impl->m_Direction) {
121 case DragDropScrollerPrivate::ScrollDirection::up:
122 mvt = SCROLL_SPEED;
123 break;
124 case DragDropScrollerPrivate::ScrollDirection::down:
125 mvt = -SCROLL_SPEED;
126 break;
127 default:
128 break;
129 }
130
131 impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
132 impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
133 }
134 }
135
136 struct DragDropHelper::DragDropHelperPrivate {
137
138 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
139 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
140 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
141 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
142 // QTemporaryFile to have a name which is not generated.
143
144 explicit DragDropHelperPrivate()
145 : m_PlaceHolder{std::make_unique<QWidget>()},
146 m_DragDropScroller{std::make_unique<DragDropScroller>()}
147 {
148 m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
149 sqpApp->installEventFilter(m_DragDropScroller.get());
150
151
152 m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
153 }
154
155 void preparePlaceHolder() const
156 {
157 if (m_CurrentDragWidget) {
158 m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
159 m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
160 }
161 else {
162 m_PlaceHolder->setMinimumSize(200, 200);
163 }
164 }
165 };
166
167
168 DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
169 {
170 }
171
172 DragDropHelper::~DragDropHelper()
173 {
174 QFile::remove(impl->m_ImageTempUrl);
175 }
176
177 void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
178 {
179 impl->m_CurrentDragWidget = dragWidget;
180 }
181
182 VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
183 {
184 return impl->m_CurrentDragWidget;
185 }
186
187
188 QWidget &DragDropHelper::placeHolder() const
189 {
190 return *impl->m_PlaceHolder;
191 }
192
193 void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index)
194 {
195 removePlaceHolder();
196 impl->preparePlaceHolder();
197 layout->insertWidget(index, impl->m_PlaceHolder.get());
198 impl->m_PlaceHolder->show();
199 }
200
201 void DragDropHelper::removePlaceHolder()
202 {
203 auto parentWidget = impl->m_PlaceHolder->parentWidget();
204 if (parentWidget) {
205 parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
206 impl->m_PlaceHolder->setParent(nullptr);
207 impl->m_PlaceHolder->hide();
208 }
209 }
210
211 bool DragDropHelper::isPlaceHolderSet() const
212 {
213 return impl->m_PlaceHolder->parentWidget();
214 }
215
216 void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
217 {
218 impl->m_DragDropScroller->addScrollArea(scrollArea);
219 }
220
221 void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
222 {
223 impl->m_DragDropScroller->removeScrollArea(scrollArea);
224 }
225
226 QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
227 {
228 image.save(impl->m_ImageTempUrl);
229 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
230 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,302
1 #include "Visualization/VisualizationDragDropContainer.h"
2 #include "DragDropHelper.h"
3 #include "SqpApplication.h"
4 #include "Visualization/VisualizationDragWidget.h"
5
6 #include <QDrag>
7 #include <QDragEnterEvent>
8 #include <QVBoxLayout>
9
10 #include <cmath>
11 #include <memory>
12
13 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
14
15 QVBoxLayout *m_Layout;
16 QStringList m_AcceptedMimeTypes;
17 QStringList m_MergeAllowedMimeTypes;
18
19 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
20 {
21 m_Layout = new QVBoxLayout(widget);
22 m_Layout->setContentsMargins(0, 0, 0, 0);
23 }
24
25 bool acceptMimeData(const QMimeData *data) const
26 {
27 for (const auto &type : m_AcceptedMimeTypes) {
28 if (data->hasFormat(type)) {
29 return true;
30 }
31 }
32
33 return false;
34 }
35
36 bool allowMergeMimeData(const QMimeData *data) const
37 {
38 for (const auto &type : m_MergeAllowedMimeTypes) {
39 if (data->hasFormat(type)) {
40 return true;
41 }
42 }
43
44 return false;
45 }
46
47 bool hasPlaceHolder() const
48 {
49 return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
50 }
51
52 VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
53 {
54 VisualizationDragWidget *dragWidget = nullptr;
55
56 for (auto child : parent->children()) {
57 auto widget = qobject_cast<VisualizationDragWidget *>(child);
58 if (widget && widget->isVisible()) {
59 if (widget->frameGeometry().contains(pos)) {
60 dragWidget = widget;
61 break;
62 }
63 }
64 }
65
66 return dragWidget;
67 }
68
69 bool cursorIsInContainer(QWidget *container) const
70 {
71 auto adustNum = 18; // to be safe, in case of scrollbar on the side
72 auto containerRect = QRect(QPoint(), container->contentsRect().size())
73 .adjusted(adustNum, adustNum, -adustNum, -adustNum);
74 return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
75 }
76 };
77
78 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
79 : QWidget{parent},
80 impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
81 {
82 setAcceptDrops(true);
83 }
84
85 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
86 {
87 impl->m_Layout->addWidget(dragWidget);
88 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
89 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
90 &VisualizationDragDropContainer::startDrag);
91 }
92
93 void VisualizationDragDropContainer::insertDragWidget(int index,
94 VisualizationDragWidget *dragWidget)
95 {
96 impl->m_Layout->insertWidget(index, dragWidget);
97 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
98 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
99 &VisualizationDragDropContainer::startDrag);
100 }
101
102 void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
103 {
104 impl->m_AcceptedMimeTypes = mimeTypes;
105 }
106
107 void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
108 {
109 impl->m_MergeAllowedMimeTypes = mimeTypes;
110 }
111
112 int VisualizationDragDropContainer::countDragWidget() const
113 {
114 auto nbGraph = 0;
115 for (auto child : children()) {
116 if (qobject_cast<VisualizationDragWidget *>(child)) {
117 nbGraph += 1;
118 }
119 }
120
121 return nbGraph;
122 }
123
124 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
125 const QPoint &dragPosition)
126 {
127 auto &helper = sqpApp->dragDropHelper();
128
129 // Note: The management of the drag object is done by Qt
130 auto drag = new QDrag{dragWidget};
131 drag->setHotSpot(dragPosition);
132
133 auto mimeData = dragWidget->mimeData();
134 drag->setMimeData(mimeData);
135
136 auto pixmap = QPixmap(dragWidget->size());
137 dragWidget->render(&pixmap);
138 drag->setPixmap(pixmap);
139
140 auto image = pixmap.toImage();
141 mimeData->setImageData(image);
142 mimeData->setUrls({helper.imageTemporaryUrl(image)});
143
144 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
145 helper.setCurrentDragWidget(dragWidget);
146
147 if (impl->cursorIsInContainer(this)) {
148 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
149 helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
150 dragWidget->setVisible(false);
151 }
152 }
153
154 // Note: The exec() is blocking on windows but not on linux and macOS
155 drag->exec(Qt::MoveAction | Qt::CopyAction);
156 }
157
158 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
159 {
160 if (impl->acceptMimeData(event->mimeData())) {
161 event->acceptProposedAction();
162
163 auto &helper = sqpApp->dragDropHelper();
164
165 if (!impl->hasPlaceHolder()) {
166 auto dragWidget = helper.getCurrentDragWidget();
167 auto parentWidget
168 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
169 if (parentWidget) {
170 dragWidget->setVisible(false);
171 }
172
173 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
174
175 if (dragWidgetHovered) {
176 auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
177 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
178 if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
179 hoveredWidgetIndex
180 += 1; // Correction of the index if the drop occurs in the same container
181 }
182
183 helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
184 }
185 else {
186 helper.insertPlaceHolder(impl->m_Layout, 0);
187 }
188 }
189 }
190 else {
191 event->ignore();
192 }
193
194 QWidget::dragEnterEvent(event);
195 }
196
197 void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
198 {
199 Q_UNUSED(event);
200
201 auto &helper = sqpApp->dragDropHelper();
202
203 if (!impl->cursorIsInContainer(this)) {
204 helper.removePlaceHolder();
205
206 bool isInternal = true;
207 if (isInternal) {
208 // Only if the drag is started from the visualization
209 // Show the drag widget at its original place
210 // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
211 // drop zone (It is not possible to catch a drop event outside of the application)
212
213 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
214 if (dragWidget) {
215 dragWidget->setVisible(true);
216 }
217 }
218 }
219
220 QWidget::dragLeaveEvent(event);
221 }
222
223 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
224 {
225 if (impl->acceptMimeData(event->mimeData())) {
226 auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
227 if (dragWidgetHovered) {
228 auto canMerge = impl->allowMergeMimeData(event->mimeData());
229
230 auto nbDragWidget = countDragWidget();
231 if (nbDragWidget > 0) {
232 auto graphHeight = size().height() / nbDragWidget;
233 auto dropIndex = floor(event->pos().y() / graphHeight);
234 auto zoneSize = qMin(graphHeight / 3.0, 150.0);
235
236 auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
237 auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
238
239 auto &helper = sqpApp->dragDropHelper();
240 auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
241
242 if (isOnTop || isOnBottom) {
243 if (isOnBottom) {
244 dropIndex += 1;
245 }
246
247 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
248 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
249 dropIndex += 1; // Correction of the index if the drop occurs in the same
250 // container
251 }
252
253 if (dropIndex != placeHolderIndex) {
254 helper.insertPlaceHolder(impl->m_Layout, dropIndex);
255 }
256 }
257 else if (canMerge) {
258 // drop on the middle -> merge
259 if (impl->hasPlaceHolder()) {
260 helper.removePlaceHolder();
261 }
262 }
263 }
264 }
265 }
266 else {
267 event->ignore();
268 }
269
270 QWidget::dragMoveEvent(event);
271 }
272
273 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
274 {
275 if (impl->acceptMimeData(event->mimeData())) {
276 auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
277 if (impl->hasPlaceHolder() && dragWidget) {
278 auto &helper = sqpApp->dragDropHelper();
279
280 auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
281
282 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
283 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
284 droppedIndex
285 -= 1; // Correction of the index if the drop occurs in the same container
286 }
287
288 dragWidget->setVisible(true);
289
290 event->acceptProposedAction();
291
292 helper.removePlaceHolder();
293
294 emit dropOccured(droppedIndex, event->mimeData());
295 }
296 }
297 else {
298 event->ignore();
299 }
300
301 QWidget::dropEvent(event);
302 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,53
1 #include "Visualization/VisualizationDragWidget.h"
2 #include "Visualization/VisualizationDragDropContainer.h"
3
4 #include <QApplication>
5 #include <QMouseEvent>
6
7 struct VisualizationDragWidget::VisualizationDragWidgetPrivate {
8
9 QPoint m_DragStartPosition;
10 bool m_DragStartPositionValid = false;
11
12 explicit VisualizationDragWidgetPrivate() {}
13 };
14
15 VisualizationDragWidget::VisualizationDragWidget(QWidget *parent)
16 : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
17 {
18 }
19
20 void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
21 {
22 if (event->button() == Qt::LeftButton) {
23 impl->m_DragStartPosition = event->pos();
24 }
25
26 impl->m_DragStartPositionValid = isDragAllowed();
27
28 QWidget::mousePressEvent(event);
29 }
30
31 void VisualizationDragWidget::mouseMoveEvent(QMouseEvent *event)
32 {
33 if (!impl->m_DragStartPositionValid || !isDragAllowed()) {
34 return;
35 }
36
37 if (!(event->buttons() & Qt::LeftButton)) {
38 return;
39 }
40
41 if (!event->modifiers().testFlag(Qt::AltModifier)) {
42 return;
43 }
44
45 if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
46 < QApplication::startDragDistance()) {
47 return;
48 }
49
50 emit dragDetected(this, impl->m_DragStartPosition);
51
52 QWidget::mouseMoveEvent(event);
53 }
Show file before | Show file after | Hide comments
@@ -20,6 +20,7 class NetworkController;
20 class TimeController;
20 class TimeController;
21 class VariableController;
21 class VariableController;
22 class VisualizationController;
22 class VisualizationController;
23 class DragDropHelper;
23
24
24 /**
25 /**
25 * @brief The SqpApplication class aims to make the link between SciQlop
26 * @brief The SqpApplication class aims to make the link between SciQlop
@@ -44,6 +45,9 public:
44 VariableController &variableController() noexcept;
45 VariableController &variableController() noexcept;
45 VisualizationController &visualizationController() noexcept;
46 VisualizationController &visualizationController() noexcept;
46
47
48 /// Accessors for the differents sciqlop helpers
49 DragDropHelper &dragDropHelper() noexcept;
50
47 private:
51 private:
48 class SqpApplicationPrivate;
52 class SqpApplicationPrivate;
49 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
53 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
Show file before | Show file after | Hide comments
@@ -2,6 +2,7
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5 #include "Visualization/VisualizationDragWidget.h"
5
6
6 #include <QLoggingCategory>
7 #include <QLoggingCategory>
7 #include <QWidget>
8 #include <QWidget>
@@ -16,12 +17,13 class QCPRange;
16 class QCustomPlot;
17 class QCustomPlot;
17 class SqpRange;
18 class SqpRange;
18 class Variable;
19 class Variable;
20 class VisualizationZoneWidget;
19
21
20 namespace Ui {
22 namespace Ui {
21 class VisualizationGraphWidget;
23 class VisualizationGraphWidget;
22 } // namespace Ui
24 } // namespace Ui
23
25
24 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
26 class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
25 Q_OBJECT
27 Q_OBJECT
26
28
27 friend class QCustomPlotSynchronizer;
29 friend class QCustomPlotSynchronizer;
@@ -31,6 +33,8 public:
31 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
33 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
32 virtual ~VisualizationGraphWidget();
34 virtual ~VisualizationGraphWidget();
33
35
36 VisualizationZoneWidget *parentZoneWidget() const noexcept;
37
34 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
38 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
35 void enableAcquisition(bool enable);
39 void enableAcquisition(bool enable);
36
40
@@ -39,6 +43,9 public:
39 /// Removes a variable from the graph
43 /// Removes a variable from the graph
40 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
44 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
41
45
46 /// Returns the list of all variables used in the graph
47 QList<std::shared_ptr<Variable> > variables() const;
48
42 void setYRange(const SqpRange &range);
49 void setYRange(const SqpRange &range);
43 SqpRange graphRange() const noexcept;
50 SqpRange graphRange() const noexcept;
44 void setGraphRange(const SqpRange &range);
51 void setGraphRange(const SqpRange &range);
@@ -49,6 +56,9 public:
49 bool contains(const Variable &variable) const override;
56 bool contains(const Variable &variable) const override;
50 QString name() const override;
57 QString name() const override;
51
58
59 // VisualisationDragWidget
60 QMimeData *mimeData() const override;
61 bool isDragAllowed() const override;
52
62
53 signals:
63 signals:
54 void synchronize(const SqpRange &range, const SqpRange &oldRange);
64 void synchronize(const SqpRange &range, const SqpRange &oldRange);
Show file before | Show file after | Hide comments
@@ -6,6 +6,7
6 #include <Common/spimpl.h>
6 #include <Common/spimpl.h>
7
7
8 #include <QLoggingCategory>
8 #include <QLoggingCategory>
9 #include <QMimeData>
9 #include <QWidget>
10 #include <QWidget>
10
11
11 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
12 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
@@ -27,14 +28,33 public:
27 /// Add a zone widget
28 /// Add a zone widget
28 void addZone(VisualizationZoneWidget *zoneWidget);
29 void addZone(VisualizationZoneWidget *zoneWidget);
29
30
31 void insertZone(int index, VisualizationZoneWidget *zoneWidget);
32
30 /**
33 /**
31 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
34 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
32 * zone.
35 * zone. The zone is added at the end.
33 * @param variable the variable for which to create the zone
36 * @param variable the variable for which to create the zone
34 * @return the pointer to the created zone
37 * @return the pointer to the created zone
35 */
38 */
36 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
39 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
37
40
41 /**
42 * Creates a zone using a list of variables. The variables will be displayed in a new graph of
43 * the new zone. The zone is inserted at the specified index.
44 * @param variables the variables for which to create the zone
45 * @param index The index where the zone should be inserted in the layout
46 * @return the pointer to the created zone
47 */
48 VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
49 int index);
50
51 /**
52 * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
53 * @param index The index where the zone should be inserted in the layout
54 * @return the pointer to the created zone
55 */
56 VisualizationZoneWidget *createEmptyZone(int index);
57
38 // IVisualizationWidget interface
58 // IVisualizationWidget interface
39 void accept(IVisualizationWidgetVisitor *visitor) override;
59 void accept(IVisualizationWidgetVisitor *visitor) override;
40 bool canDrop(const Variable &variable) const override;
60 bool canDrop(const Variable &variable) const override;
@@ -52,6 +72,9 private:
52
72
53 class VisualizationTabWidgetPrivate;
73 class VisualizationTabWidgetPrivate;
54 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
74 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
75
76 private slots:
77 void dropMimeData(int index, const QMimeData *mimeData);
55 };
78 };
56
79
57 #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H
80 #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H
Show file before | Show file after | Hide comments
@@ -2,6 +2,7
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5 #include "Visualization/VisualizationDragWidget.h"
5
6
6 #include <QLoggingCategory>
7 #include <QLoggingCategory>
7 #include <QWidget>
8 #include <QWidget>
@@ -14,34 +15,61 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
14
15
15 namespace Ui {
16 namespace Ui {
16 class VisualizationZoneWidget;
17 class VisualizationZoneWidget;
17 } // Ui
18 } // namespace Ui
18
19
19 class Variable;
20 class Variable;
20 class VisualizationGraphWidget;
21 class VisualizationGraphWidget;
21
22
22 class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
23 class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
23 Q_OBJECT
24 Q_OBJECT
24
25
25 public:
26 public:
26 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
27 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
27 virtual ~VisualizationZoneWidget();
28 virtual ~VisualizationZoneWidget();
28
29
29 /// Add a graph widget
30 /// Adds a graph widget
30 void addGraph(VisualizationGraphWidget *graphWidget);
31 void addGraph(VisualizationGraphWidget *graphWidget);
31
32
33 /// Inserts a graph widget
34 void insertGraph(int index, VisualizationGraphWidget *graphWidget);
35
32 /**
36 /**
33 * Creates a graph using a variable. The variable will be displayed in the new graph.
37 * Creates a graph using a variable. The variable will be displayed in the new graph.
38 * The graph is added at the end.
34 * @param variable the variable for which to create the graph
39 * @param variable the variable for which to create the graph
35 * @return the pointer to the created graph
40 * @return the pointer to the created graph
36 */
41 */
37 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
42 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
38
43
44 /**
45 * Creates a graph using a variable. The variable will be displayed in the new graph.
46 * The graph is inserted at the specified index.
47 * @param variable the variable for which to create the graph
48 * @param index The index where the graph should be inserted in the layout
49 * @return the pointer to the created graph
50 */
51 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
52
53 /**
54 * Creates a graph using a list of variables. The variables will be displayed in the new graph.
55 * The graph is inserted at the specified index.
56 * @param variables List of variables to be added to the graph
57 * @param index The index where the graph should be inserted in the layout
58 * @return the pointer to the created graph
59 */
60 VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
61 int index);
62
39 // IVisualizationWidget interface
63 // IVisualizationWidget interface
40 void accept(IVisualizationWidgetVisitor *visitor) override;
64 void accept(IVisualizationWidgetVisitor *visitor) override;
41 bool canDrop(const Variable &variable) const override;
65 bool canDrop(const Variable &variable) const override;
42 bool contains(const Variable &variable) const override;
66 bool contains(const Variable &variable) const override;
43 QString name() const override;
67 QString name() const override;
44
68
69 // VisualisationDragWidget
70 QMimeData *mimeData() const override;
71 bool isDragAllowed() const override;
72
45 protected:
73 protected:
46 void closeEvent(QCloseEvent *event) override;
74 void closeEvent(QCloseEvent *event) override;
47
75
@@ -55,6 +83,8 private slots:
55 void onVariableAdded(std::shared_ptr<Variable> variable);
83 void onVariableAdded(std::shared_ptr<Variable> variable);
56 /// Slot called when a variable is about to be removed from a graph contained in the zone
84 /// Slot called when a variable is about to be removed from a graph contained in the zone
57 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
85 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
86
87 void dropMimeData(int index, const QMimeData *mimeData);
58 };
88 };
59
89
60 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
90 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
Show file before | Show file after | Hide comments
@@ -2,6 +2,7
2
2
3 #include <Data/IDataProvider.h>
3 #include <Data/IDataProvider.h>
4 #include <DataSource/DataSourceController.h>
4 #include <DataSource/DataSourceController.h>
5 #include <DragDropHelper.h>
5 #include <Network/NetworkController.h>
6 #include <Network/NetworkController.h>
6 #include <QThread>
7 #include <QThread>
7 #include <Time/TimeController.h>
8 #include <Time/TimeController.h>
@@ -18,7 +19,8 public:
18 m_NetworkController{std::make_unique<NetworkController>()},
19 m_NetworkController{std::make_unique<NetworkController>()},
19 m_TimeController{std::make_unique<TimeController>()},
20 m_TimeController{std::make_unique<TimeController>()},
20 m_VariableController{std::make_unique<VariableController>()},
21 m_VariableController{std::make_unique<VariableController>()},
21 m_VisualizationController{std::make_unique<VisualizationController>()}
22 m_VisualizationController{std::make_unique<VisualizationController>()},
23 m_DragDropHelper{std::make_unique<DragDropHelper>()}
22 {
24 {
23 // /////////////////////////////// //
25 // /////////////////////////////// //
24 // Connections between controllers //
26 // Connections between controllers //
@@ -82,6 +84,8 public:
82 QThread m_NetworkControllerThread;
84 QThread m_NetworkControllerThread;
83 QThread m_VariableControllerThread;
85 QThread m_VariableControllerThread;
84 QThread m_VisualizationControllerThread;
86 QThread m_VisualizationControllerThread;
87
88 std::unique_ptr<DragDropHelper> m_DragDropHelper;
85 };
89 };
86
90
87
91
@@ -148,3 +152,8 VisualizationController &SqpApplication::visualizationController() noexcept
148 {
152 {
149 return *impl->m_VisualizationController;
153 return *impl->m_VisualizationController;
150 }
154 }
155
156 DragDropHelper &SqpApplication::dragDropHelper() noexcept
157 {
158 return *impl->m_DragDropHelper;
159 }
Show file before | Show file after | Hide comments
@@ -3,10 +3,12
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 "ui_VisualizationGraphWidget.h"
7 #include "ui_VisualizationGraphWidget.h"
7
8
8 #include <Data/ArrayData.h>
9 #include <Data/ArrayData.h>
9 #include <Data/IDataSeries.h>
10 #include <Data/IDataSeries.h>
11 #include <DragDropHelper.h>
10 #include <Settings/SqpSettingsDefs.h>
12 #include <Settings/SqpSettingsDefs.h>
11 #include <SqpApplication.h>
13 #include <SqpApplication.h>
12 #include <Variable/Variable.h>
14 #include <Variable/Variable.h>
@@ -47,7 +49,7 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
47 };
49 };
48
50
49 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
51 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
50 : QWidget{parent},
52 : VisualizationDragWidget{parent},
51 ui{new Ui::VisualizationGraphWidget},
53 ui{new Ui::VisualizationGraphWidget},
52 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
54 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
53 {
55 {
@@ -92,6 +94,16 VisualizationGraphWidget::~VisualizationGraphWidget()
92 delete ui;
94 delete ui;
93 }
95 }
94
96
97 VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
98 {
99 auto parent = parentWidget();
100 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
101 parent = parent->parentWidget();
102 }
103
104 return qobject_cast<VisualizationZoneWidget *>(parent);
105 }
106
95 void VisualizationGraphWidget::enableAcquisition(bool enable)
107 void VisualizationGraphWidget::enableAcquisition(bool enable)
96 {
108 {
97 impl->m_DoAcquisition = enable;
109 impl->m_DoAcquisition = enable;
@@ -152,6 +164,17 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable
152 ui->widget->replot();
164 ui->widget->replot();
153 }
165 }
154
166
167 QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
168 {
169 auto variables = QList<std::shared_ptr<Variable> >{};
170 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
171 it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
172 variables << it->first;
173 }
174
175 return variables;
176 }
177
155 void VisualizationGraphWidget::setYRange(const SqpRange &range)
178 void VisualizationGraphWidget::setYRange(const SqpRange &range)
156 {
179 {
157 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
180 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
@@ -206,6 +229,19 QString VisualizationGraphWidget::name() const
206 return impl->m_Name;
229 return impl->m_Name;
207 }
230 }
208
231
232 QMimeData *VisualizationGraphWidget::mimeData() const
233 {
234 auto mimeData = new QMimeData;
235 mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
236
237 return mimeData;
238 }
239
240 bool VisualizationGraphWidget::isDragAllowed() const
241 {
242 return true;
243 }
244
209 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
245 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
210 {
246 {
211 Q_UNUSED(event);
247 Q_UNUSED(event);
@@ -284,6 +320,8 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
284 {
320 {
285 // Handles plot rendering when mouse is moving
321 // Handles plot rendering when mouse is moving
286 impl->m_RenderingDelegate->onMouseMove(event);
322 impl->m_RenderingDelegate->onMouseMove(event);
323
324 VisualizationDragWidget::mouseMoveEvent(event);
287 }
325 }
288
326
289 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
327 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
@@ -307,6 +345,10 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
307 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
345 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
308 {
346 {
309 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
347 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
348
349 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
350
351 VisualizationDragWidget::mousePressEvent(event);
310 }
352 }
311
353
312 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
354 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
Show file before | Show file after | Hide comments
@@ -2,8 +2,14
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "ui_VisualizationTabWidget.h"
3 #include "ui_VisualizationTabWidget.h"
4
4
5 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationZoneWidget.h"
6 #include "Visualization/VisualizationZoneWidget.h"
6
7
8 #include "Variable/VariableController.h"
9
10 #include "DragDropHelper.h"
11 #include "SqpApplication.h"
12
7 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
13 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
8
14
9 namespace {
15 namespace {
@@ -55,27 +61,53 VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
55 {
61 {
56 ui->setupUi(this);
62 ui->setupUi(this);
57
63
64 ui->dragDropContainer->setAcceptedMimeTypes(
65 {DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
66 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
67 &VisualizationTabWidget::dropMimeData);
68 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
69
58 // Widget is deleted when closed
70 // Widget is deleted when closed
59 setAttribute(Qt::WA_DeleteOnClose);
71 setAttribute(Qt::WA_DeleteOnClose);
60 }
72 }
61
73
62 VisualizationTabWidget::~VisualizationTabWidget()
74 VisualizationTabWidget::~VisualizationTabWidget()
63 {
75 {
76 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
64 delete ui;
77 delete ui;
65 }
78 }
66
79
67 void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
80 void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
68 {
81 {
69 tabLayout().addWidget(zoneWidget);
82 ui->dragDropContainer->addDragWidget(zoneWidget);
83 }
84
85 void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
86 {
87 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
70 }
88 }
71
89
72 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
90 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
73 {
91 {
74 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};
92 return createZone({variable}, -1);
75 this->addZone(zoneWidget);
93 }
94
95 VisualizationZoneWidget *
96 VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
97 {
98 auto zoneWidget = createEmptyZone(index);
76
99
77 // Creates a new graph into the zone
100 // Creates a new graph into the zone
78 zoneWidget->createGraph(variable);
101 zoneWidget->createGraph(variables, index);
102
103 return zoneWidget;
104 }
105
106 VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
107 {
108 auto zoneWidget
109 = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
110 this->insertZone(index, zoneWidget);
79
111
80 return zoneWidget;
112 return zoneWidget;
81 }
113 }
@@ -125,5 +157,63 void VisualizationTabWidget::closeEvent(QCloseEvent *event)
125
157
126 QLayout &VisualizationTabWidget::tabLayout() const noexcept
158 QLayout &VisualizationTabWidget::tabLayout() const noexcept
127 {
159 {
128 return *ui->scrollAreaWidgetContents->layout();
160 return *ui->dragDropContainer->layout();
161 }
162
163 void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
164 {
165 auto &helper = sqpApp->dragDropHelper();
166 if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
167 auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
168 auto parentDragDropContainer
169 = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
170 Q_ASSERT(parentDragDropContainer);
171
172 auto nbGraph = parentDragDropContainer->countDragWidget();
173
174 const auto &variables = graphWidget->variables();
175
176 if (!variables.isEmpty()) {
177 // Abort the requests for the variables (if any)
178 // Commented, because it's not sure if it's needed or not
179 // for (const auto& var : variables)
180 //{
181 // sqpApp->variableController().onAbortProgressRequested(var);
182 //}
183
184 if (nbGraph == 1) {
185 // This is the only graph in the previous zone, close the zone
186 graphWidget->parentZoneWidget()->close();
187 }
188 else {
189 // Close the graph
190 graphWidget->close();
191 }
192
193 createZone(variables, index);
194 }
195 else {
196 // The graph is empty, create an empty zone and move the graph inside
197
198 auto parentZoneWidget = graphWidget->parentZoneWidget();
199
200 parentDragDropContainer->layout()->removeWidget(graphWidget);
201
202 auto zoneWidget = createEmptyZone(index);
203 zoneWidget->addGraph(graphWidget);
204
205 // Close the old zone if it was the only graph inside
206 if (nbGraph == 1) {
207 parentZoneWidget->close();
208 }
209 }
210 }
211 else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE)) {
212 // Simple move of the zone, no variable operation associated
213 auto zoneWidget = static_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
214 auto parentDragDropContainer = zoneWidget->parentWidget();
215 parentDragDropContainer->layout()->removeWidget(zoneWidget);
216
217 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
218 }
129 }
219 }
Show file before | Show file after | Hide comments
@@ -9,10 +9,13
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 <QUuid>
13 #include <QUuid>
13 #include <SqpApplication.h>
14 #include <SqpApplication.h>
14 #include <cmath>
15 #include <cmath>
15
16
17 #include <QLayout>
18
16 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
19 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
17
20
18 namespace {
21 namespace {
@@ -66,7 +69,7 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
66 };
69 };
67
70
68 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
71 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
69 : QWidget{parent},
72 : VisualizationDragWidget{parent},
70 ui{new Ui::VisualizationZoneWidget},
73 ui{new Ui::VisualizationZoneWidget},
71 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
74 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
72 {
75 {
@@ -74,6 +77,10 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
74
77
75 ui->zoneNameLabel->setText(name);
78 ui->zoneNameLabel->setText(name);
76
79
80 ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
81 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
82 &VisualizationZoneWidget::dropMimeData);
83
77 // 'Close' options : widget is deleted when closed
84 // 'Close' options : widget is deleted when closed
78 setAttribute(Qt::WA_DeleteOnClose);
85 setAttribute(Qt::WA_DeleteOnClose);
79 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
86 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
@@ -94,13 +101,27 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
94 // Synchronize new graph with others in the zone
101 // Synchronize new graph with others in the zone
95 impl->m_Synchronizer->addGraph(*graphWidget);
102 impl->m_Synchronizer->addGraph(*graphWidget);
96
103
97 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
104 ui->dragDropContainer->addDragWidget(graphWidget);
105 }
106
107 void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
108 {
109 // Synchronize new graph with others in the zone
110 impl->m_Synchronizer->addGraph(*graphWidget);
111
112 ui->dragDropContainer->insertDragWidget(index, graphWidget);
98 }
113 }
99
114
100 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
115 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
101 {
116 {
102 auto graphWidget = new VisualizationGraphWidget{
117 return createGraph(variable, -1);
103 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
118 }
119
120 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
121 int index)
122 {
123 auto graphWidget
124 = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
104
125
105
126
106 // Set graph properties
127 // Set graph properties
@@ -113,7 +134,7 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
113 const SqpRange &oldGraphRange) {
134 const SqpRange &oldGraphRange) {
114
135
115 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
136 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
116 auto frameLayout = ui->visualizationZoneFrame->layout();
137 auto frameLayout = ui->dragDropContainer->layout();
117 for (auto i = 0; i < frameLayout->count(); ++i) {
138 for (auto i = 0; i < frameLayout->count(); ++i) {
118 auto graphChild
139 auto graphChild
119 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
140 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
@@ -203,7 +224,7 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
203 auto range = SqpRange{};
224 auto range = SqpRange{};
204
225
205 // Apply visitor to graph children
226 // Apply visitor to graph children
206 auto layout = ui->visualizationZoneFrame->layout();
227 auto layout = ui->dragDropContainer->layout();
207 if (layout->count() > 0) {
228 if (layout->count() > 0) {
208 // Case of a new graph in a existant zone
229 // Case of a new graph in a existant zone
209 if (auto visualizationGraphWidget
230 if (auto visualizationGraphWidget
@@ -216,7 +237,7 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
216 range = variable->range();
237 range = variable->range();
217 }
238 }
218
239
219 this->addGraph(graphWidget);
240 this->insertGraph(index, graphWidget);
220
241
221 graphWidget->addVariable(variable, range);
242 graphWidget->addVariable(variable, range);
222
243
@@ -240,6 +261,21 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
240 return graphWidget;
261 return graphWidget;
241 }
262 }
242
263
264 VisualizationGraphWidget *
265 VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
266 {
267 if (variables.isEmpty()) {
268 return nullptr;
269 }
270
271 auto graphWidget = createGraph(variables.first(), index);
272 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
273 graphWidget->addVariable(*variableIt, graphWidget->graphRange());
274 }
275
276 return graphWidget;
277 }
278
243 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
279 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
244 {
280 {
245 if (visitor) {
281 if (visitor) {
@@ -248,7 +284,7 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
248 // 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
249 // action)
285 // action)
250 processGraphs(
286 processGraphs(
251 *ui->visualizationZoneFrame->layout(),
287 *ui->dragDropContainer->layout(),
252 [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
288 [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
253
289
254 visitor->visitLeave(this);
290 visitor->visitLeave(this);
@@ -276,10 +312,23 QString VisualizationZoneWidget::name() const
276 return ui->zoneNameLabel->text();
312 return ui->zoneNameLabel->text();
277 }
313 }
278
314
315 QMimeData *VisualizationZoneWidget::mimeData() const
316 {
317 auto mimeData = new QMimeData;
318 mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
319
320 return mimeData;
321 }
322
323 bool VisualizationZoneWidget::isDragAllowed() const
324 {
325 return true;
326 }
327
279 void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
328 void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
280 {
329 {
281 // Closes graphs in the zone
330 // Closes graphs in the zone
282 processGraphs(*ui->visualizationZoneFrame->layout(),
331 processGraphs(*ui->dragDropContainer->layout(),
283 [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
332 [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
284
333
285 // Delete synchronization group from variable controller
334 // Delete synchronization group from variable controller
@@ -302,3 +351,60 void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variabl
302 Q_ARG(std::shared_ptr<Variable>, variable),
351 Q_ARG(std::shared_ptr<Variable>, variable),
303 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
352 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
304 }
353 }
354
355 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
356 {
357 auto &helper = sqpApp->dragDropHelper();
358 if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
359 auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
360 auto parentDragDropContainer
361 = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
362 Q_ASSERT(parentDragDropContainer);
363
364 const auto &variables = graphWidget->variables();
365
366 if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
367 // The drop didn't occur in the same zone
368
369 // Abort the requests for the variables (if any)
370 // Commented, because it's not sure if it's needed or not
371 // for (const auto& var : variables)
372 //{
373 // sqpApp->variableController().onAbortProgressRequested(var);
374 //}
375
376 auto previousParentZoneWidget = graphWidget->parentZoneWidget();
377 auto nbGraph = parentDragDropContainer->countDragWidget();
378 if (nbGraph == 1) {
379 // This is the only graph in the previous zone, close the zone
380 previousParentZoneWidget->close();
381 }
382 else {
383 // Close the graph
384 graphWidget->close();
385 }
386
387 // Creates the new graph in the zone
388 createGraph(variables, index);
389 }
390 else {
391 // The drop occurred in the same zone or the graph is empty
392 // Simple move of the graph, no variable operation associated
393 parentDragDropContainer->layout()->removeWidget(graphWidget);
394
395 if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
396 // The graph is empty and dropped in a different zone.
397 // Take the range of the first graph in the zone (if existing).
398 auto layout = ui->dragDropContainer->layout();
399 if (layout->count() > 0) {
400 if (auto visualizationGraphWidget
401 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
402 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
403 }
404 }
405 }
406
407 ui->dragDropContainer->insertDragWidget(index, graphWidget);
408 }
409 }
410 }
Show file before | Show file after | Hide comments
@@ -62,12 +62,23
62 <property name="bottomMargin">
62 <property name="bottomMargin">
63 <number>0</number>
63 <number>0</number>
64 </property>
64 </property>
65 <item>
66 <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
67 </item>
65 </layout>
68 </layout>
66 </widget>
69 </widget>
67 </widget>
70 </widget>
68 </item>
71 </item>
69 </layout>
72 </layout>
70 </widget>
73 </widget>
74 <customwidgets>
75 <customwidget>
76 <class>VisualizationDragDropContainer</class>
77 <extends>QWidget</extends>
78 <header>Visualization/VisualizationDragDropContainer.h</header>
79 <container>1</container>
80 </customwidget>
81 </customwidgets>
71 <resources/>
82 <resources/>
72 <connections/>
83 <connections/>
73 </ui>
84 </ui>
Show file before | Show file after | Hide comments
@@ -107,11 +107,22
107 <property name="bottomMargin">
107 <property name="bottomMargin">
108 <number>0</number>
108 <number>0</number>
109 </property>
109 </property>
110 <item>
111 <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
112 </item>
110 </layout>
113 </layout>
111 </widget>
114 </widget>
112 </item>
115 </item>
113 </layout>
116 </layout>
114 </widget>
117 </widget>
118 <customwidgets>
119 <customwidget>
120 <class>VisualizationDragDropContainer</class>
121 <extends>QWidget</extends>
122 <header>Visualization/VisualizationDragDropContainer.h</header>
123 <container>1</container>
124 </customwidget>
125 </customwidgets>
115 <resources/>
126 <resources/>
116 <connections/>
127 <connections/>
117 </ui>
128 </ui>
General Comments 0
You need to be logged in to leave comments. Login now