Load monitors

Author: adazem009

src/projectloader.cpp

@@ -2,11 +2,13 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/value.h>
+#include <scratchcpp/monitor.h>
 #include <QtConcurrent/QtConcurrent>
 #include <QApplication>
 
 #include "projectloader.h"
 #include "spritemodel.h"
+#include "valuemonitormodel.h"
 #include "renderedtarget.h"
 
 using namespace scratchcpprender;
@@ -126,6 +128,16 @@ const QList<SpriteModel *> &ProjectLoader::cloneList() const
     return m_clones;
 }
 
+QQmlListProperty<MonitorModel> ProjectLoader::monitors()
+{
+    return QQmlListProperty<MonitorModel>(this, &m_monitors);
+}
+
+const QList<MonitorModel *> &ProjectLoader::monitorList() const
+{
+    return m_monitors;
+}
+
 void ProjectLoader::start()
 {
     if (m_loadThread.isRunning())
@@ -193,8 +205,14 @@ void ProjectLoader::load()
     m_engine->setCloneLimit(m_cloneLimit);
     m_engine->setSpriteFencingEnabled(m_spriteFencing);
 
-    auto handler = std::bind(&ProjectLoader::redraw, this);
-    m_engine->setRedrawHandler(std::function<void()>(handler));
+    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));
 
     // Load targets
     const auto &targets = m_engine->targets();
@@ -211,6 +229,12 @@ void ProjectLoader::load()
         }
     }
 
+    // Load monitors
+    const auto &monitors = m_engine->monitors();
+
+    for (auto monitor : monitors)
+        addMonitor(monitor.get());
+
     if (m_stopLoading) {
         m_engineMutex.unlock();
         emit fileNameChanged();
@@ -258,6 +282,8 @@ void ProjectLoader::redraw()
         if (renderedTarget)
             renderedTarget->beforeRedraw();
     }
+
+    m_engine->updateMonitors();
 }
 
 void ProjectLoader::addClone(SpriteModel *model)
@@ -278,6 +304,48 @@ void ProjectLoader::deleteClone(SpriteModel *model)
     emit clonesChanged();
 }
 
+void ProjectLoader::addMonitor(Monitor *monitor)
+{
+    auto section = monitor->blockSection();
+
+    if (!section)
+        return;
+
+    MonitorModel *model = nullptr;
+
+    switch (monitor->mode()) {
+        case Monitor::Mode::List:
+            // TODO: Add support for list monitors
+            break;
+
+        default:
+            model = new ValueMonitorModel(section.get());
+            break;
+    }
+
+    if (!model)
+        return;
+
+    model->moveToThread(qApp->thread());
+    model->setParent(this);
+    monitor->setInterface(model);
+    m_monitors.push_back(model);
+    emit monitorAdded(model);
+    emit monitorsChanged();
+}
+
+void ProjectLoader::removeMonitor(Monitor *monitor, IMonitorHandler *iface)
+{
+    MonitorModel *model = dynamic_cast<MonitorModel *>(iface);
+
+    if (!model)
+        return;
+
+    m_monitors.removeAll(model);
+    emit monitorRemoved(model);
+    emit monitorsChanged();
+}
+
 double ProjectLoader::fps() const
 {
     return m_fps;

src/projectloader.h

@@ -10,11 +10,13 @@
 #include "stagemodel.h"
 
 Q_MOC_INCLUDE("spritemodel.h");
+Q_MOC_INCLUDE("monitormodel.h");
 
 namespace scratchcpprender
 {
 
 class SpriteModel;
+class MonitorModel;
 
 class ProjectLoader : public QObject
 {
@@ -26,6 +28,7 @@ class ProjectLoader : public QObject
         Q_PROPERTY(StageModel *stage READ stage NOTIFY stageChanged)
         Q_PROPERTY(QQmlListProperty<SpriteModel> sprites READ sprites NOTIFY spritesChanged)
         Q_PROPERTY(QQmlListProperty<SpriteModel> clones READ clones NOTIFY clonesChanged)
+        Q_PROPERTY(QQmlListProperty<MonitorModel> monitors READ monitors NOTIFY monitorsChanged)
         Q_PROPERTY(double fps READ fps WRITE setFps NOTIFY fpsChanged)
         Q_PROPERTY(bool turboMode READ turboMode WRITE setTurboMode NOTIFY turboModeChanged)
         Q_PROPERTY(unsigned int stageWidth READ stageWidth WRITE setStageWidth NOTIFY stageWidthChanged)
@@ -55,6 +58,9 @@ class ProjectLoader : public QObject
         QQmlListProperty<SpriteModel> clones();
         const QList<SpriteModel *> &cloneList() const;
 
+        QQmlListProperty<MonitorModel> monitors();
+        const QList<MonitorModel *> &monitorList() const;
+
         Q_INVOKABLE void start();
         Q_INVOKABLE void stop();
 
@@ -88,6 +94,7 @@ class ProjectLoader : public QObject
         void stageChanged();
         void spritesChanged();
         void clonesChanged();
+        void monitorsChanged();
         void fpsChanged();
         void turboModeChanged();
         void stageWidthChanged();
@@ -98,6 +105,8 @@ class ProjectLoader : public QObject
         void assetCountChanged();
         void cloneCreated(SpriteModel *model);
         void cloneDeleted(SpriteModel *model);
+        void monitorAdded(MonitorModel *model);
+        void monitorRemoved(MonitorModel *model);
 
     protected:
         void timerEvent(QTimerEvent *event) override;
@@ -109,6 +118,8 @@ class ProjectLoader : public QObject
         void redraw();
         void addClone(SpriteModel *model);
         void deleteClone(SpriteModel *model);
+        void addMonitor(libscratchcpp::Monitor *monitor);
+        void removeMonitor(libscratchcpp::Monitor *monitor, libscratchcpp::IMonitorHandler *iface);
 
         int m_timerId = -1;
         QString m_fileName;
@@ -120,6 +131,7 @@ class ProjectLoader : public QObject
         StageModel m_stage;
         QList<SpriteModel *> m_sprites;
         QList<SpriteModel *> m_clones;
+        QList<MonitorModel *> m_monitors;
         double m_fps = 30;
         bool m_turboMode = false;
         unsigned int m_stageWidth = 480;

test/load_test.sb3

@@ -1,6 +1,7 @@
 #include <QtTest/QSignalSpy>
 #include <projectloader.h>
 #include <spritemodel.h>
+#include <valuemonitormodel.h>
 #include <enginemock.h>
 #include <renderedtargetmock.h>
 
@@ -24,6 +25,8 @@ class ProjectLoaderTest : public testing::Test
             QSignalSpy engineSpy(loader, &ProjectLoader::engineChanged);
             QSignalSpy stageSpy(loader, &ProjectLoader::stageChanged);
             QSignalSpy spritesSpy(loader, &ProjectLoader::spritesChanged);
+            QSignalSpy monitorsSpy(loader, &ProjectLoader::monitorsChanged);
+            QSignalSpy monitorAddedSpy(loader, &ProjectLoader::monitorAdded);
 
             loader->setFileName(fileName);
 
@@ -33,6 +36,8 @@ class ProjectLoaderTest : public testing::Test
             ASSERT_TRUE(engineSpy.empty());
             ASSERT_TRUE(stageSpy.empty());
             ASSERT_TRUE(spritesSpy.empty());
+            ASSERT_TRUE(monitorsSpy.empty());
+            ASSERT_TRUE(monitorAddedSpy.empty());
             ASSERT_EQ(loader->fileName(), fileName);
             ASSERT_FALSE(loader->loadStatus());
 
@@ -46,6 +51,8 @@ class ProjectLoaderTest : public testing::Test
             ASSERT_EQ(engineSpy.count(), 1);
             ASSERT_EQ(stageSpy.count(), 1);
             ASSERT_EQ(spritesSpy.count(), 1);
+            ASSERT_EQ(monitorsSpy.count(), loader->monitorList().size());
+            ASSERT_EQ(monitorAddedSpy.count(), loader->monitorList().size());
         }
 };
 
@@ -72,6 +79,17 @@ TEST_F(ProjectLoaderTest, Load)
     ASSERT_EQ(sprites.size(), 2);
     ASSERT_EQ(sprites[0]->sprite(), engine->targetAt(1));
     ASSERT_EQ(sprites[1]->sprite(), engine->targetAt(2));
+
+    const auto &monitors = loader.monitorList();
+    ASSERT_EQ(monitors.size(), 7);
+
+    ValueMonitorModel *monitorModel = dynamic_cast<ValueMonitorModel *>(monitors[0]);
+    ASSERT_EQ(monitorModel->monitor(), engine->monitors().at(3).get());
+    ASSERT_EQ(monitorModel->color(), QColor::fromString("#FF8C1A"));
+
+    monitorModel = dynamic_cast<ValueMonitorModel *>(monitors[1]);
+    ASSERT_EQ(monitorModel->monitor(), engine->monitors().at(4).get());
+    ASSERT_EQ(monitorModel->color(), QColor::fromString("#FF8C1A"));
 }
 
 TEST_F(ProjectLoaderTest, Clones)