Update libscratchcpp to latest master

Author: adazem009

libscratchcpp

@@ -20,7 +20,7 @@ using namespace libscratchcpp;
 ProjectLoader::ProjectLoader(QObject *parent) :
     QObject(parent)
 {
-    m_project.setDownloadProgressCallback([this](unsigned int finished, unsigned int all) {
+    m_project.downloadProgressChanged().connect([this](unsigned int finished, unsigned int all) {
         if (finished != m_downloadedAssets) {
             m_downloadedAssets = finished;
             emit downloadedAssetsChanged();
@@ -208,12 +208,8 @@ void ProjectLoader::stop()
 
 void ProjectLoader::answerQuestion(const QString &answer)
 {
-    if (m_engine) {
-        auto f = m_engine->questionAnswered();
-
-        if (f)
-            f(answer.toStdString());
-    }
+    if (m_engine)
+        m_engine->questionAnswered()(answer.toStdString());
 }
 
 void ProjectLoader::timerEvent(QTimerEvent *event)
@@ -255,16 +251,11 @@ void ProjectLoader::load()
     m_engine->setCloneLimit(m_cloneLimit);
     m_engine->setSpriteFencingEnabled(m_spriteFencing);
 
-    auto redrawHandler = std::bind(&ProjectLoader::redraw, this);
-    m_engine->setRedrawHandler(std::function<void()>(redrawHandler));
-
-    auto addMonitorHandler = std::bind(&ProjectLoader::addMonitor, this, std::placeholders::_1);
-    m_engine->setAddMonitorHandler(std::function<void(Monitor *)>(addMonitorHandler));
-
-    auto removeMonitorHandler = std::bind(&ProjectLoader::removeMonitor, this, std::placeholders::_1, std::placeholders::_2);
-    m_engine->setRemoveMonitorHandler(std::function<void(Monitor *, IMonitorHandler *)>(removeMonitorHandler));
+    m_engine->aboutToRender().connect(&ProjectLoader::redraw, this);
+    m_engine->monitorAdded().connect(&ProjectLoader::addMonitor, this);
+    m_engine->monitorRemoved().connect(&ProjectLoader::removeMonitor, this);
 
-    m_engine->setQuestionAsked([this](const std::string &question) { emit questionAsked(QString::fromStdString(question)); });
+    m_engine->questionAsked().connect([this](const std::string &question) { emit questionAsked(QString::fromStdString(question)); });
 
     // Load targets
     const auto &targets = m_engine->targets();

src/projectloader.cpp

@@ -150,6 +150,16 @@ libscratchcpp::Rect SpriteModel::fastBoundingRect() const
     return m_renderedTarget->getFastBounds();
 }
 
+bool SpriteModel::touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const
+{
+    return false;
+}
+
+bool SpriteModel::touchingPoint(double x, double y) const
+{
+    return false;
+}
+
 libscratchcpp::Sprite *SpriteModel::sprite() const
 {
     return m_sprite;

src/spritemodel.cpp

@@ -57,6 +57,9 @@ class SpriteModel
         libscratchcpp::Rect boundingRect() const override;
         libscratchcpp::Rect fastBoundingRect() const override;
 
+        bool touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const override;
+        bool touchingPoint(double x, double y) const override;
+
         libscratchcpp::Sprite *sprite() const;
 
         IRenderedTarget *renderedTarget() const;

src/spritemodel.h

@@ -77,6 +77,26 @@ void StageModel::onBubbleTextChanged(const std::string &text)
     }
 }
 
+libscratchcpp::Rect StageModel::boundingRect() const
+{
+    return libscratchcpp::Rect();
+}
+
+libscratchcpp::Rect StageModel::fastBoundingRect() const
+{
+    return libscratchcpp::Rect();
+}
+
+bool StageModel::touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const
+{
+    return false;
+}
+
+bool StageModel::touchingPoint(double x, double y) const
+{
+    return false;
+}
+
 void StageModel::loadCostume()
 {
     if (m_renderedTarget && m_stage)

src/stagemodel.cpp

@@ -40,6 +40,12 @@ class StageModel
         void onBubbleTypeChanged(libscratchcpp::Target::BubbleType type) override;
         void onBubbleTextChanged(const std::string &text) override;
 
+        libscratchcpp::Rect boundingRect() const override;
+        libscratchcpp::Rect fastBoundingRect() const override;
+
+        bool touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const override;
+        bool touchingPoint(double x, double y) const override;
+
         Q_INVOKABLE void loadCostume();
 
         libscratchcpp::Stage *stage() const;

src/stagemodel.h

@@ -34,7 +34,8 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, runEventLoop, (), (override));
         MOCK_METHOD(void, stopEventLoop, (), (override));
 
-        MOCK_METHOD(void, setRedrawHandler, (const std::function<void()> &), (override));
+        MOCK_METHOD(sigslot::signal<> &, aboutToRender, (), (override));
+        MOCK_METHOD(sigslot::signal<VirtualMachine *> &, threadAboutToStop, (), (override));
 
         MOCK_METHOD(bool, isRunning, (), (const, override));
 
@@ -86,8 +87,10 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(void, registerSection, (std::shared_ptr<IBlockSection>), (override));
         MOCK_METHOD(unsigned int, functionIndex, (BlockFunc), (override));
+        MOCK_METHOD(const std::vector<BlockFunc> &, blockFunctions, (), (const, override));
 
         MOCK_METHOD(void, addCompileFunction, (IBlockSection *, const std::string &, BlockComp), (override));
+        MOCK_METHOD(void, addHatPredicateCompileFunction, (IBlockSection *, const std::string &, HatPredicateCompileFunc), (override));
         MOCK_METHOD(void, addMonitorNameFunction, (IBlockSection *, const std::string &, MonitorNameFunc), (override));
         MOCK_METHOD(void, addMonitorChangeFunction, (IBlockSection *, const std::string &, MonitorChangeFunc), (override));
         MOCK_METHOD(void, addHatBlock, (IBlockSection *, const std::string &), (override));
@@ -107,6 +110,7 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
         MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, int), (override));
         MOCK_METHOD(void, addTargetClickScript, (std::shared_ptr<Block>), (override));
+        MOCK_METHOD(void, addWhenGreaterThanScript, (std::shared_ptr<Block>), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));
@@ -123,14 +127,11 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Monitor>> &, monitors, (), (const, override));
         MOCK_METHOD(void, setMonitors, (const std::vector<std::shared_ptr<Monitor>> &), (override));
-        MOCK_METHOD(void, setAddMonitorHandler, (const std::function<void(Monitor *)> &), (override));
-        MOCK_METHOD(void, setRemoveMonitorHandler, (const std::function<void(Monitor *, IMonitorHandler *)> &), (override));
+        MOCK_METHOD(sigslot::signal<Monitor *> &, monitorAdded, (), (override));
+        MOCK_METHOD((sigslot::signal<Monitor *, IMonitorHandler *> &), monitorRemoved, (), (override));
 
-        MOCK_METHOD(const std::function<void(const std::string &)> &, questionAsked, (), (const, override));
-        MOCK_METHOD(void, setQuestionAsked, (const std::function<void(const std::string &)> &), (override));
-
-        MOCK_METHOD(const std::function<void(const std::string &)> &, questionAnswered, (), (const, override));
-        MOCK_METHOD(void, setQuestionAnswered, (const std::function<void(const std::string &)> &), (override));
+        MOCK_METHOD(sigslot::signal<const std::string &> &, questionAsked, (), (override));
+        MOCK_METHOD(sigslot::signal<const std::string &> &, questionAnswered, (), (override));
 
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));
         MOCK_METHOD(void, setExtensions, (const std::vector<std::string> &), (override));

test/mocks/enginemock.h

@@ -96,7 +96,7 @@ TEST_F(ProjectLoaderTest, Load)
     ASSERT_EQ(sprites[1]->sprite(), engine->targetAt(2));
 
     const auto &monitors = loader.monitorList();
-    ASSERT_EQ(monitors.size(), 10);
+    ASSERT_EQ(monitors.size(), 11);
 
     ListMonitorModel *listMonitorModel = dynamic_cast<ListMonitorModel *>(monitors[0]);
     ASSERT_EQ(listMonitorModel->monitor(), engine->monitors().at(0).get());
@@ -179,10 +179,8 @@ TEST_F(ProjectLoaderTest, QuestionAsked)
     load(&loader, "load_test.sb3");
 
     auto engine = loader.engine();
-    auto f = engine->questionAsked();
-    ASSERT_TRUE(f);
     ASSERT_TRUE(spy.isEmpty());
-    f("test");
+    engine->questionAsked()("test");
     ASSERT_EQ(spy.count(), 1);
 
     auto args = spy.takeFirst();
@@ -197,8 +195,9 @@ TEST_F(ProjectLoaderTest, AnswerQuestion)
     loader.setEngine(&engine);
 
     AnswerQuestionMock mock;
-    std::function<void(const std::string &)> f = std::bind(&AnswerQuestionMock::answer, &mock, std::placeholders::_1);
-    EXPECT_CALL(engine, questionAnswered()).WillOnce(ReturnRef(f));
+    sigslot::signal<const std::string &> answered;
+    answered.connect(&AnswerQuestionMock::answer, &mock);
+    EXPECT_CALL(engine, questionAnswered()).WillOnce(ReturnRef(answered));
     EXPECT_CALL(mock, answer("hello"));
     loader.answerQuestion("hello");
 }