GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1087:d404ba4b75e5

drag of selection zones

trabillard -

r1087:d404ba4b75e5

parent child

Context file:

r1087:d404ba4b75e5

core/include/Common/MimeTypesDef.h +1 0

             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_PRODUCT_LIST;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
+            extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_SELECTION_ZONE;
             #endif // SCIQLOP_MIMETYPESDEF_H

core/src/Common/MimeTypesDef.cpp +1 0

             const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("sciqlop/var-list");
             const QString MIME_TYPE_PRODUCT_LIST = QStringLiteral("sciqlop/product-list");
             const QString MIME_TYPE_TIME_RANGE = QStringLiteral("sciqlop/time-range");
+            const QString MIME_TYPE_SELECTION_ZONE = QStringLiteral("sciqlop/selection-zone");

gui/include/Visualization/VisualizationDragWidget.h +6 -2

             public:
                 VisualizationDragWidget(QWidget *parent = nullptr);
-                virtual QMimeData *mimeData() const = 0;
+                virtual QMimeData *mimeData(const QPoint &position) const = 0;
                 virtual bool isDragAllowed() const = 0;
-                virtual void highlightForMerge(bool highlighted) { Q_UNUSED(highlighted); };
+                virtual void highlightForMerge(bool highlighted) { Q_UNUSED(highlighted); }
+                /// Custom pixmap to display during a drag operation.
+                /// If the provided pixmap is null, a pixmap of the entire widget is used.
+                virtual QPixmap customDragPixmap(const QPoint &dragPosition);
             protected:
                 virtual void mousePressEvent(QMouseEvent *event) override;

gui/include/Visualization/VisualizationGraphWidget.h +3 -2

                 QString name() const override;
                 // VisualisationDragWidget
-                QMimeData *mimeData() const override;
+                QMimeData *mimeData(const QPoint &position) const override;
+                QPixmap customDragPixmap(const QPoint &dragPosition) override;
                 bool isDragAllowed() const override;
                 void highlightForMerge(bool highlighted) override;
                 void enterEvent(QEvent *event) override;
                 void leaveEvent(QEvent *event) override;
-                QCustomPlot &plot() noexcept;
+                QCustomPlot &plot() const noexcept;
             private:
                 Ui::VisualizationGraphWidget *ui;

gui/include/Visualization/VisualizationZoneWidget.h +1 -1

                 QString name() const override;
                 // VisualisationDragWidget
-                QMimeData *mimeData() const override;
+                QMimeData *mimeData(const QPoint &position) const override;
                 bool isDragAllowed() const override;
                 void notifyMouseMoveInGraph(const QPointF &graphPosition, const QPointF &plotPosition,

gui/src/Visualization/VisualizationDragDropContainer.cpp +9 -2

                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
-                auto mimeData = dragWidget->mimeData();
+                auto mimeData = dragWidget->mimeData(dragPosition);
                 drag->setMimeData(mimeData);
-                auto pixmap = QPixmap(dragWidget->size());
+                auto pixmap = dragWidget->customDragPixmap(dragPosition);
+                if (pixmap.isNull()) {
+                    pixmap = QPixmap{dragWidget->size()};
                     dragWidget->render(&pixmap);
+                }
                 drag->setPixmap(pixmap.scaled(DRAGGED_MINIATURE_WIDTH, DRAGGED_MINIATURE_WIDTH,
                                               Qt::KeepAspectRatio, Qt::SmoothTransformation));
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
+                    if (impl->acceptMimeData(mimeData) && impl->allowInsertForMimeData(mimeData)) {
                         helper.setCurrentDragWidget(dragWidget);
                         if (impl->cursorIsInContainer(this)) {
                             // The drag starts directly outside the drop zone
                             // do not add the placeHolder
                         }
+                    }
                     drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::MoveAction);

gui/src/Visualization/VisualizationDragWidget.cpp +6 0

             {
             }
+            virtual QPixmap VisualizationDragWidget::customDragPixmap(const QPoint &dragPosition)
+            {
+                Q_UNUSED(dragPosition);
+                return QPixmap();
+            }
             void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {

gui/src/Visualization/VisualizationGraphWidget.cpp +69 -19

             namespace {
+            /// Key pressed to enable drag&drop in all modes
+            const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
                     }
                 }
+                VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
+                                                                const QCustomPlot &plot) const
+                {
+                    VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
+                    auto minDistanceToZone = -1;
+                    for (auto zone : m_SelectionZones) {
+                        auto distanceToZone = zone->selectTest(pos, false);
+                        if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
+                            && distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
+                            selectionZoneItemUnderCursor = zone;
+                        }
+                    }
+                    return selectionZoneItemUnderCursor;
+                }
                 QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                 return impl->m_Name;
             }
-            QMimeData *VisualizationGraphWidget::mimeData() const
+            QMimeData *VisualizationGraphWidget::mimeData(const QPoint &position) const
             {
                 auto mimeData = new QMimeData;
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
+                if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
+                    && selectionZoneItemUnderCursor) {
+                    mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
+                                                                selectionZoneItemUnderCursor->range()));
+                    mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
+                                                                    selectionZoneItemUnderCursor->range()));
+                }
+                else {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
+                }
                 return mimeData;
             }
+            QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
+            {
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
+                if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
+                    && selectionZoneItemUnderCursor) {
+                    auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
+                    auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
+                    auto zoneSize = QSizeF{qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
+                                           qAbs(zoneBottomRight.y() - zoneTopLeft.y())}
+                                        .toSize();
+                    auto pixmap = QPixmap(zoneSize);
+                    render(&pixmap, QPoint(), QRegion{QRect{zoneTopLeft.toPoint(), zoneSize}});
+                    return pixmap;
+                }
+                return QPixmap();
+            }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
                 }
             }
-            QCustomPlot &VisualizationGraphWidget::plot() noexcept
+            QCustomPlot &VisualizationGraphWidget::plot() const noexcept
             {
                 return *ui->widget;
             }
                 }
                 // Search for the selection zone under the mouse
-                VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
+                auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
-                auto minDistanceToZone = -1;
-                for (auto zone : impl->m_SelectionZones) {
-                    auto distanceToZone = zone->selectTest(event->pos(), true);
-                    if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone) && distanceToZone >= 0
-                        && distanceToZone < plot().selectionTolerance()) {
-                        selectionZoneItemUnderCursor = zone;
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
+                bool isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
+                if (!isDragDropClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos(), plot());
                     }
-                else if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
+                    else if (sqpApp->plotsInteractionMode()
+                                 == SqpApplication::PlotsInteractionMode::SelectionZones
                              && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
-                    auto itemAtPos = plot().itemAt(event->pos(), true);
+                        auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
-                    if (!itemAtPos) {
+                        if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos(), plot());
                         }
                     }
+                }
                 else if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None) {
                     plot().setInteraction(QCP::iRangeDrag, true);
                 }
                 // Allows mouse panning only in default mode
                 plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
-                                                           == SqpApplication::PlotsInteractionMode::None);
+                                                               == SqpApplication::PlotsInteractionMode::None
+                                                           && !isDragDropClick);
-                // Allows zone edition only in selection zone mode
+                // Allows zone edition only in selection zone mode without ALT pressed (ALT is for drag&drop)
-                impl->setSelectionZonesEditionEnabled(sqpApp->plotsInteractionMode()
+                impl->setSelectionZonesEditionEnabled(
-                                                      == SqpApplication::PlotsInteractionMode::SelectionZones);
+                    sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
+                    && !isDragDropClick);
                 VisualizationDragWidget::mousePressEvent(event);
             }

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +2 -1

                 {
                     auto distanceLeft = m_LeftLine->selectTest(pos, false);
                     auto distanceRight = m_RightLine->selectTest(pos, false);
-                    auto distance = zoneItem->selectTest(pos, true);
+                    auto distance = zoneItem->selectTest(pos, false);
                     if (distanceRight <= distance) {
                         return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight;
                 setSelectable(value);
                 if (!value) {
                     setSelected(false);
+                    impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                 }
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +5 -1

                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
+                ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
+                                                   VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 return ui->zoneNameLabel->text();
             }
-            QMimeData *VisualizationZoneWidget::mimeData() const
+            QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
+                Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});

General Comments 3

trabillard

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

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