##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Removes a wrong assert
trabillard -
r907:698c3bb60bb5
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,453 +1,452
1 #include "Visualization/VisualizationDragDropContainer.h"
1 #include "Visualization/VisualizationDragDropContainer.h"
2 #include "DragAndDrop/DragDropHelper.h"
2 #include "DragAndDrop/DragDropHelper.h"
3 #include "SqpApplication.h"
3 #include "SqpApplication.h"
4 #include "Visualization/VisualizationDragWidget.h"
4 #include "Visualization/VisualizationDragWidget.h"
5
5
6 #include "Common/VisualizationDef.h"
6 #include "Common/VisualizationDef.h"
7
7
8 #include <QDrag>
8 #include <QDrag>
9 #include <QDragEnterEvent>
9 #include <QDragEnterEvent>
10 #include <QVBoxLayout>
10 #include <QVBoxLayout>
11
11
12 #include <cmath>
12 #include <cmath>
13 #include <memory>
13 #include <memory>
14
14
15 Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
15 Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
16
16
17 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
17 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
18
18
19 QVBoxLayout *m_Layout;
19 QVBoxLayout *m_Layout;
20 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
20 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
21 QString m_PlaceHolderText;
21 QString m_PlaceHolderText;
22 DragDropHelper::PlaceHolderType m_PlaceHolderType = DragDropHelper::PlaceHolderType::Graph;
22 DragDropHelper::PlaceHolderType m_PlaceHolderType = DragDropHelper::PlaceHolderType::Graph;
23
23
24 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
24 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
25 = [](auto mimeData) { return true; };
25 = [](auto mimeData) { return true; };
26
26
27 int m_MinContainerHeight = 0;
27 int m_MinContainerHeight = 0;
28
28
29 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
29 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
30 {
30 {
31 m_Layout = new QVBoxLayout(widget);
31 m_Layout = new QVBoxLayout(widget);
32 m_Layout->setContentsMargins(0, 0, 0, 0);
32 m_Layout->setContentsMargins(0, 0, 0, 0);
33 }
33 }
34
34
35 bool acceptMimeData(const QMimeData *data) const
35 bool acceptMimeData(const QMimeData *data) const
36 {
36 {
37 for (const auto &type : m_AcceptedMimeTypes.keys()) {
37 for (const auto &type : m_AcceptedMimeTypes.keys()) {
38 if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
38 if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
39 return true;
39 return true;
40 }
40 }
41 }
41 }
42
42
43 return false;
43 return false;
44 }
44 }
45
45
46 bool allowMergeForMimeData(const QMimeData *data) const
46 bool allowMergeForMimeData(const QMimeData *data) const
47 {
47 {
48 bool result = false;
48 bool result = false;
49 for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
49 for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
50 ++it) {
50 ++it) {
51
51
52 if (data->hasFormat(it.key())
52 if (data->hasFormat(it.key())
53 && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
53 && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
54 || it.value()
54 || it.value()
55 == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
55 == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
56 result = true;
56 result = true;
57 }
57 }
58 else if (data->hasFormat(it.key())
58 else if (data->hasFormat(it.key())
59 && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
59 && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
60 // Merge is forbidden if the mime data contain an acceptable type which cannot be
60 // Merge is forbidden if the mime data contain an acceptable type which cannot be
61 // merged
61 // merged
62 result = false;
62 result = false;
63 break;
63 break;
64 }
64 }
65 }
65 }
66
66
67 return result;
67 return result;
68 }
68 }
69
69
70 bool allowInsertForMimeData(const QMimeData *data) const
70 bool allowInsertForMimeData(const QMimeData *data) const
71 {
71 {
72 for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
72 for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
73 ++it) {
73 ++it) {
74 if (data->hasFormat(it.key())
74 if (data->hasFormat(it.key())
75 && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
75 && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
76 || it.value()
76 || it.value()
77 == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
77 == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
78 return true;
78 return true;
79 }
79 }
80 }
80 }
81
81
82 return false;
82 return false;
83 }
83 }
84
84
85 bool hasPlaceHolder() const
85 bool hasPlaceHolder() const
86 {
86 {
87 return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
87 return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
88 }
88 }
89
89
90 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
90 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
91 {
91 {
92 VisualizationDragWidget *dragWidget = nullptr;
92 VisualizationDragWidget *dragWidget = nullptr;
93
93
94 for (auto child : parent->children()) {
94 for (auto child : parent->children()) {
95 auto widget = qobject_cast<VisualizationDragWidget *>(child);
95 auto widget = qobject_cast<VisualizationDragWidget *>(child);
96 if (widget && widget->isVisible()) {
96 if (widget && widget->isVisible()) {
97 if (widget->frameGeometry().contains(pos)) {
97 if (widget->frameGeometry().contains(pos)) {
98 dragWidget = widget;
98 dragWidget = widget;
99 break;
99 break;
100 }
100 }
101 }
101 }
102 }
102 }
103
103
104 return dragWidget;
104 return dragWidget;
105 }
105 }
106
106
107 bool cursorIsInContainer(QWidget *container) const
107 bool cursorIsInContainer(QWidget *container) const
108 {
108 {
109 return container->isAncestorOf(sqpApp->widgetAt(QCursor::pos()));
109 return container->isAncestorOf(sqpApp->widgetAt(QCursor::pos()));
110 }
110 }
111
111
112 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
112 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
113 {
113 {
114 auto nbGraph = 0;
114 auto nbGraph = 0;
115 for (auto child : parent->children()) {
115 for (auto child : parent->children()) {
116 if (qobject_cast<VisualizationDragWidget *>(child)) {
116 if (qobject_cast<VisualizationDragWidget *>(child)) {
117 if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
117 if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
118 nbGraph += 1;
118 nbGraph += 1;
119 }
119 }
120 }
120 }
121 }
121 }
122
122
123 return nbGraph;
123 return nbGraph;
124 }
124 }
125
125
126 void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
126 void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
127 const VisualizationDragDropContainer *container);
127 const VisualizationDragDropContainer *container);
128 };
128 };
129
129
130 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
130 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
131 : QFrame{parent},
131 : QFrame{parent},
132 impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
132 impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
133 {
133 {
134 setAcceptDrops(true);
134 setAcceptDrops(true);
135 }
135 }
136
136
137 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
137 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
138 {
138 {
139 impl->m_Layout->addWidget(dragWidget);
139 impl->m_Layout->addWidget(dragWidget);
140 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
140 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
141 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
141 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
142 &VisualizationDragDropContainer::startDrag);
142 &VisualizationDragDropContainer::startDrag);
143 }
143 }
144
144
145 void VisualizationDragDropContainer::insertDragWidget(int index,
145 void VisualizationDragDropContainer::insertDragWidget(int index,
146 VisualizationDragWidget *dragWidget)
146 VisualizationDragWidget *dragWidget)
147 {
147 {
148 impl->m_Layout->insertWidget(index, dragWidget);
148 impl->m_Layout->insertWidget(index, dragWidget);
149 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
149 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
150 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
150 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
151 &VisualizationDragDropContainer::startDrag);
151 &VisualizationDragDropContainer::startDrag);
152 }
152 }
153
153
154 void VisualizationDragDropContainer::addAcceptedMimeType(
154 void VisualizationDragDropContainer::addAcceptedMimeType(
155 const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
155 const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
156 {
156 {
157 impl->m_AcceptedMimeTypes[mimeType] = behavior;
157 impl->m_AcceptedMimeTypes[mimeType] = behavior;
158 }
158 }
159
159
160 int VisualizationDragDropContainer::countDragWidget() const
160 int VisualizationDragDropContainer::countDragWidget() const
161 {
161 {
162 return impl->countDragWidget(this);
162 return impl->countDragWidget(this);
163 }
163 }
164
164
165 void VisualizationDragDropContainer::setAcceptMimeDataFunction(
165 void VisualizationDragDropContainer::setAcceptMimeDataFunction(
166 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
166 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
167 {
167 {
168 impl->m_AcceptMimeDataFun = fun;
168 impl->m_AcceptMimeDataFun = fun;
169 }
169 }
170
170
171 void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
171 void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
172 const QString &placeHolderText)
172 const QString &placeHolderText)
173 {
173 {
174 impl->m_PlaceHolderType = type;
174 impl->m_PlaceHolderType = type;
175 impl->m_PlaceHolderText = placeHolderText;
175 impl->m_PlaceHolderText = placeHolderText;
176 }
176 }
177
177
178 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
178 void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
179 const QPoint &dragPosition)
179 const QPoint &dragPosition)
180 {
180 {
181 auto &helper = sqpApp->dragDropHelper();
181 auto &helper = sqpApp->dragDropHelper();
182 helper.resetDragAndDrop();
182 helper.resetDragAndDrop();
183
183
184 // Note: The management of the drag object is done by Qt
184 // Note: The management of the drag object is done by Qt
185 auto drag = new QDrag{dragWidget};
185 auto drag = new QDrag{dragWidget};
186 drag->setHotSpot(dragPosition);
186 drag->setHotSpot(dragPosition);
187
187
188 auto mimeData = dragWidget->mimeData();
188 auto mimeData = dragWidget->mimeData();
189 drag->setMimeData(mimeData);
189 drag->setMimeData(mimeData);
190
190
191 auto pixmap = QPixmap(dragWidget->size());
191 auto pixmap = QPixmap(dragWidget->size());
192 dragWidget->render(&pixmap);
192 dragWidget->render(&pixmap);
193 drag->setPixmap(pixmap);
193 drag->setPixmap(pixmap);
194
194
195 auto image = pixmap.toImage();
195 auto image = pixmap.toImage();
196 mimeData->setImageData(image);
196 mimeData->setImageData(image);
197 mimeData->setUrls({helper.imageTemporaryUrl(image)});
197 mimeData->setUrls({helper.imageTemporaryUrl(image)});
198
198
199 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
199 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
200 helper.setCurrentDragWidget(dragWidget);
200 helper.setCurrentDragWidget(dragWidget);
201
201
202 if (impl->cursorIsInContainer(this)) {
202 if (impl->cursorIsInContainer(this)) {
203 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
203 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
204 helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
204 helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
205 impl->m_PlaceHolderText);
205 impl->m_PlaceHolderText);
206 dragWidget->setVisible(false);
206 dragWidget->setVisible(false);
207 }
207 }
208 else {
208 else {
209 // The drag starts directly outside the drop zone
209 // The drag starts directly outside the drop zone
210 // do not add the placeHolder
210 // do not add the placeHolder
211 }
211 }
212
212
213 // Note: The exec() is blocking on windows but not on linux and macOS
213 // Note: The exec() is blocking on windows but not on linux and macOS
214 drag->exec(Qt::MoveAction | Qt::CopyAction);
214 drag->exec(Qt::MoveAction | Qt::CopyAction);
215 }
215 }
216 else {
216 else {
217 qCWarning(LOG_VisualizationDragDropContainer())
217 qCWarning(LOG_VisualizationDragDropContainer())
218 << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
218 << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
219 "VisualizationDragWidget is not found in this container.");
219 "VisualizationDragWidget is not found in this container.");
220 }
220 }
221 }
221 }
222
222
223 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
223 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
224 {
224 {
225 if (impl->acceptMimeData(event->mimeData())) {
225 if (impl->acceptMimeData(event->mimeData())) {
226 event->acceptProposedAction();
226 event->acceptProposedAction();
227
227
228 auto &helper = sqpApp->dragDropHelper();
228 auto &helper = sqpApp->dragDropHelper();
229
229
230 if (!impl->hasPlaceHolder()) {
230 if (!impl->hasPlaceHolder()) {
231 auto dragWidget = helper.getCurrentDragWidget();
231 auto dragWidget = helper.getCurrentDragWidget();
232
232
233 if (dragWidget) {
233 if (dragWidget) {
234 // If the drag&drop is internal to the visualization, entering the container hide
234 // If the drag&drop is internal to the visualization, entering the container hide
235 // the dragWidget which was made visible by the dragLeaveEvent
235 // the dragWidget which was made visible by the dragLeaveEvent
236 auto parentWidget
236 auto parentWidget
237 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
237 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
238 if (parentWidget) {
238 if (parentWidget) {
239 dragWidget->setVisible(false);
239 dragWidget->setVisible(false);
240 }
240 }
241 }
241 }
242
242
243 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
243 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
244 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
244 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
245 impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
245 impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
246 }
246 }
247 else {
247 else {
248 // do nothing
248 // do nothing
249 }
249 }
250 }
250 }
251 else {
251 else {
252 event->ignore();
252 event->ignore();
253 }
253 }
254
254
255 QWidget::dragEnterEvent(event);
255 QWidget::dragEnterEvent(event);
256 }
256 }
257
257
258 void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
258 void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
259 {
259 {
260 Q_UNUSED(event);
260 Q_UNUSED(event);
261
261
262 auto &helper = sqpApp->dragDropHelper();
262 auto &helper = sqpApp->dragDropHelper();
263
263
264 if (!impl->cursorIsInContainer(this)) {
264 if (!impl->cursorIsInContainer(this)) {
265 helper.removePlaceHolder();
265 helper.removePlaceHolder();
266 helper.setHightlightedDragWidget(nullptr);
266 helper.setHightlightedDragWidget(nullptr);
267 impl->m_MinContainerHeight = 0;
267 impl->m_MinContainerHeight = 0;
268
268
269 auto dragWidget = helper.getCurrentDragWidget();
269 auto dragWidget = helper.getCurrentDragWidget();
270 if (dragWidget) {
270 if (dragWidget) {
271 // dragWidget has a value only if the drag is started from the visualization
271 // dragWidget has a value only if the drag is started from the visualization
272 // In that case, shows the drag widget at its original place
272 // In that case, shows the drag widget at its original place
273 // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
273 // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
274 // drop zone (It is not possible to catch a drop event outside of the application)
274 // drop zone (It is not possible to catch a drop event outside of the application)
275
275
276 if (dragWidget) {
276 if (dragWidget) {
277 dragWidget->setVisible(true);
277 dragWidget->setVisible(true);
278 }
278 }
279 }
279 }
280 }
280 }
281 else {
281 else {
282 // Leave event probably received for a child widget.
282 // Leave event probably received for a child widget.
283 // Do nothing.
283 // Do nothing.
284 // Note: The DragLeave event, doesn't have any mean to determine who sent it.
284 // Note: The DragLeave event, doesn't have any mean to determine who sent it.
285 }
285 }
286
286
287 QWidget::dragLeaveEvent(event);
287 QWidget::dragLeaveEvent(event);
288 }
288 }
289
289
290 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
290 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
291 {
291 {
292 if (impl->acceptMimeData(event->mimeData())) {
292 if (impl->acceptMimeData(event->mimeData())) {
293 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
293 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
294 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
294 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
295 impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
295 impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
296 }
296 }
297 else {
297 else {
298 event->ignore();
298 event->ignore();
299 }
299 }
300
300
301 QWidget::dragMoveEvent(event);
301 QWidget::dragMoveEvent(event);
302 }
302 }
303
303
304 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
304 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
305 {
305 {
306 auto &helper = sqpApp->dragDropHelper();
306 auto &helper = sqpApp->dragDropHelper();
307
307
308 if (impl->acceptMimeData(event->mimeData())) {
308 if (impl->acceptMimeData(event->mimeData())) {
309 auto dragWidget = helper.getCurrentDragWidget();
309 auto dragWidget = helper.getCurrentDragWidget();
310 if (impl->hasPlaceHolder()) {
310 if (impl->hasPlaceHolder()) {
311 // drop where the placeHolder is located
311 // drop where the placeHolder is located
312
312
313 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
313 auto canInsert = impl->allowInsertForMimeData(event->mimeData());
314 if (canInsert) {
314 if (canInsert) {
315 auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
315 auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
316
316
317 if (dragWidget) {
317 if (dragWidget) {
318 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
318 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
319 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
319 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
320 // Correction of the index if the drop occurs in the same container
320 // Correction of the index if the drop occurs in the same container
321 // and if the drag is started from the visualization (in that case, the
321 // and if the drag is started from the visualization (in that case, the
322 // dragWidget is hidden)
322 // dragWidget is hidden)
323 droppedIndex -= 1;
323 droppedIndex -= 1;
324 }
324 }
325
325
326 dragWidget->setVisible(true);
326 dragWidget->setVisible(true);
327 }
327 }
328
328
329 event->acceptProposedAction();
329 event->acceptProposedAction();
330
330
331 helper.removePlaceHolder();
331 helper.removePlaceHolder();
332
332
333 emit dropOccuredInContainer(droppedIndex, event->mimeData());
333 emit dropOccuredInContainer(droppedIndex, event->mimeData());
334 }
334 }
335 else {
335 else {
336 qCWarning(LOG_VisualizationDragDropContainer()) << tr(
336 qCWarning(LOG_VisualizationDragDropContainer()) << tr(
337 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
337 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
338 "the insertion is forbidden.");
338 "the insertion is forbidden.");
339 Q_ASSERT(false);
339 Q_ASSERT(false);
340 }
340 }
341 }
341 }
342 else if (helper.getHightlightedDragWidget()) {
342 else if (helper.getHightlightedDragWidget()) {
343 // drop on the highlighted widget
343 // drop on the highlighted widget
344
344
345 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
345 auto canMerge = impl->allowMergeForMimeData(event->mimeData());
346 if (canMerge) {
346 if (canMerge) {
347 event->acceptProposedAction();
347 event->acceptProposedAction();
348 emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
348 emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
349 }
349 }
350 else {
350 else {
351 qCWarning(LOG_VisualizationDragDropContainer())
351 qCWarning(LOG_VisualizationDragDropContainer())
352 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
352 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
353 "the merge is forbidden.");
353 "the merge is forbidden.");
354 Q_ASSERT(false);
354 Q_ASSERT(false);
355 }
355 }
356 }
356 }
357 }
357 }
358 else {
358 else {
359 event->ignore();
359 event->ignore();
360 }
360 }
361
361
362 sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
362 sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
363 impl->m_MinContainerHeight = 0;
363 impl->m_MinContainerHeight = 0;
364
364
365 QWidget::dropEvent(event);
365 QWidget::dropEvent(event);
366 }
366 }
367
367
368
368
369 void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
369 void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
370 const QPoint &pos, bool canInsert, bool canMerge,
370 const QPoint &pos, bool canInsert, bool canMerge,
371 const VisualizationDragDropContainer *container)
371 const VisualizationDragDropContainer *container)
372 {
372 {
373 auto &helper = sqpApp->dragDropHelper();
373 auto &helper = sqpApp->dragDropHelper();
374
374
375 auto absPos = container->mapToGlobal(pos);
375 auto absPos = container->mapToGlobal(pos);
376 auto isOnPlaceHolder = sqpApp->widgetAt(absPos) == &(helper.placeHolder());
376 auto isOnPlaceHolder = sqpApp->widgetAt(absPos) == &(helper.placeHolder());
377
377
378 if (countDragWidget(container, true) == 0) {
378 if (countDragWidget(container, true) == 0) {
379 // Drop on an empty container, just add the placeHolder at the top
379 // Drop on an empty container, just add the placeHolder at the top
380 helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
380 helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
381 }
381 }
382 else if (!isOnPlaceHolder) {
382 else if (!isOnPlaceHolder) {
383 auto nbDragWidget = countDragWidget(container);
383 auto nbDragWidget = countDragWidget(container);
384 if (nbDragWidget > 0) {
384 if (nbDragWidget > 0) {
385
385
386 if (m_MinContainerHeight == 0) {
386 if (m_MinContainerHeight == 0) {
387 m_MinContainerHeight = container->size().height();
387 m_MinContainerHeight = container->size().height();
388 }
388 }
389
389
390 m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
390 m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
391 auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
391 auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
392
392
393 auto posY = pos.y();
393 auto posY = pos.y();
394 auto dropIndex = floor(posY / graphHeight);
394 auto dropIndex = floor(posY / graphHeight);
395 auto zoneSize = qMin(graphHeight / 4.0, 75.0);
395 auto zoneSize = qMin(graphHeight / 4.0, 75.0);
396
396
397
397
398 auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
398 auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
399 auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
399 auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
400
400
401 auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
401 auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
402
402
403 auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
403 auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
404
404
405 if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
405 if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
406 if (isOnBottom) {
406 if (isOnBottom) {
407 dropIndex += 1;
407 dropIndex += 1;
408 }
408 }
409
409
410 if (helper.getCurrentDragWidget()) {
410 if (helper.getCurrentDragWidget()) {
411 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
411 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
412 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
412 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
413 // Correction of the index if the drop occurs in the same container
413 // Correction of the index if the drop occurs in the same container
414 // and if the drag is started from the visualization (in that case, the
414 // and if the drag is started from the visualization (in that case, the
415 // dragWidget is hidden)
415 // dragWidget is hidden)
416 dropIndex += 1;
416 dropIndex += 1;
417 }
417 }
418 }
418 }
419
419
420 if (dropIndex != placeHolderIndex) {
420 if (dropIndex != placeHolderIndex) {
421 helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
421 helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
422 m_PlaceHolderText);
422 m_PlaceHolderText);
423 }
423 }
424
424
425 helper.setHightlightedDragWidget(nullptr);
425 helper.setHightlightedDragWidget(nullptr);
426 }
426 }
427 else if (canMerge && dragWidgetHovered) {
427 else if (canMerge && dragWidgetHovered) {
428 // drop on the middle -> merge
428 // drop on the middle -> merge
429 if (hasPlaceHolder()) {
429 if (hasPlaceHolder()) {
430 helper.removePlaceHolder();
430 helper.removePlaceHolder();
431 }
431 }
432
432
433 helper.setHightlightedDragWidget(dragWidgetHovered);
433 helper.setHightlightedDragWidget(dragWidgetHovered);
434 }
434 }
435 else {
435 else {
436 qCWarning(LOG_VisualizationDragDropContainer())
436 qCWarning(LOG_VisualizationDragDropContainer())
437 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
437 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
438 "action.");
438 "action.");
439 Q_ASSERT(false);
440 }
439 }
441 }
440 }
442 else {
441 else {
443 qCWarning(LOG_VisualizationDragDropContainer())
442 qCWarning(LOG_VisualizationDragDropContainer())
444 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
443 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
445 "found in the "
444 "found in the "
446 "container");
445 "container");
447 }
446 }
448 }
447 }
449 else {
448 else {
450 // the mouse is hover the placeHolder
449 // the mouse is hover the placeHolder
451 // Do nothing
450 // Do nothing
452 }
451 }
453 }
452 }
General Comments 0
You need to be logged in to leave comments. Login now