Implement pen_clear block

src/blocks/penblocks.cpp

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/sprite.h>
+
 #include "penblocks.h"
+#include "penlayer.h"
+#include "spritemodel.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
@@ -12,4 +17,23 @@ std::string PenBlocks::name() const
 
 void PenBlocks::registerBlocks(IEngine *engine)
 {
+ // Blocks
+ engine->addCompileFunction(this, "pen_clear", &compileClear);
+}
+
+void PenBlocks::compileClear(Compiler *compiler)
+{
+ compiler->addFunctionCall(&clear);
+}
+
+unsigned int PenBlocks::clear(VirtualMachine *vm)
+{
+ IPenLayer *penLayer = PenLayer::getProjectPenLayer(vm->engine());
+
+ if (penLayer) {
+ penLayer->clear();
+ vm->engine()->requestRedraw();
+ }
+
+ return 0;
 }

src/blocks/penblocks.h

@@ -17,6 +17,10 @@ class PenBlocks : public libscratchcpp::IBlockSection
  std::string name() const override;
 
  void registerBlocks(libscratchcpp::IEngine *engine) override;
+
+ static void compileClear(libscratchcpp::Compiler *compiler);
+
+ static unsigned int clear(libscratchcpp::VirtualMachine *vm);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -1,14 +1,18 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
+#include <penlayer.h>
 #include <blocks/penblocks.h>
 #include <enginemock.h>
+#include <penlayermock.h>
 
 #include "../common.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 class PenBlocksTest : public testing::Test
 {
  public:
@@ -38,5 +42,45 @@ TEST_F(PenBlocksTest, CategoryVisible)
 
 TEST_F(PenBlocksTest, RegisterBlocks)
 {
+ // Blocks
+ EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_clear", &PenBlocks::compileClear));
+
  m_section->registerBlocks(&m_engineMock);
 }
+
+TEST_F(PenBlocksTest, Clear)
+{
+ Compiler compiler(&m_engineMock);
+
+ auto block = std::make_shared<Block>("a", "pen_clear");
+
+ EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::clear)).WillOnce(Return(2));
+ compiler.init();
+ compiler.setBlock(block);
+ PenBlocks::compileClear(&compiler);
+ compiler.end();
+
+ ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT }));
+ ASSERT_TRUE(compiler.constValues().empty());
+ ASSERT_TRUE(compiler.variables().empty());
+ ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(PenBlocksTest, ClearImpl)
+{
+ static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+ static BlockFunc functions[] = { &PenBlocks::clear };
+
+ PenLayerMock penLayer;
+ PenLayer::addPenLayer(&m_engineMock, &penLayer);
+
+ VirtualMachine vm(nullptr, &m_engineMock, nullptr);
+ vm.setBytecode(bytecode);
+ vm.setFunctions(functions);
+
+ EXPECT_CALL(penLayer, clear());
+ EXPECT_CALL(m_engineMock, requestRedraw());
+ vm.run();
+
+ ASSERT_EQ(vm.registerCount(), 0);
+}