HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1075:029fbf916457

Rename "DragDropHelper" in "DragDropGuiController"

trabillard -

r1075:029fbf916457

parent child

Context file:

r1075:029fbf916457

gui/include/DragAndDrop/DragDropGuiController.h ~~gui/include/DragAndDrop/DragDropHelper.h~~ renamed +9 -9

-            #ifndef SCIQLOP_DRAGDROPHELPER_H
+            #ifndef SCIQLOP_DRAGDROPGUICONTROLLER_H
-            #define SCIQLOP_DRAGDROPHELPER_H
+            #define SCIQLOP_DRAGDROPGUICONTROLLER_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             class VisualizationDragDropContainer;
             class QMimeData;
-            Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
+            Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropGuiController)
             /**
              * @brief Helper class for drag&drop operations.
              * can interect with the gui.
              * @see SqpApplication
              */
-            class DragDropHelper {
+            class DragDropGuiController {
             public:
                 static const QString MIME_TYPE_GRAPH;
                 static const QString MIME_TYPE_ZONE;
                 enum class PlaceHolderType { Default, Graph, Zone };
-                DragDropHelper();
+                DragDropGuiController();
-                virtual ~DragDropHelper();
+                virtual ~DragDropGuiController();
                 /// Resets some internal variables. Must be called before any new drag&drop operation.
                 void resetDragAndDrop();
                 void doCloseWidgets();
             private:
-                class DragDropHelperPrivate;
+                class DragDropGuiControllerPrivate;
-                spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
+                spimpl::unique_impl_ptr<DragDropGuiControllerPrivate> impl;
             };
-            #endif // SCIQLOP_DRAGDROPHELPER_H
+            #endif // SCIQLOP_DRAGDROPGUICONTROLLER_H

gui/include/SqpApplication.h +2 -2

             class TimeController;
             class VariableController;
             class VisualizationController;
-            class DragDropHelper;
+            class DragDropGuiController;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
                 /// 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;
+                DragDropGuiController &dragDropGuiController() noexcept;
                 enum class PlotsInteractionMode { None, ZoomBox, DragAndDrop, SelectionZones };

gui/include/Visualization/VisualizationDragDropContainer.h +2 -2

             #include <functional>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer)
                 void setAcceptDragWidgetFunction(AcceptDragWidgetFunction fun);
-                void setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+                void setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                                         const QString &placeHolderText = QString());
             protected:

gui/src/DataSource/DataSourceTreeWidget.cpp +2 -2

             #include "DataSource/DataSourceItem.h"
             #include "DataSource/DataSourceTreeWidgetItem.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             #include <QMimeData>
             void DataSourceTreeWidget::startDrag(Qt::DropActions supportedActions)
             {
                 // Resets the drag&drop operations before it's starting
-                sqpApp->dragDropHelper().resetDragAndDrop();
+                sqpApp->dragDropGuiController().resetDragAndDrop();
                 QTreeWidget::startDrag(supportedActions);
             }

gui/src/DragAndDrop/DragDropGuiController.cpp ~~gui/src/DragAndDrop/DragDropHelper.cpp~~ renamed +34 -32

-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include <QVBoxLayout>
-            Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
+            Q_LOGGING_CATEGORY(LOG_DragDropGuiController, "DragDropGuiController")
-            struct DragDropHelper::DragDropHelperPrivate {
+            struct DragDropGuiController::DragDropGuiControllerPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QList<QWidget *> m_WidgetToClose;
-                explicit DragDropHelperPrivate()
+                explicit DragDropGuiControllerPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()},
                           m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
-                void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) const
+                void preparePlaceHolder(DragDropGuiController::PlaceHolderType type,
+                                        const QString &topLabelText) const
                 {
                     if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                     }
                     switch (type) {
-                        case DragDropHelper::PlaceHolderType::Graph:
+                        case DragDropGuiController::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
-                        case DragDropHelper::PlaceHolderType::Zone:
+                        case DragDropGuiController::PlaceHolderType::Zone:
-                        case DragDropHelper::PlaceHolderType::Default:
+                        case DragDropGuiController::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
             };
-            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
+            DragDropGuiController::DragDropGuiController()
+                    : impl{spimpl::make_unique_impl<DragDropGuiControllerPrivate>()}
             {
             }
-            DragDropHelper::~DragDropHelper()
+            DragDropGuiController::~DragDropGuiController()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
-            void DragDropHelper::resetDragAndDrop()
+            void DragDropGuiController::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
-            void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
+            void DragDropGuiController::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                 impl->m_CurrentDragWidget = dragWidget;
             }
-            VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
+            VisualizationDragWidget *DragDropGuiController::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
-            QWidget &DragDropHelper::placeHolder() const
+            QWidget &DragDropGuiController::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
-            void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+            void DragDropGuiController::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                                           const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->m_PlaceHolder->show();
             }
-            void DragDropHelper::removePlaceHolder()
+            void DragDropGuiController::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget) {
                 }
             }
-            bool DragDropHelper::isPlaceHolderSet() const
+            bool DragDropGuiController::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
-            void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
+            void DragDropGuiController::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
-            void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
+            void DragDropGuiController::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
-            void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
+            void DragDropGuiController::addDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
-            void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
+            void DragDropGuiController::removeDragDropTabBar(QTabBar *tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
-            QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
+            QUrl DragDropGuiController::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
-            void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
+            void DragDropGuiController::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                 impl->m_HighlightedDragWidget = dragWidget;
             }
-            VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
+            VisualizationDragWidget *DragDropGuiController::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
-            void DragDropHelper::delayedCloseWidget(QWidget *widget)
+            void DragDropGuiController::delayedCloseWidget(QWidget *widget)
             {
                 widget->hide();
                 impl->m_WidgetToClose << widget;
             }
-            void DragDropHelper::doCloseWidgets()
+            void DragDropGuiController::doCloseWidgets()
             {
                 for (auto widget : impl->m_WidgetToClose) {
                     widget->close();
                 impl->m_WidgetToClose.clear();
             }
-            bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
+            bool DragDropGuiController::checkMimeDataForVisualization(
-                                                               VisualizationDragDropContainer *dropContainer)
+                const QMimeData *mimeData, VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
-                    qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                    qCWarning(LOG_DragDropGuiController()) << QObject::tr(
-                        "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
+                        "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                                 }
                             }
                             else {
-                                qCWarning(LOG_DragDropHelper()) << QObject::tr(
+                                qCWarning(LOG_DragDropGuiController()) << QObject::tr(
-                                    "DragDropHelper::checkMimeDataForVisualization, the parent "
+                                    "DragDropGuiController::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }

gui/src/SqpApplication.cpp +5 -5

             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
-                          m_DragDropHelper{std::make_unique<DragDropHelper>()},
+                          m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
                           m_CatalogueController{std::make_unique<CatalogueController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 QThread m_VisualizationControllerThread;
                 QThread m_CatalogueControllerThread;
-                std::unique_ptr<DragDropHelper> m_DragDropHelper;
+                std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
                 return *impl->m_VisualizationController;
             }
-            DragDropHelper &SqpApplication::dragDropHelper() noexcept
+            DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
             {
-                return *impl->m_DragDropHelper;
+                return *impl->m_DragDropGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const

gui/src/TimeWidget/TimeWidget.cpp +2 -2

             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
                 auto pixmap = QPixmap{":/icones/time.png"};
                 drag->setPixmap(pixmap.scaledToWidth(22));
-                sqpApp->dragDropHelper().resetDragAndDrop();
+                sqpApp->dragDropGuiController().resetDragAndDrop();
                 // Note: The exec() is blocking on windows but not on linux and macOS
                 drag->exec(Qt::MoveAction | Qt::CopyAction);

gui/src/Variable/VariableInspectorTableView.cpp +2 -2

             #include "Variable/VariableInspectorTableView.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             VariableInspectorTableView::VariableInspectorTableView(QWidget *parent) : QTableView(parent)
             void VariableInspectorTableView::startDrag(Qt::DropActions supportedActions)
             {
                 // Resets the drag&drop operations before it's starting
-                sqpApp->dragDropHelper().resetDragAndDrop();
+                sqpApp->dragDropGuiController().resetDragAndDrop();
                 QTableView::startDrag(supportedActions);
             }

gui/src/Variable/VariableInspectorWidget.cpp +1 -1

             #include <QStyledItemDelegate>
             #include <QWidgetAction>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")

gui/src/Visualization/VisualizationDragDropContainer.cpp +13 -12

             #include "Visualization/VisualizationDragDropContainer.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
                 QVBoxLayout *m_Layout;
                 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
                 QString m_PlaceHolderText;
-                DragDropHelper::PlaceHolderType m_PlaceHolderType;
+                DragDropGuiController::PlaceHolderType m_PlaceHolderType;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 int m_MinContainerHeight = 0;
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
-                        : m_PlaceHolderType(DragDropHelper::PlaceHolderType::Graph)
+                        : m_PlaceHolderType(DragDropGuiController::PlaceHolderType::Graph)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 bool hasPlaceHolder() const
                 {
-                    return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
+                    return sqpApp->dragDropGuiController().placeHolder().parentWidget()
+                           == m_Layout->parentWidget();
                 }
                 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
                 {
                     auto widgetUnderMouse = sqpApp->widgetAt(QCursor::pos());
                     return container->isAncestorOf(widgetUnderMouse) && widgetUnderMouse != container
-                           && sqpApp->dragDropHelper().placeHolder().isAncestorOf(widgetUnderMouse);
+                           && sqpApp->dragDropGuiController().placeHolder().isAncestorOf(widgetUnderMouse);
                 }
                 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
                 impl->m_AcceptDragWidgetFun = fun;
             }
-            void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
+            void VisualizationDragDropContainer::setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
                                                                     const QString &placeHolderText)
             {
                 impl->m_PlaceHolderType = type;
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
-                    auto &helper = sqpApp->dragDropHelper();
+                    auto &helper = sqpApp->dragDropGuiController();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
             {
                 Q_UNUSED(event);
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = helper.getCurrentDragWidget();
                     event->ignore();
                 }
-                sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
+                sqpApp->dragDropGuiController().setHightlightedDragWidget(nullptr);
                 impl->m_MinContainerHeight = 0;
                 QWidget::dropEvent(event);
                 const QPoint &pos, const QMimeData *mimeData, bool canInsert, bool canMerge,
                 const VisualizationDragDropContainer *container)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto absPos = container->mapToGlobal(pos);
                 auto isOnPlaceHolder = helper.placeHolder().isAncestorOf(sqpApp->widgetAt(absPos));

gui/src/Visualization/VisualizationGraphWidget.cpp +1 -1

             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>

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

             #include "Common/MimeTypesDef.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
                 impl->m_MacScrollBarStyle->selfInstallOn(ui->scrollArea, true);
             #endif
-                ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
+                ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 12);
                 ui->dragDropContainer->layout()->setSpacing(0);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
-                sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
+                sqpApp->dragDropGuiController().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             VisualizationTabWidget::~VisualizationTabWidget()
             {
-                sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
+                sqpApp->dragDropGuiController().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {

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

             #include "ui_VisualizationWidget.h"
-            #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
             #include <QToolButton>
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
-                sqpApp->dragDropHelper().addDragDropTabBar(ui->tabWidget->tabBar());
+                sqpApp->dragDropGuiController().addDragDropTabBar(ui->tabWidget->tabBar());
                 // Adds default tab
                 addTabView();
             VisualizationWidget::~VisualizationWidget()
             {
-                sqpApp->dragDropHelper().removeDragDropTabBar(ui->tabWidget->tabBar());
+                sqpApp->dragDropGuiController().removeDragDropTabBar(ui->tabWidget->tabBar());
                 delete ui;
             }

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

             #include <Visualization/operations/FindVariableOperation.h>
-            #include <DragAndDrop/DragDropHelper.h>
+            #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
                 ui->zoneNameLabel->setText(name);
-                ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Graph);
+                ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
-                auto &helper = sqpApp->dragDropHelper();
+                auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {

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