Merge pull request #184 from scratchcpp/dropdown_menu_value

Support dropdown menus in Compiler

Author: adazem009

include/scratchcpp/input.h

@@ -45,6 +45,9 @@ class LIBSCRATCHCPP_EXPORT Input
         void setValueBlock(std::shared_ptr<Block> block);
         void setValueBlockId(const std::string &id);
 
+        bool pointsToDropdownMenu() const;
+        std::string selectedMenuItem() const;
+
     private:
         spimpl::unique_impl_ptr<InputPrivate> impl;
 };

src/engine/compiler.cpp

@@ -98,8 +98,14 @@ const std::vector<InputValue *> &Compiler::constInputValues() const
 std::vector<Value> Compiler::constValues() const
 {
     std::vector<Value> ret;
-    for (auto value : impl->constValues)
-        ret.push_back(value->value());
+    for (auto value : impl->constValues) {
+        const auto &menuInfo = impl->constValueMenuInfo.at(value);
+
+        if (menuInfo.first)
+            ret.push_back(menuInfo.second);
+        else
+            ret.push_back(value->value());
+    }
     return ret;
 }
 
@@ -139,7 +145,10 @@ void Compiler::addInput(Input *input)
     }
     switch (input->type()) {
         case Input::Type::Shadow:
-            addInstruction(OP_CONST, { constIndex(input->primaryValue()) });
+            if (input->pointsToDropdownMenu())
+                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue(), true, input->selectedMenuItem()) });
+            else
+                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
             break;
 
         case Input::Type::NoShadow: {
@@ -275,11 +284,7 @@ unsigned int Compiler::listIndex(std::shared_ptr<Entity> listEntity)
 /*! Returns the index of the given constant input value. */
 unsigned int Compiler::constIndex(InputValue *value)
 {
-    auto it = std::find(impl->constValues.begin(), impl->constValues.end(), value);
-    if (it != impl->constValues.end())
-        return it - impl->constValues.begin();
-    impl->constValues.push_back(value);
-    return impl->constValues.size() - 1;
+    return impl->constIndex(value);
 }
 
 /*! Returns the index of the procedure code of the given block. */

src/engine/compiler_p.cpp

@@ -20,6 +20,16 @@ void CompilerPrivate::addInstruction(vm::Opcode opcode, std::initializer_list<un
         bytecode.push_back(arg);
 }
 
+unsigned int CompilerPrivate::constIndex(InputValue *value, bool pointsToDropdownMenu, const std::string &selectedMenuItem)
+{
+    auto it = std::find(constValues.begin(), constValues.end(), value);
+    if (it != constValues.end())
+        return it - constValues.begin();
+    constValues.push_back(value);
+    constValueMenuInfo[value] = { pointsToDropdownMenu, selectedMenuItem };
+    return constValues.size() - 1;
+}
+
 void CompilerPrivate::substackEnd()
 {
     auto parent = substackTree.back();

src/engine/compiler_p.h

@@ -13,6 +13,8 @@ struct CompilerPrivate
 
         void addInstruction(vm::Opcode opcode, std::initializer_list<unsigned int> args = {});
 
+        unsigned int constIndex(InputValue *value, bool pointsToDropdownMenu = false, const std::string &selectedMenuItem = "");
+
         void substackEnd();
 
         IEngine *engine;
@@ -23,6 +25,7 @@ struct CompilerPrivate
 
         std::vector<unsigned int> bytecode;
         std::vector<InputValue *> constValues;
+        std::unordered_map<InputValue *, std::pair<bool, std::string>> constValueMenuInfo; // input value, <whether the input points to a dropdown menu, selected menu item>
         std::vector<Variable *> variables;
         std::vector<List *> lists;
         std::vector<std::string> procedures;

src/scratch/input.cpp

@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/block.h>
 
@@ -94,3 +95,35 @@ void Input::setValueBlockId(const std::string &id)
     impl->primaryValue.setValueBlock(nullptr);
     impl->primaryValue.setValueBlockId(id);
 }
+
+/*!
+ * Returns true if the input points to a dropdown menu.\n
+ * (if type() == Type::Shadow and valueBlock() points to a block with a single field which does not point to an entity)
+ */
+bool Input::pointsToDropdownMenu() const
+{
+    auto block = valueBlock();
+
+    if ((impl->type != Type::Shadow) || !block)
+        return false;
+
+    const auto &fields = block->fields();
+
+    if (fields.size() != 1)
+        return false;
+
+    auto field = fields[0];
+    return (field && !field->valuePtr() && (field->valueId() == ""));
+}
+
+/*!
+ * Returns the selected item in the dropdown menu.\n
+ * Works only pointsToDropdownMenu() is true.
+ */
+std::string Input::selectedMenuItem() const
+{
+    if (!pointsToDropdownMenu())
+        return "";
+
+    return valueBlock()->fieldAt(0)->value().toString();
+}

test/compiler/compiler_test.cpp

@@ -329,11 +329,32 @@ TEST_F(CompilerTest, ResolveInput)
     engine.registerSection(m_section);
 
     auto block = std::make_shared<Block>("a", "test_block1");
-    auto reporter = std::make_shared<Block>("a", "test_reporter");
     auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
     input->setPrimaryValue("test");
     input->setInputId(TestBlockSection::INPUT1);
-    input->setValueBlock(reporter);
+    block->addInput(input);
+    block->updateInputMap();
+    block->setCompileFunction(&TestBlockSection::compileTestBlock1);
+
+    compiler.compile(block);
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
+}
+
+TEST_F(CompilerTest, ResolveDropdownMenuInput)
+{
+    INIT_COMPILER(engine, compiler);
+
+    engine.registerSection(m_section);
+
+    auto block = std::make_shared<Block>("a", "test_block1");
+    auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
+    auto menu = std::make_shared<Block>("a", "test_menu");
+    auto optionField = std::make_shared<Field>("OPTION", "test");
+    input->setInputId(TestBlockSection::INPUT1);
+    input->setValueBlock(menu);
+    menu->addField(optionField);
     block->addInput(input);
     block->updateInputMap();
     block->setCompileFunction(&TestBlockSection::compileTestBlock1);

test/scratch_classes/input_test.cpp

@@ -1,6 +1,8 @@
 #include <scratchcpp/input.h>
 #include <scratchcpp/inputvalue.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/block.h>
+#include <scratchcpp/variable.h>
 
 #include "../common.h"
 
@@ -64,3 +66,75 @@ TEST(InputTest, ValueBlock)
     ASSERT_EQ(input.valueBlock(), nullptr);
     ASSERT_EQ(input.valueBlockId(), "");
 }
+
+TEST(InputTest, SelectedMenuItem)
+{
+    // Test with Shadow type
+    Input input1("", Input::Type::Shadow);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    auto block1 = std::make_shared<Block>("abc", "");
+    input1.setValueBlock(block1);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    auto field1 = std::make_shared<Field>("OPTION1", "");
+    block1->addField(field1);
+    ASSERT_TRUE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    auto field2 = std::make_shared<Field>("OPTION2", "something");
+    block1->addField(field2);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    auto block2 = std::make_shared<Block>("def", "");
+    input1.setValueBlock(block2);
+
+    field1 = std::make_shared<Field>("OPTION1", "something");
+    block2->addField(field1);
+    ASSERT_TRUE(input1.pointsToDropdownMenu());
+    ASSERT_EQ(input1.selectedMenuItem(), "something");
+
+    auto variable = std::make_shared<Variable>("", "");
+    field1->setValuePtr(variable);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    field1->setValuePtr(nullptr);
+    ASSERT_TRUE(input1.pointsToDropdownMenu());
+    ASSERT_EQ(input1.selectedMenuItem(), "something");
+
+    field2 = std::make_shared<Field>("OPTION2", "hello");
+    block2->addField(field2);
+    ASSERT_FALSE(input1.pointsToDropdownMenu());
+    ASSERT_TRUE(input1.selectedMenuItem().empty());
+
+    // Test with NoShadow type
+    Input input2("", Input::Type::NoShadow);
+    ASSERT_FALSE(input2.pointsToDropdownMenu());
+    ASSERT_TRUE(input2.selectedMenuItem().empty());
+
+    auto block3 = std::make_shared<Block>("ghi", "");
+    input2.setValueBlock(block3);
+    ASSERT_FALSE(input2.pointsToDropdownMenu());
+    ASSERT_TRUE(input2.selectedMenuItem().empty());
+
+    block3->addField(field1);
+    ASSERT_FALSE(input2.pointsToDropdownMenu());
+    ASSERT_TRUE(input2.selectedMenuItem().empty());
+
+    // Test with ObscuredShadow type
+    Input input3("", Input::Type::ObscuredShadow);
+    ASSERT_FALSE(input3.pointsToDropdownMenu());
+    ASSERT_TRUE(input3.selectedMenuItem().empty());
+
+    input3.setValueBlock(block3);
+    ASSERT_FALSE(input3.pointsToDropdownMenu());
+    ASSERT_TRUE(input3.selectedMenuItem().empty());
+
+    block3->addField(field1);
+    ASSERT_FALSE(input3.pointsToDropdownMenu());
+    ASSERT_TRUE(input3.selectedMenuItem().empty());
+}