Add monitor name API

Author: adazem009

include/scratchcpp/global.h

@@ -17,6 +17,8 @@
 #define LIBSCRATCHCPP_EXPORT DECL_IMPORT
 #endif
 
+#include <string>
+
 /*! \brief The main namespace of the library. */
 namespace libscratchcpp
 {
@@ -29,6 +31,7 @@ enum class ScratchVersion
 
 class VirtualMachine;
 class Compiler;
+class Block;
 
 /*!
  * \typedef BlockFunc
@@ -44,6 +47,13 @@ using BlockFunc = unsigned int (*)(VirtualMachine *vm);
  */
 using BlockComp = void (*)(Compiler *);
 
+/*!
+ * \typedef MonitorNameFunc
+ *
+ * MonitorNameFunc is a function pointer for functions which are used to get monitor names.
+ */
+using MonitorNameFunc = const std::string &(*)(Block *);
+
 } // namespace libscratchcpp
 
 #endif // LIBSCRATCHCPP_GLOBAL_H

include/scratchcpp/iengine.h

@@ -217,6 +217,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
          */
         virtual void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) = 0;
 
+        /*!
+         * Call this from IBlockSection#registerBlocks() to add a monitor name function to a block section.
+         * \see <a href="blockSections.html">Block sections</a>
+         */
+        virtual void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) = 0;
+
         /*!
          * Call this from IBlockSection#registerBlocks() to add a hat block to a block section.
          * \see <a href="blockSections.html">Block sections</a>

include/scratchcpp/monitor.h

@@ -37,6 +37,8 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
 
         void setInterface(IMonitorHandler *iface);
 
+        const std::string &name() const;
+
         Mode mode() const;
         void setMode(Mode mode);
 

src/engine/internal/blocksectioncontainer.cpp

@@ -11,6 +11,11 @@ void BlockSectionContainer::addCompileFunction(const std::string &opcode, BlockC
     m_compileFunctions[opcode] = f;
 }
 
+void BlockSectionContainer::addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f)
+{
+    m_monitorNameFunctions[opcode] = f;
+}
+
 void BlockSectionContainer::addHatBlock(const std::string &opcode)
 {
     m_compileFunctions[opcode] = &dummyFunction;
@@ -38,6 +43,13 @@ BlockComp BlockSectionContainer::resolveBlockCompileFunc(const std::string &opco
     return nullptr;
 }
 
+MonitorNameFunc BlockSectionContainer::resolveMonitorNameFunc(const std::string &opcode) const
+{
+    if (m_monitorNameFunctions.count(opcode) == 1)
+        return m_monitorNameFunctions.at(opcode);
+    return nullptr;
+}
+
 int BlockSectionContainer::resolveInput(const std::string &name) const
 {
     if (m_inputs.count(name) == 1)

src/engine/internal/blocksectioncontainer.h

@@ -16,18 +16,21 @@ class BlockSectionContainer
         BlockSectionContainer(const BlockSectionContainer &) = delete;
 
         void addCompileFunction(const std::string &opcode, BlockComp f);
+        void addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f);
         void addHatBlock(const std::string &opcode);
         void addInput(const std::string &name, int id);
         void addField(const std::string &name, int id);
         void addFieldValue(const std::string &value, int id);
 
         BlockComp resolveBlockCompileFunc(const std::string &opcode) const;
+        MonitorNameFunc resolveMonitorNameFunc(const std::string &opcode) const;
         int resolveInput(const std::string &name) const;
         int resolveField(const std::string &name) const;
         int resolveFieldValue(const std::string &value) const;
 
     private:
         std::unordered_map<std::string, BlockComp> m_compileFunctions;
+        std::unordered_map<std::string, MonitorNameFunc> m_monitorNameFunctions;
         std::unordered_map<std::string, int> m_inputs;
         std::unordered_map<std::string, int> m_fields;
         std::unordered_map<std::string, int> m_fieldValues;

src/engine/internal/engine.cpp

@@ -226,6 +226,14 @@ void Engine::compile()
         Compiler compiler(this, target);
         auto block = monitor->block();
         auto section = blockSection(block->opcode());
+        auto container = blockSectionContainer(block->opcode());
+
+        if (container) {
+            MonitorNameFunc f = container->resolveMonitorNameFunc(block->opcode());
+
+            if (f)
+                monitor->impl->name = f(block.get());
+        }
 
         if (section) {
             auto script = std::make_shared<Script>(target, block, this);
@@ -804,6 +812,14 @@ void Engine::addCompileFunction(IBlockSection *section, const std::string &opcod
         container->addCompileFunction(opcode, f);
 }
 
+void Engine::addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f)
+{
+    auto container = blockSectionContainer(section);
+
+    if (container)
+        container->addMonitorNameFunction(opcode, f);
+}
+
 void Engine::addHatBlock(IBlockSection *section, const std::string &opcode)
 {
     auto container = blockSectionContainer(section);
@@ -1439,6 +1455,14 @@ void Engine::addVarOrListMonitor(std::shared_ptr<Monitor> monitor, Target *targe
         monitor->setSprite(dynamic_cast<Sprite *>(target));
 
     monitor->impl->blockSection = blockSection(monitor->opcode());
+    auto container = blockSectionContainer(monitor->opcode());
+
+    if (container) {
+        MonitorNameFunc f = container->resolveMonitorNameFunc(monitor->opcode());
+
+        if (f)
+            monitor->impl->name = f(monitor->block().get());
+    }
 
     // Auto-position the monitor
     Rect rect = Monitor::getInitialPosition(m_monitors, monitor->width(), monitor->height());

src/engine/internal/engine.h

@@ -102,6 +102,7 @@ class Engine : public IEngine
         unsigned int functionIndex(BlockFunc f) override;
 
         void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) override;
+        void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) override;
         void addHatBlock(IBlockSection *section, const std::string &opcode) override;
         void addInput(IBlockSection *section, const std::string &name, int id) override;
         void addField(IBlockSection *section, const std::string &name, int id) override;

src/scratch/monitor.cpp

@@ -32,6 +32,15 @@ void Monitor::setInterface(IMonitorHandler *iface)
         iface->init(this);
 }
 
+/*
+ * Returns the name of this monitor.
+ * \note Add the monitor to a project to initialize this property.
+ */
+const std::string &Monitor::name() const
+{
+    return impl->name;
+}
+
 /*! Returns the monitor's mode. */
 Monitor::Mode Monitor::mode() const
 {

src/scratch/monitor_p.h

@@ -17,6 +17,7 @@ struct MonitorPrivate
         MonitorPrivate(const MonitorPrivate &) = delete;
 
         IMonitorHandler *iface = nullptr;
+        std::string name;
         Monitor::Mode mode = Monitor::Mode::Default;
         std::shared_ptr<Script> script;
         std::shared_ptr<IBlockSection> blockSection;

test/engine/engine_test.cpp

@@ -123,6 +123,13 @@ TEST(EngineTest, CompileAndExecuteMonitors)
     engine.addCompileFunction(section.get(), m1->opcode(), [](Compiler *compiler) { compiler->addConstValue(5.4); });
     engine.addCompileFunction(section.get(), m2->opcode(), [](Compiler *compiler) { compiler->addConstValue("test"); });
 
+    engine.addMonitorNameFunction(section.get(), m1->opcode(), [](Block *block) -> const std::string & {
+        static const std::string testStr = "test";
+        return testStr;
+    });
+
+    engine.addMonitorNameFunction(section.get(), m2->opcode(), [](Block *block) -> const std::string & { return block->opcode(); });
+
     // Compile the monitor blocks
     engine.compile();
     auto script1 = m1->script();
@@ -142,6 +149,10 @@ TEST(EngineTest, CompileAndExecuteMonitors)
     ASSERT_EQ(m2->blockSection(), section);
     ASSERT_FALSE(m3->blockSection());
 
+    ASSERT_EQ(m1->name(), "test");
+    ASSERT_EQ(m2->name(), m2->opcode());
+    ASSERT_TRUE(m3->name().empty());
+
     // Execute the monitor blocks
     MonitorHandlerMock iface1, iface2, iface3;
     EXPECT_CALL(iface1, init);