GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r885:be7e4409e91c

Drag of the time widget on a graph

trabillard -

r885:be7e4409e91c

parent child

Context file:

r885:be7e4409e91c

gui/include/TimeWidget/TimeWidget.h +8 0

             #include <Data/SqpRange.h>
+            #include <Common/spimpl.h>
             namespace Ui {
             class TimeWidget;
             } // Ui
                 virtual ~TimeWidget();
                 void setTimeRange(SqpRange time);
+                SqpRange timeRange() const;
             signals:
                 /// Signal emitted when the time parameters has beed updated
                 void dragLeaveEvent(QDragLeaveEvent *event) override;
                 void dropEvent(QDropEvent *event) override;
+                void mousePressEvent(QMouseEvent *event) override;
+                void mouseMoveEvent(QMouseEvent *event) override;
             private:
                 Ui::TimeWidget *ui;
+                class TimeWidgetPrivate;
+                spimpl::unique_impl_ptr<TimeWidgetPrivate> impl;
             };
             #endif // SCIQLOP_ SQPSIDEPANE_H

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

                 void dropOccuredOnWidget(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             public:
+                enum class DropBehavior { Inserted, Merged, InsertedAndMerged };
                 using AcceptMimeDataFunction = std::function<bool(const QMimeData *mimeData)>;
                 VisualizationDragDropContainer(QWidget *parent = nullptr);
                 void addDragWidget(VisualizationDragWidget *dragWidget);
                 void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
-                void setAcceptedMimeTypes(const QStringList &mimeTypes);
+                void addAcceptedMimeType(const QString &mimeType, DropBehavior behavior);
-                void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
                 int countDragWidget() const;

gui/src/TimeWidget/TimeWidget.cpp +63 -3

@@ -4,14 +4,27
4	#include <Common/DateUtils.h>	4	#include <Common/DateUtils.h>
5	#include <Common/MimeTypesDef.h>	5	#include <Common/MimeTypesDef.h>
6		6
		7	#include <DragDropHelper.h>
7	#include <SqpApplication.h>	8	#include <SqpApplication.h>
8	#include <Time/TimeController.h>	9	#include <Time/TimeController.h>
9		10
		11	#include <QDrag>
10	#include <QDragEnterEvent>	12	#include <QDragEnterEvent>
11	#include <QDropEvent>	13	#include <QDropEvent>
12	#include <QMimeData>	14	#include <QMimeData>
13		15
14	TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}	16
		17	struct TimeWidget::TimeWidgetPrivate {
		18
		19	explicit TimeWidgetPrivate() {}
		20
		21	QPoint m_DragStartPosition;
		22	};
		23
		24	TimeWidget::TimeWidget(QWidget *parent)
		25	: QWidget{parent},
		26	ui{new Ui::TimeWidget},
		27	impl{spimpl::make_unique_impl<TimeWidgetPrivate>()}
15	{	28	{
16	ui->setupUi(this);	29	ui->setupUi(this);
17		30
@@ -56,11 +69,15 void TimeWidget::setTimeRange(SqpRange time)
56	ui->endDateTimeEdit->setDateTime(endDateTime);	69	ui->endDateTimeEdit->setDateTime(endDateTime);
57	}	70	}
58		71
59	void TimeWidget::onTimeUpdateRequested()	72	SqpRange TimeWidget::timeRange() const
60	{	73	{
61	~~auto~~ ~~dateTime~~ = SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),	74	return SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
62	DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};	75	DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
		76	}
63		77
		78	void TimeWidget::onTimeUpdateRequested()
		79	{
		80	auto dateTime = timeRange();
64	emit timeUpdated(std::move(dateTime));	81	emit timeUpdated(std::move(dateTime));
65	}	82	}
66		83
@@ -94,3 +111,46 void TimeWidget::dropEvent(QDropEvent *event)
94		111
95	setStyleSheet(QString());	112	setStyleSheet(QString());
96	}	113	}
		114
		115
		116	void TimeWidget::mousePressEvent(QMouseEvent *event)
		117	{
		118	if (event->button() == Qt::LeftButton) {
		119	impl->m_DragStartPosition = event->pos();
		120	}
		121
		122	QWidget::mousePressEvent(event);
		123	}
		124
		125	void TimeWidget::mouseMoveEvent(QMouseEvent *event)
		126	{
		127	if (!(event->buttons() & Qt::LeftButton)) {
		128	return;
		129	}
		130
		131	if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
		132	< QApplication::startDragDistance()) {
		133	return;
		134	}
		135
		136	// Note: The management of the drag object is done by Qt
		137	auto drag = new QDrag{this};
		138
		139	auto mimeData = new QMimeData;
		140	auto timeData = TimeController::mimeDataForTimeRange(timeRange());
		141	mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
		142
		143	drag->setMimeData(mimeData);
		144
		145	auto pixmap = QPixmap(size());
		146	render(&pixmap);
		147	drag->setPixmap(pixmap);
		148	drag->setHotSpot(impl->m_DragStartPosition);
		149
		150	sqpApp->dragDropHelper().resetDragAndDrop();
		151
		152	// Note: The exec() is blocking on windows but not on linux and macOS
		153	drag->exec(Qt::MoveAction \| Qt::CopyAction);
		154
		155	QWidget::mouseMoveEvent(event);
		156	}

gui/src/Visualization/VisualizationDragDropContainer.cpp +67 -24

             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
-                QStringList m_AcceptedMimeTypes;
+                QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
-                QStringList m_MergeAllowedMimeTypes;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 int m_MinContainerHeight = 0;
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                 bool acceptMimeData(const QMimeData *data) const
                 {
-                    for (const auto &type : m_AcceptedMimeTypes) {
+                    for (const auto &type : m_AcceptedMimeTypes.keys()) {
                         if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                             return true;
                         }
                     return false;
                 }
-                bool allowMergeMimeData(const QMimeData *data) const
+                bool allowMergeForMimeData(const QMimeData *data) const
                 {
-                    for (const auto &type : m_MergeAllowedMimeTypes) {
+                    bool result = false;
-                        if (data->hasFormat(type)) {
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+                         ++it) {
+                        if (data->hasFormat(it.key())
+                            && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
+                                || it.value()
+                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
+                            result = true;
+                        }
+                        else if (data->hasFormat(it.key())
+                                 && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
+                            // Merge is forbidden if the mime data contain an acceptable type which cannot be
+                            // merged
+                            result = false;
+                            break;
+                        }
+                    }
+                    return result;
+                }
+                bool allowInsertForMimeData(const QMimeData *data) const
+                {
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+                         ++it) {
+                        if (data->hasFormat(it.key())
+                            && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
+                                || it.value()
+                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             return true;
                         }
                     }
                     return nbGraph;
                 }
-                void findPlaceHolderPosition(const QPoint &pos, bool canMerge,
+                void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
                                              const VisualizationDragDropContainer *container);
             };
                         &VisualizationDragDropContainer::startDrag);
             }
-            void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
+            void VisualizationDragDropContainer::addAcceptedMimeType(
+                const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
             {
-                impl->m_AcceptedMimeTypes = mimeTypes;
+                impl->m_AcceptedMimeTypes[mimeType] = behavior;
-            void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
-                impl->m_MergeAllowedMimeTypes = mimeTypes;
             }
             int VisualizationDragDropContainer::countDragWidget() const
                             }
                         }
-                        auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                        auto canMerge = impl->allowMergeForMimeData(event->mimeData());
-                        impl->findPlaceHolderPosition(event->pos(), canMerge, this);
+                        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+                        impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                     }
                     else {
                         // do nothing
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
-                    auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                    auto canMerge = impl->allowMergeForMimeData(event->mimeData());
-                    impl->findPlaceHolderPosition(event->pos(), canMerge, this);
+                    auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+                    impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                 }
                 else {
                     event->ignore();
                     if (impl->hasPlaceHolder()) {
                         // drop where the placeHolder is located
+                        auto canInsert = impl->allowInsertForMimeData(event->mimeData());
+                        if (canInsert) {
                             auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
                             if (dragWidget) {
                             emit dropOccuredInContainer(droppedIndex, event->mimeData());
                         }
+                        else {
+                            qCWarning(LOG_VisualizationDragDropContainer()) << tr(
+                                "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
+                                "the insertion is forbidden.");
+                            Q_ASSERT(false);
+                        }
+                    }
                     else if (helper.getHightlightedDragWidget()) {
                         // drop on the highlighted widget
-                        auto canMerge = impl->allowMergeMimeData(event->mimeData());
+                        auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         if (canMerge) {
                             event->acceptProposedAction();
                             emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
             void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
-                const QPoint &pos, bool canMerge, const VisualizationDragDropContainer *container)
+                const QPoint &pos, bool canInsert, bool canMerge,
+                const VisualizationDragDropContainer *container)
             {
                 auto &helper = sqpApp->dragDropHelper();
                         auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
-                        if (isOnTop || isOnBottom || !canMerge) {
+                        if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
                             if (isOnBottom) {
                                 dropIndex += 1;
                             }
                             helper.setHightlightedDragWidget(dragWidgetHovered);
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
-                            << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
+                                << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
+                                      "action.");
+                            Q_ASSERT(false);
+                        }
+                    }
+                    else {
+                        qCWarning(LOG_VisualizationDragDropContainer()) << tr(
+                            "VisualizationDragDropContainer::findPlaceHolderPosition, no widget found in the "
                             "container");
                     }
                 }
-                else if (!hasPlaceHolder()) {
+                else if (!hasPlaceHolder() && canInsert) {
                     // Drop on an empty container, just add the placeHolder at the top
                     helper.insertPlaceHolder(m_Layout, 0);
                 }

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

             {
                 ui->setupUi(this);
-                ui->dragDropContainer->setAcceptedMimeTypes(
+                ui->dragDropContainer->addAcceptedMimeType(
-                    {MIME_TYPE_GRAPH, MIME_TYPE_ZONE, MIME_TYPE_VARIABLE_LIST});
+                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
-                connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
+                ui->dragDropContainer->addAcceptedMimeType(
-                        &VisualizationTabWidget::dropMimeData);
+                    MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
+                ui->dragDropContainer->addAcceptedMimeType(
+                    MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
+                connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
+                        &VisualizationTabWidget::dropMimeData);
                 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed

gui/src/Visualization/VisualizationZoneWidget.cpp +10 -7

                 ui->zoneNameLabel->setText(name);
-                ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
+                ui->dragDropContainer->addAcceptedMimeType(
-                ui->dragDropContainer->setMergeAllowedMimeTypes({MIME_TYPE_VARIABLE_LIST});
+                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
+                ui->dragDropContainer->addAcceptedMimeType(
+                    MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
+                ui->dragDropContainer->addAcceptedMimeType(
+                    MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
-                if (const auto firstGraph = impl->firstGraph(this)) {
-                    auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
-                    mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 return mimeData;
             }
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
+                else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
+                    auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
+                    graphWidget->setGraphRange(range);
+                }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");

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