Merge pull request #433 from scratchcpp/complete_monitors

Complete the monitor 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,8 @@ enum class ScratchVersion
 
 class VirtualMachine;
 class Compiler;
+class Block;
+class Value;
 
 /*!
  * \typedef BlockFunc
@@ -44,6 +48,20 @@ 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 *);
+
+/*!
+ * \typedef MonitorChangeFunc
+ *
+ * MonitorChangeFunc is a function pointer for functions which are used to change monitor values.
+ */
+using MonitorChangeFunc = void (*)(Block *, const Value &newValue);
+
 } // namespace libscratchcpp
 
 #endif // LIBSCRATCHCPP_GLOBAL_H

include/scratchcpp/iengine.h

@@ -217,6 +217,18 @@ 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 monitor value change function to a block section.
+         * \see <a href="blockSections.html">Block sections</a>
+         */
+        virtual void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc 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);
 
@@ -54,6 +56,9 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
 
         void updateValue(const VirtualMachine *vm);
 
+        void setValueChangeFunction(MonitorChangeFunc f);
+        void changeValue(const Value &newValue);
+
         unsigned int width() const;
         void setWidth(unsigned int width);
 

src/blocks/listblocks.cpp

@@ -3,6 +3,8 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/list.h>
 
 #include "listblocks.h"
 
@@ -32,6 +34,9 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_lengthoflist", &compileLengthOfList);
     engine->addCompileFunction(this, "data_listcontainsitem", &compileListContainsItem);
 
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_listcontents", &listContentsMonitorName);
+
     // Inputs
     engine->addInput(this, "ITEM", ITEM);
     engine->addInput(this, "INDEX", INDEX);
@@ -101,3 +106,15 @@ void ListBlocks::compileListContainsItem(Compiler *compiler)
     compiler->addInput(ITEM);
     compiler->addInstruction(vm::OP_LIST_CONTAINS, { compiler->listIndex(compiler->field(LIST)->valuePtr()) });
 }
+
+const std::string &ListBlocks::listContentsMonitorName(Block *block)
+{
+    List *list = dynamic_cast<List *>(block->findFieldById(LIST)->valuePtr().get());
+
+    if (list)
+        return list->name();
+    else {
+        static const std::string empty = "";
+        return empty;
+    }
+}

src/blocks/listblocks.h

@@ -40,6 +40,8 @@ class ListBlocks : public IBlockSection
         static void compileLengthOfList(Compiler *compiler);
         static void compileListContainsItem(Compiler *compiler);
 
+        static const std::string &listContentsMonitorName(Block *block);
+
     private:
         static int validateIndex(size_t index, size_t listLength);
 };

src/blocks/looksblocks.cpp

@@ -7,6 +7,7 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/scratchconfiguration.h>
 
 #include "looksblocks.h"
@@ -42,6 +43,11 @@ void LooksBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "looks_costumenumbername", &compileCostumeNumberName);
     engine->addCompileFunction(this, "looks_backdropnumbername", &compileBackdropNumberName);
 
+    // Monitor names
+    engine->addMonitorNameFunction(this, "looks_costumenumbername", &costumeNumberNameMonitorName);
+    engine->addMonitorNameFunction(this, "looks_backdropnumbername", &backdropNumberNameMonitorName);
+    engine->addMonitorNameFunction(this, "looks_size", &sizeMonitorName);
+
     // Inputs
     engine->addInput(this, "CHANGE", CHANGE);
     engine->addInput(this, "SIZE", SIZE);
@@ -459,6 +465,56 @@ void LooksBlocks::compileBackdropNumberName(Compiler *compiler)
     }
 }
 
+const std::string &LooksBlocks::costumeNumberNameMonitorName(Block *block)
+{
+    int option = block->findFieldById(NUMBER_NAME)->specialValueId();
+
+    switch (option) {
+        case Number: {
+            static const std::string name = "costume number";
+            return name;
+        }
+
+        case Name: {
+            static const std::string name = "costume name";
+            return name;
+        }
+
+        default: {
+            static const std::string name = "";
+            return name;
+        }
+    }
+}
+
+const std::string &LooksBlocks::backdropNumberNameMonitorName(Block *block)
+{
+    int option = block->findFieldById(NUMBER_NAME)->specialValueId();
+
+    switch (option) {
+        case Number: {
+            static const std::string name = "backdrop number";
+            return name;
+        }
+
+        case Name: {
+            static const std::string name = "backdrop name";
+            return name;
+        }
+
+        default: {
+            static const std::string name = "";
+            return name;
+        }
+    }
+}
+
+const std::string &LooksBlocks::sizeMonitorName(Block *block)
+{
+    static const std::string name = "size";
+    return name;
+}
+
 unsigned int LooksBlocks::show(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/looksblocks.h

@@ -75,6 +75,10 @@ class LooksBlocks : public IBlockSection
         static void compileCostumeNumberName(Compiler *compiler);
         static void compileBackdropNumberName(Compiler *compiler);
 
+        static const std::string &costumeNumberNameMonitorName(Block *block);
+        static const std::string &backdropNumberNameMonitorName(Block *block);
+        static const std::string &sizeMonitorName(Block *block);
+
         static unsigned int show(VirtualMachine *vm);
         static unsigned int hide(VirtualMachine *vm);
 

src/blocks/motionblocks.cpp

@@ -45,6 +45,11 @@ void MotionBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "motion_yposition", &compileYPosition);
     engine->addCompileFunction(this, "motion_direction", &compileDirection);
 
+    // Monitor names
+    engine->addMonitorNameFunction(this, "motion_xposition", &xPositionMonitorName);
+    engine->addMonitorNameFunction(this, "motion_yposition", &yPositionMonitorName);
+    engine->addMonitorNameFunction(this, "motion_direction", &directionMonitorName);
+
     // Inputs
     engine->addInput(this, "STEPS", STEPS);
     engine->addInput(this, "DEGREES", DEGREES);
@@ -245,6 +250,24 @@ void MotionBlocks::compileDirection(Compiler *compiler)
     compiler->addFunctionCall(&direction);
 }
 
+const std::string &MotionBlocks::xPositionMonitorName(Block *block)
+{
+    static const std::string name = "x position";
+    return name;
+}
+
+const std::string &MotionBlocks::yPositionMonitorName(Block *block)
+{
+    static const std::string name = "y position";
+    return name;
+}
+
+const std::string &MotionBlocks::directionMonitorName(Block *block)
+{
+    static const std::string name = "direction";
+    return name;
+}
+
 unsigned int MotionBlocks::moveSteps(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/motionblocks.h

@@ -67,6 +67,10 @@ class MotionBlocks : public IBlockSection
         static void compileYPosition(Compiler *compiler);
         static void compileDirection(Compiler *compiler);
 
+        static const std::string &xPositionMonitorName(Block *block);
+        static const std::string &yPositionMonitorName(Block *block);
+        static const std::string &directionMonitorName(Block *block);
+
         static unsigned int moveSteps(VirtualMachine *vm);
         static unsigned int turnRight(VirtualMachine *vm);
         static unsigned int turnLeft(VirtualMachine *vm);

src/blocks/sensingblocks.cpp

@@ -10,6 +10,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/costume.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/block.h>
 #include "sensingblocks.h"
 
 #include "../engine/internal/clock.h"
@@ -38,6 +39,14 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sensing_current", &compileCurrent);
     engine->addCompileFunction(this, "sensing_dayssince2000", &compileDaysSince2000);
 
+    // Monitor names
+    engine->addMonitorNameFunction(this, "sensing_mousedown", &mouseDownMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_mousex", &mouseXMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_mousey", &mouseYMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_timer", &timerMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_current", &currentMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_dayssince2000", &daysSince2000MonitorName);
+
     // Inputs
     engine->addInput(this, "DISTANCETOMENU", DISTANCETOMENU);
     engine->addInput(this, "KEY_OPTION", KEY_OPTION);
@@ -310,6 +319,83 @@ void SensingBlocks::compileDaysSince2000(Compiler *compiler)
     compiler->addFunctionCall(&daysSince2000);
 }
 
+const std::string &SensingBlocks::mouseDownMonitorName(Block *block)
+{
+    static const std::string name = "mouse down?";
+    return name;
+}
+
+const std::string &SensingBlocks::mouseXMonitorName(Block *block)
+{
+    static const std::string name = "mouse x";
+    return name;
+}
+
+const std::string &SensingBlocks::mouseYMonitorName(Block *block)
+{
+    static const std::string name = "mouse y";
+    return name;
+}
+
+const std::string &SensingBlocks::timerMonitorName(Block *block)
+{
+    static const std::string name = "timer";
+    return name;
+}
+
+const std::string &SensingBlocks::currentMonitorName(Block *block)
+{
+    int id = block->findFieldById(CURRENTMENU)->specialValueId();
+
+    switch (id) {
+        case YEAR: {
+            static const std::string name = "year";
+            return name;
+        }
+
+        case MONTH: {
+            static const std::string name = "month";
+            return name;
+        }
+
+        case DATE: {
+            static const std::string name = "date";
+            return name;
+        }
+
+        case DAYOFWEEK: {
+            static const std::string name = "day of week";
+            return name;
+        }
+
+        case HOUR: {
+            static const std::string name = "hour";
+            return name;
+        }
+
+        case MINUTE: {
+            static const std::string name = "minute";
+            return name;
+        }
+
+        case SECOND: {
+            static const std::string name = "second";
+            return name;
+        }
+
+        default: {
+            static const std::string name = "";
+            return name;
+        }
+    }
+}
+
+const std::string &SensingBlocks::daysSince2000MonitorName(Block *block)
+{
+    static const std::string name = "days since 2000";
+    return name;
+}
+
 unsigned int SensingBlocks::keyPressed(VirtualMachine *vm)
 {
     vm->replaceReturnValue(vm->engine()->keyPressed(vm->getInput(0, 1)->toString()), 1);

src/blocks/sensingblocks.h

@@ -64,6 +64,13 @@ class SensingBlocks : public IBlockSection
         static void compileCurrent(Compiler *compiler);
         static void compileDaysSince2000(Compiler *compiler);
 
+        static const std::string &mouseDownMonitorName(Block *block);
+        static const std::string &mouseXMonitorName(Block *block);
+        static const std::string &mouseYMonitorName(Block *block);
+        static const std::string &timerMonitorName(Block *block);
+        static const std::string &currentMonitorName(Block *block);
+        static const std::string &daysSince2000MonitorName(Block *block);
+
         static unsigned int keyPressed(VirtualMachine *vm);
         static unsigned int mouseDown(VirtualMachine *vm);
         static unsigned int mouseX(VirtualMachine *vm);