HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r873:5662e2f354c4

Improves visual effect of dropping a variable in a graph

trabillard -

r873:5662e2f354c4

parent child

Context file:

r873:5662e2f354c4

gui/include/DragDropHelper.h +2 0

                  QUrl imageTemporaryUrl(const QImage &image) const;
+                 void setHightlightedDragWidget(VisualizationDragWidget *dragWidget);
              private:
                  class DragDropHelperPrivate;
                  spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;

gui/include/Visualization/VisualizationDragWidget.h +1 0

                  virtual QMimeData *mimeData() const = 0;
                  virtual bool isDragAllowed() const = 0;
+                 virtual void highlightForMerge(bool highlighted) { Q_UNUSED(highlighted); };
              protected:
                  virtual void mousePressEvent(QMouseEvent *event) override;

gui/include/Visualization/VisualizationGraphWidget.h +1 0

                  // VisualisationDragWidget
                  QMimeData *mimeData() const override;
                  bool isDragAllowed() const override;
+                 void highlightForMerge(bool highlighted) override;
              signals:
                  void synchronize(const SqpRange &range, const SqpRange &oldRange);

gui/src/DragDropHelper.cpp +15 -1

                  QScrollArea *m_CurrentScrollArea = nullptr;
                  std::unique_ptr<QTimer> m_Timer = nullptr;
                  enum class ScrollDirection { up, down, unknown };
                  ScrollDirection m_Direction = ScrollDirection::unknown;
                  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;
                  explicit DragDropHelperPrivate()
                          : m_PlaceHolder{std::make_unique<QWidget>()},
                            m_DragDropScroller{std::make_unique<DragDropScroller>()}
              void DragDropHelper::resetDragAndDrop()
              {
                  setCurrentDragWidget(nullptr);
+                 impl->m_HighlightedDragWidget = nullptr;
              }
              void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
                  return QUrl::fromLocalFile(impl->m_ImageTempUrl);
              }
+             void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
+             {
+                 if (impl->m_HighlightedDragWidget) {
+                     impl->m_HighlightedDragWidget->highlightForMerge(false);
+                 }
+                 if (dragWidget) {
+                     impl->m_HighlightedDragWidget = dragWidget;
+                     impl->m_HighlightedDragWidget->highlightForMerge(true);
+                 }
+             }
              bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                 VisualizationDragDropContainer *dropContainer)
              {

gui/src/Visualization/VisualizationDragDropContainer.cpp +103 -85

                  QStringList m_MergeAllowedMimeTypes;
                  VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                      = [](auto mimeData) { return true; };
+                 int m_MinContainerHeight = 0;
                  explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                  {
                      return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
                  }
-                 VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
+                 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
                  {
                      VisualizationDragWidget *dragWidget = nullptr;
                                               .adjusted(adustNum, adustNum, -adustNum, -adustNum);
                      return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
                  }
+                 int countDragWidget(const QWidget *parent) const
+                 {
+                     auto nbGraph = 0;
+                     for (auto child : parent->children()) {
+                         if (qobject_cast<VisualizationDragWidget *>(child)) {
+                             nbGraph += 1;
+                         }
+                     }
+                     return nbGraph;
+                 }
+                 void findPlaceHolderPosition(const QPoint &pos, bool canMerge,
+                                              const VisualizationDragDropContainer *container);
              };
              VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
              int VisualizationDragDropContainer::countDragWidget() const
              {
-                 auto nbGraph = 0;
-                 for (auto child : children()) {
-                     if (qobject_cast<VisualizationDragWidget *>(child)) {
-                         nbGraph += 1;
+                     }
+                 }
-                 return nbGraph;
+                 return impl->countDragWidget(this);
              }
              void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                          if (dragWidget) {
                              // If the drag&drop is internal to the visualization, entering the container hide
-                             // the dragWidget which was hidden by the dragLeaveEvent
+                             // the dragWidget which was made visible by the dragLeaveEvent
                              auto parentWidget
                                  = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                              if (parentWidget) {
                              }
                          }
-                         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) {
-                                     // 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);
+                         }
-                         else {
-                             helper.insertPlaceHolder(impl->m_Layout, 0);
+                         }
+                         auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                         impl->findPlaceHolderPosition(event->pos(), canMerge, this);
                      }
                      else {
                          // do nothing
                  if (!impl->cursorIsInContainer(this)) {
                      helper.removePlaceHolder();
+                     helper.setHightlightedDragWidget(nullptr);
+                     impl->m_MinContainerHeight = 0;
                      auto dragWidget = helper.getCurrentDragWidget();
                      if (dragWidget) {
              void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
              {
                  if (impl->acceptMimeData(event->mimeData())) {
-                     auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
-                     if (dragWidgetHovered) {
-                         auto canMerge = impl->allowMergeMimeData(event->mimeData());
-                         auto nbDragWidget = countDragWidget();
-                         if (nbDragWidget > 0) {
-                             auto graphHeight = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
-                             auto dropIndex = floor(event->pos().y() / graphHeight);
-                             auto zoneSize = qMin(graphHeight / 3.0, 150.0);
-                             auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
-                             auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
-                             auto &helper = sqpApp->dragDropHelper();
-                             auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
-                             if (isOnTop || isOnBottom) {
-                                 if (isOnBottom) {
-                                     dropIndex += 1;
+                                 }
-                                 if (helper.getCurrentDragWidget()) {
-                                     auto dragWidgetIndex
-                                         = impl->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(impl->m_Layout, dropIndex);
+                                 }
+                             }
-                             else if (canMerge) {
-                                 // drop on the middle -> merge
-                                 if (impl->hasPlaceHolder()) {
-                                     helper.removePlaceHolder();
+                                 }
+                             }
+                         }
-                         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
+                     }
+                     auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                     impl->findPlaceHolderPosition(event->pos(), canMerge, this);
                  }
                  else {
                      event->ignore();
                          qCWarning(LOG_VisualizationDragDropContainer())
                              << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
                                    "placeHolder is not found.");
-                         Q_ASSERT(false);
+                         // 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 canMerge, const VisualizationDragDropContainer *container)
+             {
+                 auto &helper = sqpApp->dragDropHelper();
+                 auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
+                 if (dragWidgetHovered) {
+                     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()));
+                         if (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);
+                             }
+                             helper.setHightlightedDragWidget(nullptr);
+                         }
+                         else if (canMerge) {
+                             // drop on the middle -> merge
+                             if (hasPlaceHolder()) {
+                                 helper.removePlaceHolder();
+                             }
+                             helper.setHightlightedDragWidget(dragWidgetHovered);
+                         }
+                     }
+                     else {
+                         qCWarning(LOG_VisualizationDragDropContainer())
+                             << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
+                                   "container");
+                     }
+                 }
+                 else if (!hasPlaceHolder()) {
+                     // Drop on an empty container, just add the placeHolder at the top
+                     helper.insertPlaceHolder(m_Layout, 0);
+                 }
+                 else {
+                     // No hovered drag widget, the mouse is probably hover the placeHolder
+                     // Do nothing
+                 }
+             }

gui/src/Visualization/VisualizationGraphWidget.cpp +12 0

                  return true;
              }
+             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
+             {
+                 if (highlighted) {
+                     plot().setBackground(QBrush(QColor("#BBD5EE")));
+                 }
+                 else {
+                     plot().setBackground(QBrush(Qt::white));
+                 }
+                 plot().update();
+             }
              void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
              {
                  Q_UNUSED(event);

gui/src/Visualization/VisualizationZoneWidget.cpp +1 0

                  ui->zoneNameLabel->setText(name);
                  ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
+                 ui->dragDropContainer->setMergeAllowedMimeTypes({MIME_TYPE_VARIABLE_LIST});
                  ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                      return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                    ui->dragDropContainer);

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