Implement pen_clear block

Author: adazem009

src/blocks/penblocks.cpp

@@ -1,4 +1,9 @@
+#include <scratchcpp/iengine.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/executioncontext.h>
+
 #include "penblocks.h"
+#include "penlayer.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
@@ -20,4 +25,22 @@ Rgb PenBlocks::color() const
 
 void PenBlocks::registerBlocks(IEngine *engine)
 {
+    engine->addCompileFunction(this, "pen_clear", &compileClear);
+}
+
+CompilerValue *PenBlocks::compileClear(Compiler *compiler)
+{
+    compiler->addFunctionCallWithCtx("pen_clear");
+    return nullptr;
+}
+
+BLOCK_EXPORT void pen_clear(ExecutionContext *ctx)
+{
+    IEngine *engine = ctx->engine();
+    IPenLayer *penLayer = PenLayer::getProjectPenLayer(engine);
+
+    if (penLayer) {
+        penLayer->clear();
+        engine->requestRedraw();
+    }
 }

src/blocks/penblocks.h

@@ -11,6 +11,9 @@ class PenBlocks : public libscratchcpp::IExtension
         libscratchcpp::Rgb color() const override;
 
         void registerBlocks(libscratchcpp::IEngine *engine) override;
+
+    private:
+        static libscratchcpp::CompilerValue *compileClear(libscratchcpp::Compiler *compiler);
 };
 
 } // namespace scratchcpprender

src/penlayer.cpp

@@ -468,6 +468,11 @@ void PenLayer::addPenLayer(libscratchcpp::IEngine *engine, IPenLayer *penLayer)
     m_projectPenLayers[engine] = penLayer;
 }
 
+void PenLayer::removePenLayer(libscratchcpp::IEngine *engine)
+{
+    m_projectPenLayers.erase(engine);
+}
+
 QNanoQuickItemPainter *PenLayer::createItemPainter() const
 {
     m_glCtx = QOpenGLContext::currentContext();

src/penlayer.h

@@ -47,7 +47,10 @@ class PenLayer : public IPenLayer
         const libscratchcpp::Rect &getBounds() const override;
 
         static IPenLayer *getProjectPenLayer(libscratchcpp::IEngine *engine);
-        static void addPenLayer(libscratchcpp::IEngine *engine, IPenLayer *penLayer); // for tests
+
+        // For tests
+        static void addPenLayer(libscratchcpp::IEngine *engine, IPenLayer *penLayer);
+        static void removePenLayer(libscratchcpp::IEngine *engine);
 
     signals:
         void engineChanged();

test/blocks/pen_blocks_test.cpp

@@ -1,11 +1,22 @@
 #include <scratchcpp/project.h>
+#include <scratchcpp/sprite.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/script.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/test/scriptbuilder.h>
 #include <enginemock.h>
+#include <penlayermock.h>
 #include <gtest/gtest.h>
 
+#include "penlayer.h"
 #include "blocks/penblocks.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
+using namespace libscratchcpp::test;
+
+using ::testing::Return;
+using ::testing::ReturnRef;
 
 class PenBlocksTest : public testing::Test
 {
@@ -15,10 +26,47 @@ class PenBlocksTest : public testing::Test
             m_extension = std::make_unique<PenBlocks>();
             m_engine = m_project.engine().get();
             m_extension->registerBlocks(m_engine);
+
+            PenLayer::addPenLayer(&m_engineMock, &m_penLayer);
+
+            EXPECT_CALL(m_engineMock, targets()).WillRepeatedly(ReturnRef(m_engine->targets()));
+        }
+
+        void TearDown() override { PenLayer::removePenLayer(&m_engineMock); }
+
+        std::shared_ptr<Thread> buildScript(ScriptBuilder &builder, Target *target)
+        {
+            auto block = builder.currentBlock();
+
+            m_compiler = std::make_unique<Compiler>(&m_engineMock, target);
+            auto code = m_compiler->compile(block);
+            m_script = std::make_unique<Script>(target, block, &m_engineMock);
+            m_script->setCode(code);
+            return std::make_shared<Thread>(target, &m_engineMock, m_script.get());
         }
 
         std::unique_ptr<IExtension> m_extension;
         Project m_project;
         IEngine *m_engine = nullptr;
         EngineMock m_engineMock;
+        PenLayerMock m_penLayer;
+
+    private:
+        std::unique_ptr<Compiler> m_compiler;
+        std::unique_ptr<Script> m_script;
 };
+
+TEST_F(PenBlocksTest, Clear)
+{
+    auto sprite = std::make_shared<Sprite>();
+    sprite->setEngine(&m_engineMock);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, sprite);
+    builder.addBlock("pen_clear");
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_penLayer, clear());
+    EXPECT_CALL(m_engineMock, requestRedraw());
+    thread->run();
+}