Add MouseEventHandler class

adazem009 · adazem009 · commit 2527f4f2501b · 2023-12-25T01:15:41.000+01:00
diff --git a/ScratchCPPGui/CMakeLists.txt b/ScratchCPPGui/CMakeLists.txt
@@ -22,6 +22,8 @@ qt_add_qml_module(libscratchcpp-gui
         renderedtarget.h
 	targetpainter.cpp
 	targetpainter.h
+	mouseeventhandler.cpp
+	mouseeventhandler.h
 	keyeventhandler.cpp
 	keyeventhandler.h
 )
diff --git a/ScratchCPPGui/irenderedtarget.h b/ScratchCPPGui/irenderedtarget.h
@@ -53,6 +53,8 @@ class IRenderedTarget : public QNanoQuickItem
         virtual qreal height() const = 0;
         virtual void setHeight(qreal width) = 0;
 
+        virtual QPointF mapFromScene(const QPointF &point) const = 0;
+
         virtual QBuffer *bitmapBuffer() = 0;
         virtual const QString &bitmapUniqueKey() const = 0;
 
diff --git a/ScratchCPPGui/mouseeventhandler.cpp b/ScratchCPPGui/mouseeventhandler.cpp
@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include <QMouseEvent>
+#include <scratchcpp/target.h>
+
+#include "mouseeventhandler.h"
+#include "renderedtarget.h"
+
+using namespace scratchcppgui;
+
+MouseEventHandler::MouseEventHandler(QObject *parent) :
+    QObject(parent)
+{
+}
+
+IRenderedTarget *MouseEventHandler::stage() const
+{
+    return m_stage;
+}
+
+void MouseEventHandler::setStage(IRenderedTarget *stage)
+{
+    m_stage = stage;
+}
+
+QQuickItem *MouseEventHandler::spriteRepeater() const
+{
+    return m_spriteRepeater;
+}
+
+void MouseEventHandler::setSpriteRepeater(QQuickItem *repeater)
+{
+    m_spriteRepeater = repeater;
+}
+
+bool MouseEventHandler::eventFilter(QObject *obj, QEvent *event)
+{
+    switch (event->type()) {
+        case QEvent::HoverEnter:
+        case QEvent::HoverLeave:
+            forwardPointEvent(static_cast<QSinglePointEvent *>(event));
+            return true;
+
+        case QEvent::HoverMove:
+        case QEvent::MouseMove: {
+            QSinglePointEvent *pointEvent = static_cast<QSinglePointEvent *>(event);
+            forwardPointEvent(pointEvent);
+            QPointF pos = pointEvent->position();
+            emit mouseMoved(pos.x(), pos.y());
+            return true;
+        }
+
+        case QEvent::MouseButtonPress:
+            emit mousePressed();
+            forwardPointEvent(static_cast<QSinglePointEvent *>(event));
+            return true;
+
+        case QEvent::MouseButtonRelease:
+            emit mouseReleased();
+            forwardPointEvent(static_cast<QSinglePointEvent *>(event));
+            return true;
+
+        default:
+            break;
+    }
+
+    return QObject::eventFilter(obj, event);
+}
+
+void MouseEventHandler::forwardPointEvent(QSinglePointEvent *event)
+{
+    Q_ASSERT(m_spriteRepeater);
+
+    if (!m_spriteRepeater)
+        return;
+
+    // Create list of sprites
+    std::vector<IRenderedTarget *> sprites;
+    int count = m_spriteRepeater->property("count").toInt();
+    sprites.reserve(count);
+
+    for (int i = 0; i < count; i++) {
+        QQuickItem *sprite = nullptr;
+        QMetaObject::invokeMethod(m_spriteRepeater, "itemAt", Qt::DirectConnection, Q_RETURN_ARG(QQuickItem *, sprite), Q_ARG(int, i));
+        Q_ASSERT(sprite);
+        Q_ASSERT(dynamic_cast<IRenderedTarget *>(sprite));
+        Q_ASSERT(dynamic_cast<IRenderedTarget *>(sprite)->scratchTarget());
+        sprites.push_back(dynamic_cast<IRenderedTarget *>(sprite));
+    }
+
+    // Sort the list by layer order
+    std::sort(sprites.begin(), sprites.end(), [](IRenderedTarget *t1, IRenderedTarget *t2) { return t1->scratchTarget()->layerOrder() > t2->scratchTarget()->layerOrder(); });
+
+    // Send the event to the hovered sprite
+    for (IRenderedTarget *sprite : sprites) {
+        // contains() expects position in the item's coordinate system
+        QPointF localPos = sprite->mapFromScene(event->scenePosition());
+
+        if (sprite->contains(localPos)) {
+            sendPointEventToItem(event, sprite);
+            return;
+        }
+    }
+
+    // If there wasn't any hovered sprite, send the event to the stage
+    Q_ASSERT(m_stage);
+
+    if (m_stage)
+        sendPointEventToItem(event, m_stage);
+}
+
+void MouseEventHandler::sendPointEventToItem(QSinglePointEvent *event, QQuickItem *item)
+{
+    Q_ASSERT(event);
+    Q_ASSERT(item);
+    Q_ASSERT(m_stage);
+
+    switch (event->type()) {
+        case QEvent::HoverEnter:
+        case QEvent::HoverLeave:
+            QCoreApplication::sendEvent(item, event);
+            break;
+
+        case QEvent::HoverMove:
+            // Send HoverLeave to the previously hovered item and HoverEnter to the hovered item
+            if (item != m_hoveredItem) {
+                if (m_hoveredItem)
+                    sendHoverEventToItem(static_cast<QHoverEvent *>(event), QEvent::HoverLeave, m_hoveredItem);
+
+                sendHoverEventToItem(static_cast<QHoverEvent *>(event), QEvent::HoverEnter, item);
+                m_hoveredItem = item;
+            }
+
+            QCoreApplication::sendEvent(item, event);
+            break;
+
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        case QEvent::MouseMove: {
+            QMouseEvent itemEvent(
+                event->type(),
+                item->mapFromScene(event->scenePosition()),
+                event->scenePosition(),
+                event->globalPosition(),
+                event->button(),
+                event->buttons(),
+                event->modifiers(),
+                static_cast<const QPointingDevice *>(event->device()));
+
+            QCoreApplication::sendEvent(item, &itemEvent);
+            break;
+        }
+
+        default:
+            Q_ASSERT(false);
+            break;
+    }
+}
+
+void MouseEventHandler::sendHoverEventToItem(QHoverEvent *originalEvent, QEvent::Type newType, QQuickItem *item)
+{
+    Q_ASSERT(newType == QEvent::HoverEnter || newType == QEvent::HoverLeave || newType == QEvent::HoverMove);
+
+    QHoverEvent event(
+        newType,
+        originalEvent->scenePosition(),
+        originalEvent->globalPosition(),
+        originalEvent->oldPosF(),
+        originalEvent->modifiers(),
+        static_cast<const QPointingDevice *>(originalEvent->device()));
+
+    QCoreApplication::sendEvent(item, &event);
+}
diff --git a/ScratchCPPGui/mouseeventhandler.h b/ScratchCPPGui/mouseeventhandler.h
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <QObject>
+#include <QEvent>
+
+class QQuickItem;
+class QSinglePointEvent;
+class QHoverEvent;
+
+namespace scratchcppgui
+{
+
+class IRenderedTarget;
+
+class MouseEventHandler : public QObject
+{
+        Q_OBJECT
+    public:
+        explicit MouseEventHandler(QObject *parent = nullptr);
+
+        IRenderedTarget *stage() const;
+        void setStage(IRenderedTarget *stage);
+
+        QQuickItem *spriteRepeater() const;
+        void setSpriteRepeater(QQuickItem *repeater);
+
+        bool eventFilter(QObject *obj, QEvent *event) override;
+
+    signals:
+        void mouseMoved(qreal x, qreal y);
+        void mousePressed();
+        void mouseReleased();
+
+    private:
+        void forwardPointEvent(QSinglePointEvent *event);
+        void sendPointEventToItem(QSinglePointEvent *event, QQuickItem *item);
+        void sendHoverEventToItem(QHoverEvent *originalEvent, QEvent::Type newType, QQuickItem *item);
+
+        IRenderedTarget *m_stage = nullptr;
+        QQuickItem *m_hoveredItem = nullptr;
+        QQuickItem *m_spriteRepeater = nullptr;
+};
+
+} // namespace scratchcppgui
diff --git a/ScratchCPPGui/renderedtarget.cpp b/ScratchCPPGui/renderedtarget.cpp
@@ -216,6 +216,11 @@ void RenderedTarget::setHeight(qreal height)
     QNanoQuickItem::setHeight(height);
 }
 
+QPointF RenderedTarget::mapFromScene(const QPointF &point) const
+{
+    return QNanoQuickItem::mapFromScene(point);
+}
+
 QNanoQuickItemPainter *RenderedTarget::createItemPainter() const
 {
     return new TargetPainter();
diff --git a/ScratchCPPGui/renderedtarget.h b/ScratchCPPGui/renderedtarget.h
@@ -48,6 +48,8 @@ class RenderedTarget : public IRenderedTarget
         qreal height() const override;
         void setHeight(qreal height) override;
 
+        QPointF mapFromScene(const QPointF &point) const override;
+
         QBuffer *bitmapBuffer() override;
         const QString &bitmapUniqueKey() const override;
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -26,3 +26,4 @@ add_subdirectory(targetpainter)
 add_subdirectory(target_models)
 add_subdirectory(projectscene)
 add_subdirectory(keyeventhandler)
+add_subdirectory(mouseeventhandler)
diff --git a/test/mocks/renderedtargetmock.h b/test/mocks/renderedtargetmock.h
@@ -33,6 +33,8 @@ class RenderedTargetMock : public IRenderedTarget
         MOCK_METHOD(qreal, height, (), (const, override));
         MOCK_METHOD(void, setHeight, (qreal), (override));
 
+        MOCK_METHOD(QPointF, mapFromScene, (const QPointF &), (const, override));
+
         MOCK_METHOD(QBuffer *, bitmapBuffer, (), (override));
         MOCK_METHOD(const QString &, bitmapUniqueKey, (), (const, override));
 
@@ -49,6 +51,12 @@ class RenderedTargetMock : public IRenderedTarget
 
         MOCK_METHOD(bool, contains, (const QPointF &), (const, override));
         MOCK_METHOD(QNanoQuickItemPainter *, createItemPainter, (), (const, override));
+        MOCK_METHOD(void, hoverEnterEvent, (QHoverEvent *), (override));
+        MOCK_METHOD(void, hoverLeaveEvent, (QHoverEvent *), (override));
+        MOCK_METHOD(void, hoverMoveEvent, (QHoverEvent *), (override));
+        MOCK_METHOD(void, mouseMoveEvent, (QMouseEvent *), (override));
+        MOCK_METHOD(void, mousePressEvent, (QMouseEvent *), (override));
+        MOCK_METHOD(void, mouseReleaseEvent, (QMouseEvent *), (override));
 };
 
 } // namespace scratchcppgui
diff --git a/test/mouseeventhandler/CMakeLists.txt b/test/mouseeventhandler/CMakeLists.txt
@@ -0,0 +1,19 @@
+add_executable(
+  mouseeventhandler_test
+  mouseeventhandler_test.cpp
+  fakerepeater.cpp
+  fakerepeater.h
+)
+
+target_link_libraries(
+  mouseeventhandler_test
+  GTest::gtest_main
+  GTest::gmock_main
+  libscratchcpp-gui
+  scratchcppgui_mocks
+  ${QT_LIBS}
+  Qt6::Test
+)
+
+add_test(mouseeventhandler_test)
+gtest_discover_tests(mouseeventhandler_test)
diff --git a/test/mouseeventhandler/fakerepeater.cpp b/test/mouseeventhandler/fakerepeater.cpp
@@ -0,0 +1,19 @@
+#include "fakerepeater.h"
+
+using namespace scratchcppgui;
+
+FakeRepeater::FakeRepeater(QQuickItem *parent) :
+    QQuickItem(parent)
+{
+}
+
+int FakeRepeater::count() const
+{
+    return items.size();
+}
+
+QQuickItem *FakeRepeater::itemAt(int index) const
+{
+    Q_ASSERT(index >= 0 && index < items.size());
+    return items[index];
+}
diff --git a/test/mouseeventhandler/fakerepeater.h b/test/mouseeventhandler/fakerepeater.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <QQuickItem>
+
+namespace scratchcppgui
+{
+
+class FakeRepeater : public QQuickItem
+{
+        Q_OBJECT
+        Q_PROPERTY(int count READ count)
+    public:
+        FakeRepeater(QQuickItem *parent = nullptr);
+
+        int count() const;
+        Q_INVOKABLE QQuickItem *itemAt(int index) const;
+
+        std::vector<QQuickItem *> items;
+};
+
+} // namespace scratchcppgui
diff --git a/test/mouseeventhandler/mouseeventhandler_test.cpp b/test/mouseeventhandler/mouseeventhandler_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ qt_add_qml_module(libscratchcpp-gui`
`22`	`22`	`renderedtarget.h`
`23`	`23`	`targetpainter.cpp`
`24`	`24`	`targetpainter.h`
	`25`	`+ mouseeventhandler.cpp`
	`26`	`+ mouseeventhandler.h`
`25`	`27`	`keyeventhandler.cpp`
`26`	`28`	`keyeventhandler.h`
`27`	`29`	`)`
Original file line number	Diff line number	Diff line change
`@@ -216,6 +216,11 @@ void RenderedTarget::setHeight(qreal height)`
`216`	`216`	`QNanoQuickItem::setHeight(height);`
`217`	`217`	`}`
`218`	`218`
	`219`	`+QPointF RenderedTarget::mapFromScene(const QPointF &point) const`
	`220`	`+{`
	`221`	`+ return QNanoQuickItem::mapFromScene(point);`
	`222`	`+}`
	`223`	`+`
`219`	`224`	`QNanoQuickItemPainter *RenderedTarget::createItemPainter() const`
`220`	`225`	`{`
`221`	`226`	`return new TargetPainter();`