Merge pull request #55 from scratchcpp/sprite_dragging

adazem009 · web-flow · commit bc689dbbb3ee · 2023-12-25T14:05:40.000+01:00
Implement sprite dragging
diff --git a/ScratchCPPGui/ProjectPlayer.qml b/ScratchCPPGui/ProjectPlayer.qml
@@ -47,6 +47,7 @@ ProjectScene {
         id: stageTarget
         engine: loader.engine
         stageModel: loader.stage
+        mouseArea: sceneMouseArea
         onStageModelChanged: stageModel.renderedTarget = this
     }
 
@@ -66,6 +67,7 @@ ProjectScene {
             id: target
             engine: loader.engine
             spriteModel: modelData
+            mouseArea: sceneMouseArea
             transform: Scale { xScale: mirrorHorizontally ? -1 : 1 }
             Component.onCompleted: modelData.renderedTarget = this
         }
@@ -112,7 +114,7 @@ ProjectScene {
     }
 
     SceneMouseArea {
-        id: mouseArea
+        id: sceneMouseArea
         anchors.fill: parent
         stage: stageTarget
         spriteRepeater: sprites
diff --git a/ScratchCPPGui/irenderedtarget.h b/ScratchCPPGui/irenderedtarget.h
@@ -21,6 +21,7 @@ namespace scratchcppgui
 
 class StageModel;
 class SpriteModel;
+class SceneMouseArea;
 
 class IRenderedTarget : public QNanoQuickItem
 {
@@ -47,6 +48,9 @@ class IRenderedTarget : public QNanoQuickItem
 
         virtual libscratchcpp::Target *scratchTarget() const = 0;
 
+        virtual SceneMouseArea *mouseArea() const = 0;
+        virtual void setMouseArea(SceneMouseArea *newMouseArea) = 0;
+
         virtual qreal width() const = 0;
         virtual void setWidth(qreal width) = 0;
 
diff --git a/ScratchCPPGui/mouseeventhandler.cpp b/ScratchCPPGui/mouseeventhandler.cpp
@@ -57,7 +57,13 @@ bool MouseEventHandler::eventFilter(QObject *obj, QEvent *event)
 
         case QEvent::MouseButtonRelease:
             emit mouseReleased();
-            forwardPointEvent(static_cast<QSinglePointEvent *>(event));
+
+            if (m_clickedItem) {
+                sendPointEventToItem(static_cast<QSinglePointEvent *>(event), m_clickedItem);
+                m_clickedItem = nullptr;
+            } else
+                forwardPointEvent(static_cast<QSinglePointEvent *>(event));
+
             return true;
 
         default:
@@ -137,6 +143,9 @@ void MouseEventHandler::sendPointEventToItem(QSinglePointEvent *event, QQuickIte
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::MouseMove: {
+            if (event->type() == QEvent::MouseButtonPress)
+                m_clickedItem = item;
+
             QMouseEvent itemEvent(
                 event->type(),
                 item->mapFromScene(event->scenePosition()),
diff --git a/ScratchCPPGui/mouseeventhandler.h b/ScratchCPPGui/mouseeventhandler.h
@@ -40,6 +40,7 @@ class MouseEventHandler : public QObject
 
         IRenderedTarget *m_stage = nullptr;
         QQuickItem *m_hoveredItem = nullptr;
+        QQuickItem *m_clickedItem = nullptr;
         QQuickItem *m_spriteRepeater = nullptr;
 };
 
diff --git a/ScratchCPPGui/renderedtarget.cpp b/ScratchCPPGui/renderedtarget.cpp
@@ -9,6 +9,7 @@
 #include "targetpainter.h"
 #include "stagemodel.h"
 #include "spritemodel.h"
+#include "scenemousearea.h"
 
 using namespace scratchcppgui;
 using namespace libscratchcpp;
@@ -196,6 +197,22 @@ Target *RenderedTarget::scratchTarget() const
         return nullptr;
 }
 
+SceneMouseArea *RenderedTarget::mouseArea() const
+{
+    return m_mouseArea;
+}
+
+void RenderedTarget::setMouseArea(SceneMouseArea *newMouseArea)
+{
+    if (m_mouseArea == newMouseArea)
+        return;
+
+    m_mouseArea = newMouseArea;
+    Q_ASSERT(m_mouseArea);
+    connect(m_mouseArea, &SceneMouseArea::mouseMoved, this, &RenderedTarget::handleSceneMouseMove);
+    emit mouseAreaChanged();
+}
+
 qreal RenderedTarget::width() const
 {
     return QNanoQuickItem::width();
@@ -226,6 +243,39 @@ QNanoQuickItemPainter *RenderedTarget::createItemPainter() const
     return new TargetPainter();
 }
 
+void RenderedTarget::mousePressEvent(QMouseEvent *event)
+{
+    m_clicked = true;
+}
+
+void RenderedTarget::mouseReleaseEvent(QMouseEvent *event)
+{
+    m_clicked = false;
+    Q_ASSERT(m_mouseArea);
+
+    // Stop dragging
+    if (m_mouseArea->draggedSprite() == this)
+        m_mouseArea->setDraggedSprite(nullptr);
+}
+
+void RenderedTarget::mouseMoveEvent(QMouseEvent *event)
+{
+    Q_ASSERT((m_spriteModel && m_spriteModel->sprite()) || m_stageModel);
+    Q_ASSERT(m_mouseArea);
+
+    // Start dragging
+    if (m_clicked && !m_mouseArea->draggedSprite() && m_spriteModel && m_spriteModel->sprite()->draggable()) {
+        Q_ASSERT(m_engine);
+        Sprite *sprite = m_spriteModel->sprite();
+        m_dragDeltaX = m_engine->mouseX() - sprite->x();
+        m_dragDeltaY = m_engine->mouseY() - sprite->y();
+        m_mouseArea->setDraggedSprite(this);
+
+        // Move the sprite to the front layer
+        m_engine->moveSpriteToFront(sprite);
+    }
+}
+
 void RenderedTarget::updateCostumeData()
 {
     // Costume
@@ -399,6 +449,19 @@ void RenderedTarget::calculateSize(Target *target, double costumeWidth, double c
     }
 }
 
+void RenderedTarget::handleSceneMouseMove(qreal x, qreal y)
+{
+    Q_ASSERT(m_mouseArea);
+
+    if (m_mouseArea->draggedSprite() == this) {
+        Q_ASSERT(m_spriteModel && m_spriteModel->sprite());
+        Q_ASSERT(m_engine);
+        Sprite *sprite = m_spriteModel->sprite();
+        sprite->setX(x - m_engine->stageWidth() / 2.0 - m_dragDeltaX);
+        sprite->setY(-y + m_engine->stageHeight() / 2.0 - m_dragDeltaY);
+    }
+}
+
 QBuffer *RenderedTarget::bitmapBuffer()
 {
     return &m_bitmapBuffer;
diff --git a/ScratchCPPGui/renderedtarget.h b/ScratchCPPGui/renderedtarget.h
@@ -11,6 +11,7 @@
 
 Q_MOC_INCLUDE("stagemodel.h");
 Q_MOC_INCLUDE("spritemodel.h");
+Q_MOC_INCLUDE("scenemousearea.h");
 
 namespace scratchcppgui
 {
@@ -23,6 +24,7 @@ class RenderedTarget : public IRenderedTarget
         Q_PROPERTY(StageModel *stageModel READ stageModel WRITE setStageModel NOTIFY stageModelChanged)
         Q_PROPERTY(SpriteModel *spriteModel READ spriteModel WRITE setSpriteModel NOTIFY spriteModelChanged)
         Q_PROPERTY(bool mirrorHorizontally READ mirrorHorizontally NOTIFY mirrorHorizontallyChanged)
+        Q_PROPERTY(SceneMouseArea *mouseArea READ mouseArea WRITE setMouseArea NOTIFY mouseAreaChanged)
 
     public:
         RenderedTarget(QNanoQuickItem *parent = nullptr);
@@ -42,6 +44,9 @@ class RenderedTarget : public IRenderedTarget
 
         libscratchcpp::Target *scratchTarget() const override;
 
+        SceneMouseArea *mouseArea() const override;
+        void setMouseArea(SceneMouseArea *newMouseArea) override;
+
         qreal width() const override;
         void setWidth(qreal width) override;
 
@@ -70,21 +75,26 @@ class RenderedTarget : public IRenderedTarget
         void engineChanged();
         void stageModelChanged();
         void spriteModelChanged();
-
+        void mouseAreaChanged();
         void mirrorHorizontallyChanged();
 
     protected:
         QNanoQuickItemPainter *createItemPainter() const override;
+        void mousePressEvent(QMouseEvent *event) override;
+        void mouseReleaseEvent(QMouseEvent *event) override;
+        void mouseMoveEvent(QMouseEvent *event) override;
 
     private:
         void updateCostumeData();
         void doLoadCostume();
         void calculateSize(libscratchcpp::Target *target, double costumeWidth, double costumeHeight);
+        void handleSceneMouseMove(qreal x, qreal y);
 
         libscratchcpp::IEngine *m_engine = nullptr;
         libscratchcpp::Costume *m_costume = nullptr;
         StageModel *m_stageModel = nullptr;
         SpriteModel *m_spriteModel = nullptr;
+        SceneMouseArea *m_mouseArea = nullptr;
         QSvgRenderer m_svgRenderer;
         QBuffer m_bitmapBuffer;
         QString m_bitmapUniqueKey;
@@ -109,6 +119,9 @@ class RenderedTarget : public IRenderedTarget
         qreal m_maximumWidth = std::numeric_limits<double>::infinity();
         qreal m_maximumHeight = std::numeric_limits<double>::infinity();
         std::vector<QPointF> m_hullPoints;
+        bool m_clicked = false;
+        double m_dragDeltaX = 0;
+        double m_dragDeltaY = 0;
 };
 
 } // namespace scratchcppgui
diff --git a/ScratchCPPGui/scenemousearea.cpp b/ScratchCPPGui/scenemousearea.cpp
@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
+#include <scratchcpp/sprite.h>
+
 #include "scenemousearea.h"
 #include "mouseeventhandler.h"
 
@@ -40,3 +42,14 @@ void SceneMouseArea::setSpriteRepeater(QQuickItem *newSpriteRepeater)
     m_mouseHandler->setSpriteRepeater(newSpriteRepeater);
     emit spriteRepeaterChanged();
 }
+
+IRenderedTarget *SceneMouseArea::draggedSprite() const
+{
+    return m_draggedSprite;
+}
+
+void SceneMouseArea::setDraggedSprite(IRenderedTarget *sprite)
+{
+    Q_ASSERT(sprite);
+    m_draggedSprite = sprite;
+}
diff --git a/ScratchCPPGui/scenemousearea.h b/ScratchCPPGui/scenemousearea.h
@@ -26,6 +26,9 @@ class SceneMouseArea : public QQuickItem
         QQuickItem *spriteRepeater() const;
         void setSpriteRepeater(QQuickItem *newSpriteRepeater);
 
+        IRenderedTarget *draggedSprite() const;
+        void setDraggedSprite(IRenderedTarget *sprite);
+
     signals:
         void mouseMoved(qreal x, qreal y);
         void mousePressed();
@@ -35,6 +38,7 @@ class SceneMouseArea : public QQuickItem
 
     private:
         MouseEventHandler *m_mouseHandler = nullptr;
+        IRenderedTarget *m_draggedSprite = nullptr;
 };
 
 } // namespace scratchcppgui
diff --git a/test/mocks/renderedtargetmock.h b/test/mocks/renderedtargetmock.h
@@ -27,6 +27,9 @@ class RenderedTargetMock : public IRenderedTarget
 
         MOCK_METHOD(libscratchcpp::Target *, scratchTarget, (), (const, override));
 
+        MOCK_METHOD(SceneMouseArea *, mouseArea, (), (const, override));
+        MOCK_METHOD(void, setMouseArea, (SceneMouseArea *), (override));
+
         MOCK_METHOD(qreal, width, (), (const, override));
         MOCK_METHOD(void, setWidth, (qreal), (override));
 
diff --git a/test/mouseeventhandler/mouseeventhandler_test.cpp b/test/mouseeventhandler/mouseeventhandler_test.cpp
@@ -303,17 +303,32 @@ TEST(MouseEventHandlerTest, MousePressReleaseEvent)
     pressedSpy.clear();
     releasedSpy.clear();
 
-    // Send to stage (press)
+    // Send release (should be sent to sprite 1)
+    EXPECT_CALL(renderedTarget1, mouseReleaseEvent(_)).WillOnce(WithArgs<0>(Invoke(checkReleaseEvent)));
+    ASSERT_TRUE(handler.eventFilter(nullptr, &releaseEvent));
+    ASSERT_EQ(pressedSpy.count(), 0);
+    ASSERT_EQ(releasedSpy.count(), 1);
+    pressedSpy.clear();
+    releasedSpy.clear();
+
+    // Send to sprite 1 (press)
     EXPECT_CALL(renderedTarget3, contains(localPos)).WillOnce(Return(false));
-    EXPECT_CALL(renderedTarget1, contains(localPos)).WillOnce(Return(false));
-    EXPECT_CALL(renderedTarget2, contains(localPos)).WillOnce(Return(false));
-    EXPECT_CALL(stage, mousePressEvent(_)).WillOnce(WithArgs<0>(Invoke(checkPressEvent)));
+    EXPECT_CALL(renderedTarget1, contains(localPos)).WillOnce(Return(true));
+    EXPECT_CALL(renderedTarget1, mousePressEvent(_)).WillOnce(WithArgs<0>(Invoke(checkPressEvent)));
     ASSERT_TRUE(handler.eventFilter(nullptr, &pressEvent));
     ASSERT_EQ(pressedSpy.count(), 1);
     ASSERT_EQ(releasedSpy.count(), 0);
     pressedSpy.clear();
     releasedSpy.clear();
 
+    // Send release (should be sent to sprite 1)
+    EXPECT_CALL(renderedTarget1, mouseReleaseEvent(_)).WillOnce(WithArgs<0>(Invoke(checkReleaseEvent)));
+    ASSERT_TRUE(handler.eventFilter(nullptr, &releaseEvent));
+    ASSERT_EQ(pressedSpy.count(), 0);
+    ASSERT_EQ(releasedSpy.count(), 1);
+    pressedSpy.clear();
+    releasedSpy.clear();
+
     // Send to sprite 1 (release)
     EXPECT_CALL(renderedTarget3, contains(localPos)).WillOnce(Return(false));
     EXPECT_CALL(renderedTarget1, contains(localPos)).WillOnce(Return(true));
@@ -324,10 +339,18 @@ TEST(MouseEventHandlerTest, MousePressReleaseEvent)
     pressedSpy.clear();
     releasedSpy.clear();
 
-    // Send to stage (release)
+    // Send to stage (press)
     EXPECT_CALL(renderedTarget3, contains(localPos)).WillOnce(Return(false));
     EXPECT_CALL(renderedTarget1, contains(localPos)).WillOnce(Return(false));
     EXPECT_CALL(renderedTarget2, contains(localPos)).WillOnce(Return(false));
+    EXPECT_CALL(stage, mousePressEvent(_)).WillOnce(WithArgs<0>(Invoke(checkPressEvent)));
+    ASSERT_TRUE(handler.eventFilter(nullptr, &pressEvent));
+    ASSERT_EQ(pressedSpy.count(), 1);
+    ASSERT_EQ(releasedSpy.count(), 0);
+    pressedSpy.clear();
+    releasedSpy.clear();
+
+    // Send release (should be sent to stage)
     EXPECT_CALL(stage, mouseReleaseEvent(_)).WillOnce(WithArgs<0>(Invoke(checkReleaseEvent)));
     ASSERT_TRUE(handler.eventFilter(nullptr, &releaseEvent));
     ASSERT_EQ(pressedSpy.count(), 0);
diff --git a/test/renderedtarget/renderedtarget_test.cpp b/test/renderedtarget/renderedtarget_test.cpp
@@ -5,6 +5,7 @@
 #include <renderedtarget.h>
 #include <stagemodel.h>
 #include <spritemodel.h>
+#include <scenemousearea.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/costume.h>
@@ -592,3 +593,13 @@ TEST_F(RenderedTargetTest, ScratchTarget)
     target.setSpriteModel(&spriteModel);
     ASSERT_EQ(target.scratchTarget(), &sprite);
 }
+
+TEST_F(RenderedTargetTest, MouseArea)
+{
+    RenderedTarget target;
+    ASSERT_EQ(target.mouseArea(), nullptr);
+
+    SceneMouseArea mouseArea;
+    target.setMouseArea(&mouseArea);
+    ASSERT_EQ(target.mouseArea(), &mouseArea);
+}
diff --git a/test/scenemousearea/scenemousearea_test.cpp b/test/scenemousearea/scenemousearea_test.cpp
@@ -37,3 +37,13 @@ TEST(SceneMouseAreaTest, SpriteRepeater)
     ASSERT_EQ(spy.count(), 1);
     ASSERT_EQ(mouseArea.spriteRepeater(), &item);
 }
+
+TEST(SceneMouseAreaTest, DraggedSprite)
+{
+    SceneMouseArea mouseArea;
+    ASSERT_EQ(mouseArea.draggedSprite(), nullptr);
+
+    RenderedTargetMock sprite;
+    mouseArea.setDraggedSprite(&sprite);
+    ASSERT_EQ(mouseArea.draggedSprite(), &sprite);
+}
