GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r852:2e038915a77e

drop of variables in the visualization

trabillard -

r852:2e038915a77e

parent child

Context file:

r852:2e038915a77e

core/src/Variable/VariableModel.cpp +2 0

                  QList<std::shared_ptr<Variable> > variableList;
                  for (const auto &index : indexes) {
+                     if (index.column() == 0) { // only the first column
                      auto variable = impl->m_Variables.at(index.row());
                      if (variable.get() && index.isValid()) {
                          variableList << variable;
                      }
                  }
+                 }
                  auto encodedData = impl->m_VariableController->mimeDataForVariables(variableList);
                  mimeData->setData(MIME_TYPE_VARIABLE_LIST, encodedData);

gui/include/DragDropHelper.h +43 -23

              #define SCIQLOP_DRAGDROPHELPER_H
              #include <Common/spimpl.h>
+             #include <QLoggingCategory>
              #include <QWidget>
              class QVBoxLayout;
              class QScrollArea;
              class VisualizationDragWidget;
+             class VisualizationDragDropContainer;
              class QMimeData;
-             /**
-              * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
-              * @note A QScrollArea inside an other QScrollArea is not fully supported.
-              */
-             class DragDropScroller : public QObject {
-                 Q_OBJECT
-             public:
-                 DragDropScroller(QObject *parent = nullptr);
-                 void addScrollArea(QScrollArea *scrollArea);
-                 void removeScrollArea(QScrollArea *scrollArea);
-             protected:
-                 bool eventFilter(QObject *obj, QEvent *event);
-             private:
-                 class DragDropScrollerPrivate;
-                 spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
-             private slots:
-                 void onTimer();
-             };
+             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:
                  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 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);
                  spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
              };
+             /**
+              * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
+              * @note A QScrollArea inside an other QScrollArea is not fully supported.
+              */
+             class DragDropScroller : public QObject {
+                 Q_OBJECT
+             public:
+                 DragDropScroller(QObject *parent = nullptr);
+                 void addScrollArea(QScrollArea *scrollArea);
+                 void removeScrollArea(QScrollArea *scrollArea);
+             protected:
+                 bool eventFilter(QObject *obj, QEvent *event);
+             private:
+                 class DragDropScrollerPrivate;
+                 spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
+             private slots:
+                 void onTimer();
+             };
              #endif // SCIQLOP_DRAGDROPHELPER_H

gui/include/SqpApplication.h +2 -1

                  VariableController &variableController() noexcept;
                  VisualizationController &visualizationController() noexcept;
-                 /// Accessors for the differents sciqlop helpers
+                 /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
+                 /// doesn't live in a thread and access gui
                  DragDropHelper &dragDropHelper() noexcept;
              private:

gui/include/Visualization/VisualizationDragDropContainer.h +9 0

              #define SCIQLOP_VISUALIZATIONDRAGDROPCONTAINER_H
              #include <Common/spimpl.h>
+             #include <QLoggingCategory>
              #include <QMimeData>
              #include <QVBoxLayout>
              #include <QWidget>
+             #include <functional>
+             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
              class VisualizationDragWidget;
              class VisualizationDragDropContainer : public QWidget {
                  void dropOccured(int dropIndex, const QMimeData *mimeData);
              public:
+                 using AcceptMimeDataFunction = std::function<bool(const QMimeData *mimeData)>;
                  VisualizationDragDropContainer(QWidget *parent = nullptr);
                  void addDragWidget(VisualizationDragWidget *dragWidget);
                  int countDragWidget() const;
+                 void setAcceptMimeDataFunction(AcceptMimeDataFunction fun);
              protected:
                  void dragEnterEvent(QDragEnterEvent *event);
                  void dragLeaveEvent(QDragLeaveEvent *event);

gui/src/DragDropHelper.cpp +63 -1

              #include "DragDropHelper.h"
              #include "SqpApplication.h"
+             #include "Visualization/VisualizationDragDropContainer.h"
              #include "Visualization/VisualizationDragWidget.h"
+             #include "Visualization/VisualizationWidget.h"
+             #include "Visualization/operations/FindVariableOperation.h"
+             #include "Variable/VariableController.h"
+             #include "Common/MimeTypesDef.h"
+             #include "Common/VisualizationDef.h"
              #include <QDir>
              #include <QDragEnterEvent>
              const int SCROLL_SPEED = 5;
              const int SCROLL_ZONE_SIZE = 50;
+             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
              struct DragDropScroller::DragDropScrollerPrivate {
                  QList<QScrollArea *> m_ScrollAreas;
                          m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                      }
                      else {
-                         m_PlaceHolder->setMinimumSize(200, 200);
+                         // Configuration of the placeHolder when there is no dragWidget
+                         // (for instance with a drag from a variable)
+                         m_PlaceHolder->setMinimumSize(400, 300);
+                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                      }
                  }
              };
                  QFile::remove(impl->m_ImageTempUrl);
              }
+             void DragDropHelper::resetDragAndDrop()
+             {
+                 setCurrentDragWidget(nullptr);
+             }
              void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
              {
                  impl->m_CurrentDragWidget = dragWidget;
                  image.save(impl->m_ImageTempUrl);
                  return QUrl::fromLocalFile(impl->m_ImageTempUrl);
              }
+             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
+                                                                VisualizationDragDropContainer *dropContainer)
+             {
+                 auto result = true;
+                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                     auto variables = sqpApp->variableController().variablesForMimeData(
+                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                     if (variables.count() == 1) {
+                         // Check that the viariable is not already in a graph
+                         // Search for the top level VisualizationWidget
+                         auto parent = dropContainer->parentWidget();
+                         while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
+                             parent = parent->parentWidget();
+                         }
+                         if (parent) {
+                             auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
+                             FindVariableOperation findVariableOperation{variables.first()};
+                             visualizationWidget->accept(&findVariableOperation);
+                             auto variableContainers = findVariableOperation.result();
+                             if (!variableContainers.empty()) {
+                                 result = false;
+                             }
+                         }
+                         else {
+                             qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                                 "DragDropHelper::checkMimeDataForVisualization, the parent "
+                                 "VisualizationWidget cannot be found.");
+                             result = false;
+                         }
+                     }
+                     else {
+                         result = false;
+                     }
+                 }
+                 return result;
+             }

gui/src/Variable/VariableInspectorWidget.cpp +6 0

              #include <QStyledItemDelegate>
              #include <QWidgetAction>
+             #include <DragDropHelper.h>
              #include <SqpApplication.h>
              Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
                  ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                  connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                          &VariableInspectorWidget::onTableMenuRequested);
+                 // Resets the drag&drop operation on a left-click (the drag&drop is also started by a left
+                 // click).
+                 connect(ui->tableView, &QTableView::clicked,
+                         [](const auto &modelIndex) { sqpApp->dragDropHelper().resetDragAndDrop(); });
              }
              VariableInspectorWidget::~VariableInspectorWidget()

gui/src/Visualization/VisualizationDragDropContainer.cpp +72 -15

              #include <cmath>
              #include <memory>
+             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
              struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                  QVBoxLayout *m_Layout;
                  QStringList m_AcceptedMimeTypes;
                  QStringList m_MergeAllowedMimeTypes;
+                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
+                     = [](auto mimeData) { return true; };
                  explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                  {
                  bool acceptMimeData(const QMimeData *data) const
                  {
                      for (const auto &type : m_AcceptedMimeTypes) {
-                         if (data->hasFormat(type)) {
+                         if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                              return true;
                          }
                      }
                  return nbGraph;
              }
+             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
+                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
+             {
+                 impl->m_AcceptMimeDataFun = fun;
+             }
              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};
                          helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
                          dragWidget->setVisible(false);
                      }
+                 }
                  // Note: The exec() is blocking on windows but not on linux and macOS
                  drag->exec(Qt::MoveAction | Qt::CopyAction);
              }
+                 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->hasPlaceHolder()) {
                          auto dragWidget = helper.getCurrentDragWidget();
+                         if (dragWidget) {
+                             // If the drag&drop is internal to the visualization, entering the container hide
+                             // the dragWidget which was hidden by the dragLeaveEvent
                          auto parentWidget
                              = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                          if (parentWidget) {
                              dragWidget->setVisible(false);
                          }
+                         }
                          auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
                          if (dragWidgetHovered) {
                              auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
+                             if (dragWidget) {
                              auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
                              if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
-                                 hoveredWidgetIndex
-                                     += 1; // Correction of the index if the drop occurs in the same container
+                                     // 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)
+                                     hoveredWidgetIndex += 1;
+                                 }
                              }
                              helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
                              helper.insertPlaceHolder(impl->m_Layout, 0);
                          }
                      }
+                     else {
+                         // do nothing
+                     }
                  }
                  else {
                      event->ignore();
                  if (!impl->cursorIsInContainer(this)) {
                      helper.removePlaceHolder();
-                     bool isInternal = true;
-                     if (isInternal) {
-                         // Only if the drag is started from the visualization
-                         // Show the drag widget at its original place
+                     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)
-                         auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
                          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);
              }
                                      dropIndex += 1;
                                  }
-                                 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                                 if (helper.getCurrentDragWidget()) {
+                                     auto dragWidgetIndex
+                                         = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
                                  if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
-                                     dropIndex += 1; // Correction of the index if the drop occurs in the same
-                                                     // container
+                                         // 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) {
                                  }
                              }
                          }
+                         else {
+                             qCWarning(LOG_VisualizationDragDropContainer())
+                                 << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
+                                       "container");
+                         }
+                     }
+                     else {
+                         // No hovered drag widget, the mouse is probably hover the placeHolder
+                         // Do nothing
                      }
                  }
                  else {
              {
                  if (impl->acceptMimeData(event->mimeData())) {
                      auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
-                     if (impl->hasPlaceHolder() && dragWidget) {
+                     if (impl->hasPlaceHolder()) {
                          auto &helper = sqpApp->dragDropHelper();
                          auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
+                         if (dragWidget) {
                          auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                          if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
-                             droppedIndex
-                                 -= 1; // Correction of the index if the drop occurs in the same container
+                                 // 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();
                          emit dropOccured(droppedIndex, event->mimeData());
                      }
+                     else {
+                         qCWarning(LOG_VisualizationDragDropContainer())
+                             << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
+                                   "placeHolder is not found.");
+                         Q_ASSERT(false);
+                     }
                  }
                  else {
                      event->ignore();

gui/src/Visualization/VisualizationTabWidget.cpp +85 -11

                  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)
              {
                  ui->setupUi(this);
-                 ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_ZONE});
+                 ui->dragDropContainer->setAcceptedMimeTypes(
+                     {MIME_TYPE_GRAPH, MIME_TYPE_ZONE, MIME_TYPE_VARIABLE_LIST});
                  connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
                          &VisualizationTabWidget::dropMimeData);
+                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
+                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                                                                                   ui->dragDropContainer);
+                 });
                  sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                  // Widget is deleted when closed
              void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
              {
-                 auto &helper = sqpApp->dragDropHelper();
                  if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
-                     auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                     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());
-                     Q_ASSERT(parentDragDropContainer);
+                 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();
-                             graphWidget->close();
-                         }
-                         createZone(variables, index);
+                     tabWidget->createZone(variables, index);
-                     }
-                     else {
-                         // The graph is empty, create an empty zone and move the graph inside
-                         parentDragDropContainer->layout()->removeWidget(graphWidget);
-                         auto zoneWidget = createEmptyZone(index);
+                     auto zoneWidget = tabWidget->createEmptyZone(index);
-                         zoneWidget->addGraph(graphWidget);
-                         // Close the old zone if it was the only graph inside
-                         }
-                     }
                  }
-                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
+             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
-                     auto zoneWidget = static_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
-                     auto parentDragDropContainer = zoneWidget->parentWidget();
-                     parentDragDropContainer->layout()->removeWidget(zoneWidget);
-                     ui->dragDropContainer->insertDragWidget(index, zoneWidget);
+                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
                  }
+             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
+                 const QList<std::shared_ptr<Variable> > &variables, int index,
+                 VisualizationTabWidget *tabWidget)
+             {
+                 // Note: we are sure that there is a single and compatible variable here
+                 // because the AcceptMimeDataFunction, set on the drop container, makes the check before the
+                 // drop can occur.
+                 tabWidget->createZone(variables, index);
              }

gui/src/Visualization/VisualizationZoneWidget.cpp +82 -9

              #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 <Variable/Variable.h>
              #include <Variable/VariableController.h>
+             #include <Visualization/operations/FindVariableOperation.h>
              #include <DragDropHelper.h>
              #include <QUuid>
              #include <SqpApplication.h>
                  }
                  QUuid m_SynchronisationGroupId;
                  std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
+                 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)
                  ui->zoneNameLabel->setText(name);
-                 ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH});
+                 ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
+                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
+                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                                                                                   ui->dragDropContainer);
+                 });
                  connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
                          &VisualizationZoneWidget::dropMimeData);
              void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
              {
-                 auto &helper = sqpApp->dragDropHelper();
                  if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
-                     auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+                     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::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());
-                     Q_ASSERT(parentDragDropContainer);
+                 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 != ui->dragDropContainer && !variables.isEmpty()) {
+                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
-                         // The drop didn't occur in the same zone
-                         // Abort the requests for the variables (if any)
-                         }
-                         // Creates the new graph in the zone
-                         createGraph(variables, index);
+                     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 != ui->dragDropContainer) {
+                     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 = ui->dragDropContainer->layout();
+                         auto layout = zoneWidget->ui->dragDropContainer->layout();
-                             if (layout->count() > 0) {
-                                 if (auto visualizationGraphWidget
-                                     = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
-                             }
-                         }
-                         ui->dragDropContainer->insertDragWidget(index, graphWidget);
+                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
+                 }
+             }
+             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
+                 const QList<std::shared_ptr<Variable> > &variables, int index,
+                 VisualizationZoneWidget *zoneWidget)
+             {
+                 // Search for the top level VisualizationWidget
+                 auto parent = zoneWidget->parentWidget();
+                 while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
+                     parent = parent->parentWidget();
+                 }
+                 if (!parent) {
+                     qCWarning(LOG_VisualizationZoneWidget())
+                         << tr("VisualizationZoneWidget::dropVariables, drop aborted, the parent "
+                               "VisualizationWidget cannot be found.");
+                     Q_ASSERT(false);
+                     return;
+                 }
+                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
+                 // Search for the first variable which can be dropped
+                 for (auto variable : variables) {
+                     FindVariableOperation findVariableOperation{variable};
+                     visualizationWidget->accept(&findVariableOperation);
+                     auto variableContainers = findVariableOperation.result();
+                     if (variableContainers.empty()) {
+                         zoneWidget->createGraph(variable, index);
+                         break;
                      }
                  }
              }

General Comments 1

trabillard

|

Auto status change to "Under Review"

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