HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r911:9102bdac4611

Fix for D&D bug on mac

Thibaud Rabillard -

r911:9102bdac4611

parent child

Context file:

r911:9102bdac4611

Collapse all files

gui/include/DragAndDrop/DragDropHelper.h +4 0

             #ifndef SCIQLOP_DRAGDROPHELPER_H
             #define SCIQLOP_DRAGDROPHELPER_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class QVBoxLayout;
             class QScrollArea;
             class QTabBar;
             class VisualizationDragWidget;
             class VisualizationDragDropContainer;
             class QMimeData;
             Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
             /**
              * @brief Helper class for drag&drop operations.
              * @note The helper is accessible from the sqpApp singleton and  has the same life as the whole
              * application (like a controller). But contrary to a controller, it doesn't live in a thread and
              * can interect with the gui.
              * @see SqpApplication
              */
             class DragDropHelper {
             public:
                 static const QString MIME_TYPE_GRAPH;
                 static const QString MIME_TYPE_ZONE;
                 enum class PlaceHolderType { Default, Graph, Zone };
                 DragDropHelper();
                 virtual ~DragDropHelper();
                 /// Resets some internal variables. Must be called before any new drag&drop operation.
                 void resetDragAndDrop();
                 /// Sets the visualization widget currently being drag on the visualization.
                 void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
                 /// Returns the visualization widget currently being drag on the visualization.
                 /// Can be null if a new visualization widget is intended to be created by the drag&drop
                 /// operation.
                 VisualizationDragWidget *getCurrentDragWidget() const;
                 QWidget &placeHolder() const;
                 void insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                        const QString &topLabelText);
                 void removePlaceHolder();
                 bool isPlaceHolderSet() const;
                 /// Checks if the specified mime data is valid for a drop in the visualization
                 bool checkMimeDataForVisualization(const QMimeData *mimeData,
                                                    VisualizationDragDropContainer *dropContainer);
                 void addDragDropScrollArea(QScrollArea *scrollArea);
                 void removeDragDropScrollArea(QScrollArea *scrollArea);
                 void addDragDropTabBar(QTabBar *tabBar);
                 void removeDragDropTabBar(QTabBar *tabBar);
                 QUrl imageTemporaryUrl(const QImage &image) const;
                 void setHightlightedDragWidget(VisualizationDragWidget *dragWidget);
                 VisualizationDragWidget *getHightlightedDragWidget() const;
+                /// Delays the closing of a widget during a drag&drop operation
+                void delayedCloseWidget(QWidget *widget);
+                void doCloseWidgets();
             private:
                 class DragDropHelperPrivate;
                 spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
             };
             #endif // SCIQLOP_DRAGDROPHELPER_H

gui/src/DragAndDrop/DragDropHelper.cpp +17 0

             #include "DragAndDrop/DragDropHelper.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
             struct DragDropHelper::DragDropHelperPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel *m_PlaceHolderLabel;
                 QWidget *m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
                 std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
+                QList<QWidget *> m_WidgetToClose;
                 explicit DragDropHelperPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()},
                           m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                 {
                     auto layout = new QVBoxLayout{m_PlaceHolder.get()};
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
                 void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
                 {
                     if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
                     else {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type) {
                         case DragDropHelper::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
                         case DragDropHelper::PlaceHolderType::Zone:
                         case DragDropHelper::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
             DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget &DragDropHelper::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
             void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                                    const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
             void DragDropHelper::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget) {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
                 }
             }
             bool DragDropHelper::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
             void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
             QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
+            void DragDropHelper::delayedCloseWidget(QWidget *widget)
+            {
+                widget->hide();
+                impl->m_WidgetToClose << widget;
+            }
+            void DragDropHelper::doCloseWidgets()
+            {
+                for (auto widget : impl->m_WidgetToClose) {
+                    widget->close();
+                }
+                impl->m_WidgetToClose.clear();
+            }
             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
                     qCWarning(LOG_DragDropHelper()) << QObject::tr(
                         "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         auto variable = variables.first();
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent) {
                                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                                 FindVariableOperation findVariableOperation{variable};
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty()) {
                                     result = true;
                                 }
                                 else {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else {
                                 qCWarning(LOG_DragDropHelper()) << QObject::tr(
                                     "DragDropHelper::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/Visualization/VisualizationDragDropContainer.cpp +3 -2

             #include "Visualization/VisualizationDragDropContainer.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Common/VisualizationDef.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
                 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
                 QString m_PlaceHolderText;
                 DragDropHelper::PlaceHolderType m_PlaceHolderType = DragDropHelper::PlaceHolderType::Graph;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 int m_MinContainerHeight = 0;
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 bool acceptMimeData(const QMimeData *data) const
                 {
                     for (const auto &type : m_AcceptedMimeTypes.keys()) {
                         if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool allowMergeForMimeData(const QMimeData *data) const
                 {
                     bool result = false;
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             result = true;
                         }
                         else if (data->hasFormat(it.key())
                                  && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
                             // Merge is forbidden if the mime data contain an acceptable type which cannot be
                             // merged
                             result = false;
                             break;
                         }
                     }
                     return result;
                 }
                 bool allowInsertForMimeData(const QMimeData *data) const
                 {
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
                     return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
                 }
                 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
                 {
                     VisualizationDragWidget *dragWidget = nullptr;
                     for (auto child : parent->children()) {
                         auto widget = qobject_cast<VisualizationDragWidget *>(child);
                         if (widget && widget->isVisible()) {
                             if (widget->frameGeometry().contains(pos)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 bool cursorIsInContainer(QWidget *container) const
                 {
                     return container->isAncestorOf(sqpApp->widgetAt(QCursor::pos()));
                 }
                 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
                 {
                     auto nbGraph = 0;
                     for (auto child : parent->children()) {
                         if (qobject_cast<VisualizationDragWidget *>(child)) {
                             if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
                                 nbGraph += 1;
                             }
                         }
                     }
                     return nbGraph;
                 }
                 void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
                                              const VisualizationDragDropContainer *container);
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
                     : QFrame{parent},
                       impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
             {
                 setAcceptDrops(true);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::addAcceptedMimeType(
                 const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
             {
                 impl->m_AcceptedMimeTypes[mimeType] = behavior;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
                 return impl->countDragWidget(this);
             }
             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
             {
                 impl->m_AcceptMimeDataFun = fun;
             }
             void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
                                                                     const QString &placeHolderText)
             {
                 impl->m_PlaceHolderType = type;
                 impl->m_PlaceHolderText = placeHolderText;
             }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 drag->setHotSpot(dragPosition);
                 auto mimeData = dragWidget->mimeData();
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap(dragWidget->size());
                 dragWidget->render(&pixmap);
                 drag->setPixmap(pixmap);
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
                     helper.setCurrentDragWidget(dragWidget);
                     if (impl->cursorIsInContainer(this)) {
                         auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                         helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
                                                  impl->m_PlaceHolderText);
                         dragWidget->setVisible(false);
                     }
                     else {
                         // The drag starts directly outside the drop zone
                         // do not add the placeHolder
                     }
-                    // Note: The exec() is blocking on windows but not on linux and macOS
+                    drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::MoveAction);
-                    drag->exec(Qt::MoveAction | Qt::CopyAction);
+                    helper.doCloseWidgets();
                 }
                 else {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
                 }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
                     auto &helper = sqpApp->dragDropHelper();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
                         if (dragWidget) {
                             // If the drag&drop is internal to the visualization, entering the container hide
                             // the dragWidget which was made visible by the dragLeaveEvent
                             auto parentWidget
                                 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                             if (parentWidget) {
                                 dragWidget->setVisible(false);
                             }
                         }
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                     }
                     else {
                         // do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
                 auto &helper = sqpApp->dragDropHelper();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
                     helper.setHightlightedDragWidget(nullptr);
                     impl->m_MinContainerHeight = 0;
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (dragWidget) {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
                         if (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
                 else {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
                 }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                     auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                     impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragMoveEvent(event);
             }
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (impl->hasPlaceHolder()) {
                         // drop where the placeHolder is located
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         if (canInsert) {
                             auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
                             if (dragWidget) {
                                 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     droppedIndex -= 1;
                                 }
                                 dragWidget->setVisible(true);
                             }
                             event->acceptProposedAction();
                             helper.removePlaceHolder();
                             emit dropOccuredInContainer(droppedIndex, event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer()) << tr(
                                 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
                                 "the insertion is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                     else if (helper.getHightlightedDragWidget()) {
                         // drop on the highlighted widget
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         if (canMerge) {
                             event->acceptProposedAction();
                             emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
                                       "the merge is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                 }
                 else {
                     event->ignore();
                 }
                 sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
                 impl->m_MinContainerHeight = 0;
                 QWidget::dropEvent(event);
             }
             void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
                 const QPoint &pos, bool canInsert, bool canMerge,
                 const VisualizationDragDropContainer *container)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto absPos = container->mapToGlobal(pos);
                 auto isOnPlaceHolder = sqpApp->widgetAt(absPos) == &(helper.placeHolder());
                 if (countDragWidget(container, true) == 0) {
                     // Drop on an empty container, just add the placeHolder at the top
                     helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
                 }
                 else if (!isOnPlaceHolder) {
                     auto nbDragWidget = countDragWidget(container);
                     if (nbDragWidget > 0) {
                         if (m_MinContainerHeight == 0) {
                             m_MinContainerHeight = container->size().height();
                         }
                         m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
                         auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
                         auto posY = pos.y();
                         auto dropIndex = floor(posY / graphHeight);
                         auto zoneSize = qMin(graphHeight / 4.0, 75.0);
                         auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
                         auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
                         auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
                         auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
                         if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
                             if (isOnBottom) {
                                 dropIndex += 1;
                             }
                             if (helper.getCurrentDragWidget()) {
                                 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     dropIndex += 1;
                                 }
                             }
                             if (dropIndex != placeHolderIndex) {
                                 helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
                                                          m_PlaceHolderText);
                             }
                             helper.setHightlightedDragWidget(nullptr);
                         }
                         else if (canMerge && dragWidgetHovered) {
                             // drop on the middle -> merge
                             if (hasPlaceHolder()) {
                                 helper.removePlaceHolder();
                             }
                             helper.setHightlightedDragWidget(dragWidgetHovered);
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
                                       "action.");
                         }
                     }
                     else {
                         qCWarning(LOG_VisualizationDragDropContainer())
                             << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
                                   "found in the "
                                   "container");
                     }
                 }
                 else {
                     // the mouse is hover the placeHolder
                     // Do nothing
                 }
             }

gui/src/Visualization/VisualizationTabWidget.cpp +3 -3

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 5);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
                 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 if (!variables.isEmpty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
-                        graphWidget->parentZoneWidget()->close();
+                        helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
                     else {
                         // Close the graph
-                        graphWidget->close();
+                        helper.delayedCloseWidget(graphWidget);
                     }
                     tabWidget->createZone(variables, index);
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
-                        parentZoneWidget->close();
+                        helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +2 -2

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 // Returns the first graph in the zone or nullptr if there is no graph inside
                 VisualizationGraphWidget *firstGraph(const VisualizationZoneWidget *zoneWidget) const
                 {
                     VisualizationGraphWidget *firstGraph = nullptr;
                     auto layout = zoneWidget->ui->dragDropContainer->layout();
                     if (layout->count() > 0) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                             firstGraph = visualizationGraphWidget;
                         }
                     }
                     return firstGraph;
                 }
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Graph);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 if (auto firstGraph = impl->firstGraph(this)) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
-                        previousParentZoneWidget->close();
+                        helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
-                        graphWidget->close();
+                        helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     zoneWidget->createGraph(variables, index);
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages