HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r840:8d32ce09be20

Manage the scroll of the tab QScrollArea during a drag&drop operation

trabillard -

r840:8d32ce09be20

parent child

Context file:

r840:8d32ce09be20

gui/include/DragDropHelper.h +25 0

             #ifndef DRAGDROPHELPER_H
             #define DRAGDROPHELPER_H
             #include <Common/spimpl.h>
             #include <QWidget>
             class QVBoxLayout;
             class QScrollArea;
             class VisualizationDragWidget;
             class QMimeData;
             /**
+             * @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();
+            };
+            /**
              * @brief Helper class for drag&drop operations.
              */
             class DragDropHelper
             {
             public:
                 DragDropHelper();
                 ~DragDropHelper();
                 static const QString MIME_TYPE_GRAPH;
                 static const QString MIME_TYPE_ZONE;
                 void setCurrentDragWidget(VisualizationDragWidget* dragWidget);
                 VisualizationDragWidget* getCurrentDragWidget() const;
                 QWidget &placeHolder() const;
                 void insertPlaceHolder(QVBoxLayout* layout, int index);
                 void removePlaceHolder();
                 bool isPlaceHolderSet() const;
                 void addDragDropScrollArea(QScrollArea* scrollArea);
                 void removeDragDropScrollArea(QScrollArea* scrollArea);
                 QUrl imageTemporaryUrl(const QImage& image) const;
             private:
                 class DragDropHelperPrivate;
                 spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
             };
             #endif // DRAGDROPHELPER_H

gui/src/DragDropHelper.cpp +143 0

             #include "DragDropHelper.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "SqpApplication.h"
             #include <QDragMoveEvent>
             #include <QDragEnterEvent>
             #include <QScrollBar>
             #include <QScrollArea>
             #include <QVBoxLayout>
             #include <QTimer>
             #include <QDir>
             const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
             const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
+            const int SCROLL_SPEED = 5;
+            const int SCROLL_ZONE_SIZE = 50;
+            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)
+                {
+                    auto w = static_cast<QWidget*>(obj);
+                    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)
+                {
+                    auto w = static_cast<QWidget*>(obj);
+                    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;
                 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.
                 explicit DragDropHelperPrivate()
                     : m_placeHolder{std::make_unique<QWidget>()},
                       m_dragDropScroller{std::make_unique<DragDropScroller>()}
                 {
                      m_placeHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
                      sqpApp->installEventFilter(m_dragDropScroller.get());
                      m_imageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
                 }
                 void preparePlaceHolder() const
                 {
                     if (m_currentDragWidget)
                     {
                         m_placeHolder->setMinimumSize(m_currentDragWidget->size());
                         m_placeHolder->setSizePolicy(m_currentDragWidget->sizePolicy());
                     }
                     else
                     {
                         m_placeHolder->setMinimumSize(200, 200);
                     }
                 }
             };
             DragDropHelper::DragDropHelper() :
                 impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
             {
             }
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_imageTempUrl);
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 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)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder();
                 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);
             }

gui/src/Visualization/VisualizationTabWidget.cpp +2 0

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "SqpApplication.h"
             #include "DragDropHelper.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this, &VisualizationTabWidget::dropMimeData);
+                sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
+                sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                  ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 auto& helper = sqpApp->dragDropHelper();
                 if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH))
                 {
                     auto graphWidget = static_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
                     auto parentDragDropContainer = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
                     Q_ASSERT(parentDragDropContainer);
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1)
                     {
                         //This is the only graph in the previous zone, close the zone
                         graphWidget->parentZoneWidget()->close();
                     }
                     else
                     {
                          //Close the graph
                         graphWidget->close();
                     }
                     const auto& variables = graphWidget->variables();
                     createZone(variables, index);
                 }
                 else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE))
                 {
                     //Simple move of the zone, no variable operation associated
                     auto zoneWidget = static_cast<VisualizationZoneWidget*>(helper.getCurrentDragWidget());
                     auto parentDragDropContainer = zoneWidget->parentWidget();
                     parentDragDropContainer->layout()->removeWidget(zoneWidget);
                     ui->dragDropContainer->insertDragWidget(index, zoneWidget);
                 }
             }

General Comments 0

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