GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r891:dd73a5040007

Moves the class DragDropScroller in its own file

trabillard -

r891:dd73a5040007

parent child

Context file:

r891:dd73a5040007

gui/include/DragAndDrop/DragDropScroller.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef SCIQLOP_DRAGDROPSCROLLER_H
	2	#define SCIQLOP_DRAGDROPSCROLLER_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QScrollArea>
	6
	7	/**
	8	* @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
	9	* @note A QScrollArea inside an other QScrollArea is not fully supported.
	10	*/
	11	class DragDropScroller : public QObject {
	12	Q_OBJECT
	13
	14	public:
	15	DragDropScroller(QObject *parent = nullptr);
	16
	17	void addScrollArea(QScrollArea *scrollArea);
	18	void removeScrollArea(QScrollArea *scrollArea);
	19
	20	protected:
	21	bool eventFilter(QObject obj, QEvent event);
	22
	23	private:
	24	class DragDropScrollerPrivate;
	25	spimpl::unique_impl_ptr<DragDropScrollerPrivate> impl;
	26
	27	private slots:
	28	void onTimer();
	29	};
	30
	31
	32	#endif // SCIQLOP_DRAGDROPSCROLLER_H

gui/src/DragAndDrop/DragDropScroller.cpp created 644 +125 0

@@ -0,0 +1,125
	1	#include "DragAndDrop/DragDropScroller.h"
	2
	3	#include <QDragEnterEvent>
	4	#include <QDragMoveEvent>
	5	#include <QScrollBar>
	6	#include <QTimer>
	7
	8	const int SCROLL_SPEED = 5;
	9	const int SCROLL_ZONE_SIZE = 50;
	10
	11	struct DragDropScroller::DragDropScrollerPrivate {
	12
	13	QList<QScrollArea *> m_ScrollAreas;
	14	QScrollArea *m_CurrentScrollArea = nullptr;
	15	std::unique_ptr<QTimer> m_Timer = nullptr;
	16
	17	enum class ScrollDirection { up, down, unknown };
	18	ScrollDirection m_Direction = ScrollDirection::unknown;
	19
	20	explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
	21	{
	22	m_Timer->setInterval(0);
	23	}
	24	};
	25
	26	DragDropScroller::DragDropScroller(QObject *parent)
	27	: QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
	28	{
	29	connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
	30	}
	31
	32	void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
	33	{
	34	impl->m_ScrollAreas << scrollArea;
	35	scrollArea->viewport()->setAcceptDrops(true);
	36	}
	37
	38	void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
	39	{
	40	impl->m_ScrollAreas.removeAll(scrollArea);
	41	scrollArea->viewport()->setAcceptDrops(false);
	42	}
	43
	44	bool DragDropScroller::eventFilter(QObject obj, QEvent event)
	45	{
	46	if (event->type() == QEvent::DragMove) {
	47	auto w = static_cast<QWidget *>(obj);
	48
	49	if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
	50	auto moveEvent = static_cast<QDragMoveEvent *>(event);
	51
	52	auto pos = moveEvent->pos();
	53	if (impl->m_CurrentScrollArea->viewport() != w) {
	54	auto globalPos = w->mapToGlobal(moveEvent->pos());
	55	pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
	56	}
	57
	58	auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
	59	- SCROLL_ZONE_SIZE;
	60	auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
	61
	62	if (!isInTopZone && !isInBottomZone) {
	63	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	64	impl->m_Timer->stop();
	65	}
	66	else if (!impl->m_Timer->isActive()) {
	67	impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
	68	: DragDropScrollerPrivate::ScrollDirection::down;
	69	impl->m_Timer->start();
	70	}
	71	}
	72	}
	73	else if (event->type() == QEvent::DragEnter) {
	74	auto w = static_cast<QWidget *>(obj);
	75
	76	for (auto scrollArea : impl->m_ScrollAreas) {
	77	if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
	78	auto enterEvent = static_cast<QDragEnterEvent *>(event);
	79	enterEvent->acceptProposedAction();
	80	enterEvent->setDropAction(Qt::IgnoreAction);
	81	impl->m_CurrentScrollArea = scrollArea;
	82	break;
	83	}
	84	}
	85	}
	86	else if (event->type() == QEvent::DragLeave) {
	87	if (impl->m_CurrentScrollArea) {
	88	if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
	89	.contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
	90	impl->m_CurrentScrollArea = nullptr;
	91	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	92	impl->m_Timer->stop();
	93	}
	94	}
	95	}
	96	else if (event->type() == QEvent::Drop) {
	97	if (impl->m_CurrentScrollArea) {
	98	impl->m_CurrentScrollArea = nullptr;
	99	impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
	100	impl->m_Timer->stop();
	101	}
	102	}
	103
	104	return false;
	105	}
	106
	107	void DragDropScroller::onTimer()
	108	{
	109	if (impl->m_CurrentScrollArea) {
	110	auto mvt = 0;
	111	switch (impl->m_Direction) {
	112	case DragDropScrollerPrivate::ScrollDirection::up:
	113	mvt = SCROLL_SPEED;
	114	break;
	115	case DragDropScrollerPrivate::ScrollDirection::down:
	116	mvt = -SCROLL_SPEED;
	117	break;
	118	default:
	119	break;
	120	}
	121
	122	impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
	123	impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
	124	}
	125	}

gui/include/DragAndDrop/DragDropHelper.h 0 -24

             #ifndef SCIQLOP_DRAGDROPHELPER_H
             #define SCIQLOP_DRAGDROPHELPER_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class QVBoxLayout;
             class QScrollArea;
             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);
                 QUrl imageTemporaryUrl(const QImage &image) const;
                 void setHightlightedDragWidget(VisualizationDragWidget *dragWidget);
                 VisualizationDragWidget *getHightlightedDragWidget() const;
             private:
                 class DragDropHelperPrivate;
                 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/meson.build +2 0

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropHelper.h',
+              'include/DragAndDrop/DragDropScroller.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
+              'src/DragAndDrop/DragDropScroller.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/DragAndDrop/DragDropHelper.cpp +2 -122

             #include "DragAndDrop/DragDropHelper.h"
+            #include "DragAndDrop/DragDropScroller.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 <QDragEnterEvent>
-            #include <QDragMoveEvent>
             #include <QLabel>
-            #include <QScrollArea>
+            #include <QUrl>
-            #include <QScrollBar>
-            #include <QTimer>
             #include <QVBoxLayout>
-            const int SCROLL_SPEED = 5;
-            const int SCROLL_ZONE_SIZE = 50;
             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
-            struct DragDropScroller::DragDropScrollerPrivate {
-                QList<QScrollArea *> m_ScrollAreas;
-                QScrollArea *m_CurrentScrollArea = nullptr;
-                std::unique_ptr<QTimer> m_Timer = nullptr;
-                enum class ScrollDirection { up, down, unknown };
-                ScrollDirection m_Direction = ScrollDirection::unknown;
-                explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
-                    m_Timer->setInterval(0);
-            };
-            DragDropScroller::DragDropScroller(QObject *parent)
-                    : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
-                connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
-            void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
-                impl->m_ScrollAreas << scrollArea;
-                scrollArea->viewport()->setAcceptDrops(true);
-            void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
-                impl->m_ScrollAreas.removeAll(scrollArea);
-                scrollArea->viewport()->setAcceptDrops(false);
-            bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
-                if (event->type() == QEvent::DragMove) {
-                    auto w = static_cast<QWidget *>(obj);
-                    if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
-                        auto moveEvent = static_cast<QDragMoveEvent *>(event);
-                        auto pos = moveEvent->pos();
-                        if (impl->m_CurrentScrollArea->viewport() != w) {
-                            auto globalPos = w->mapToGlobal(moveEvent->pos());
-                            pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
-                        auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
-                                                         - SCROLL_ZONE_SIZE;
-                        auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
-                        if (!isInTopZone && !isInBottomZone) {
-                            impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-                            impl->m_Timer->stop();
-                        else if (!impl->m_Timer->isActive()) {
-                            impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
-                                                            : DragDropScrollerPrivate::ScrollDirection::down;
-                            impl->m_Timer->start();
-                else if (event->type() == QEvent::DragEnter) {
-                    auto w = static_cast<QWidget *>(obj);
-                    for (auto scrollArea : impl->m_ScrollAreas) {
-                        if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
-                            auto enterEvent = static_cast<QDragEnterEvent *>(event);
-                            enterEvent->acceptProposedAction();
-                            enterEvent->setDropAction(Qt::IgnoreAction);
-                            impl->m_CurrentScrollArea = scrollArea;
-                            break;
-                else if (event->type() == QEvent::DragLeave) {
-                    if (impl->m_CurrentScrollArea) {
-                        if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
-                                 .contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
-                            impl->m_CurrentScrollArea = nullptr;
-                            impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-                            impl->m_Timer->stop();
-                else if (event->type() == QEvent::Drop) {
-                    if (impl->m_CurrentScrollArea) {
-                        impl->m_CurrentScrollArea = nullptr;
-                        impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-                        impl->m_Timer->stop();
-                return false;
-            void DragDropScroller::onTimer()
-                if (impl->m_CurrentScrollArea) {
-                    auto mvt = 0;
-                    switch (impl->m_Direction) {
-                        case DragDropScrollerPrivate::ScrollDirection::up:
-                            mvt = SCROLL_SPEED;
-                            break;
-                        case DragDropScrollerPrivate::ScrollDirection::down:
-                            mvt = -SCROLL_SPEED;
-                            break;
-                        default:
-                            break;
-                    impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
-                        impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
             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;
                 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;
                 explicit DragDropHelperPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
                           m_DragDropScroller{std::make_unique<DragDropScroller>()}
                 {
                     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());
                     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);
             }
             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;
             }
             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;
             }

General Comments 3

trabillard

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 1 added
  * 0 removed

Changed files:
  * A core/tests/meson.build

Write
Preview

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

	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