ProjectLoader: Add API for stopping loading

Author: adazem009

src/projectloader.cpp

@@ -45,10 +45,7 @@ ProjectLoader::ProjectLoader(QObject *parent) :
 
 ProjectLoader::~ProjectLoader()
 {
-    m_stopLoading = true;
-
-    if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+    stopLoading();
 
     for (SpriteModel *sprite : m_sprites)
         sprite->deleteLater();
@@ -61,8 +58,11 @@ const QString &ProjectLoader::fileName() const
 
 void ProjectLoader::setFileName(const QString &newFileName)
 {
-    if (m_loadThread.isRunning())
+    if (m_loadThread.isRunning()) {
+        stopLoading();
         m_loadThread.waitForFinished();
+        QCoreApplication::processEvents();
+    }
 
     if (newFileName.isEmpty())
         return;
@@ -72,7 +72,7 @@ void ProjectLoader::setFileName(const QString &newFileName)
     clear();
 
     m_project.setFileName(m_fileName.toStdString());
-    m_loadStatus = false;
+    m_loadStatus = LoadStatus::Loading;
 
     // TODO: Do not set these to 0 after libscratchcpp starts doing it itself
     m_downloadedAssets = 0;
@@ -87,14 +87,23 @@ void ProjectLoader::setFileName(const QString &newFileName)
     m_loadThread = QtConcurrent::run(&callLoad, this);
 }
 
-bool ProjectLoader::loadStatus() const
+ProjectLoader::LoadStatus ProjectLoader::loadStatus() const
 {
     if (m_loadThread.isRunning())
-        return false;
+        return LoadStatus::Loading;
 
     return m_loadStatus;
 }
 
+void ProjectLoader::stopLoading()
+{
+    if (m_loadThread.isRunning()) {
+        m_project.stopLoading();
+        m_stopLoading = true;
+        m_loadThread.waitForFinished();
+    }
+}
+
 bool ProjectLoader::running() const
 {
     return m_running;
@@ -122,15 +131,17 @@ void ProjectLoader::setEngine(libscratchcpp::IEngine *engine)
 StageModel *ProjectLoader::stage()
 {
     if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+        return nullptr;
 
     return &m_stage;
 }
 
 QQmlListProperty<SpriteModel> ProjectLoader::sprites()
 {
-    if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+    if (m_loadThread.isRunning()) {
+        m_emptySpriteList.clear();
+        return QQmlListProperty<SpriteModel>(this, &m_emptySpriteList);
+    }
 
     return QQmlListProperty<SpriteModel>(this, &m_sprites);
 }
@@ -168,9 +179,9 @@ const QStringList &ProjectLoader::unsupportedBlocks() const
 void ProjectLoader::start()
 {
     if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+        return;
 
-    if (m_loadStatus) {
+    if (m_loadStatus == LoadStatus::Loaded) {
         Q_ASSERT(m_engine);
         m_engine->start();
     }
@@ -179,9 +190,9 @@ void ProjectLoader::start()
 void ProjectLoader::stop()
 {
     if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+        return;
 
-    if (m_loadStatus) {
+    if (m_loadStatus == LoadStatus::Loaded) {
         Q_ASSERT(m_engine);
         m_engine->stop();
     }
@@ -276,12 +287,16 @@ void ProjectLoader::clear()
 void ProjectLoader::load()
 {
     m_unpositionedMonitors.clear();
-    m_loadStatus = m_project.load();
+    m_loadStatus = m_project.load() ? LoadStatus::Loaded : LoadStatus::Failed;
     m_engineMutex.lock();
     m_engine = m_project.engine().get();
 
     if (!m_engine || m_stopLoading) {
         m_engineMutex.unlock();
+
+        if (m_stopLoading)
+            m_loadStatus = LoadStatus::Aborted;
+
         emit fileNameChanged();
         emit loadStatusChanged();
         emit loadingFinished();
@@ -330,6 +345,7 @@ void ProjectLoader::load()
 
     if (m_stopLoading) {
         m_engineMutex.unlock();
+        m_loadStatus = LoadStatus::Aborted;
         emit fileNameChanged();
         emit loadStatusChanged();
         emit loadingFinished();
@@ -364,7 +380,7 @@ void ProjectLoader::initTimer()
 void ProjectLoader::redraw()
 {
     if (m_loadThread.isRunning())
-        m_loadThread.waitForFinished();
+        return;
 
     auto stage = m_stage.renderedTarget();
 

src/projectloader.h

@@ -23,7 +23,7 @@ class ProjectLoader : public QObject
         Q_OBJECT
         QML_ELEMENT
         Q_PROPERTY(QString fileName READ fileName WRITE setFileName NOTIFY fileNameChanged)
-        Q_PROPERTY(bool loadStatus READ loadStatus NOTIFY loadStatusChanged)
+        Q_PROPERTY(LoadStatus loadStatus READ loadStatus NOTIFY loadStatusChanged)
         Q_PROPERTY(bool running READ running NOTIFY runningChanged)
         Q_PROPERTY(int renderFps READ renderFps NOTIFY renderFpsChanged FINAL)
         Q_PROPERTY(libscratchcpp::IEngine *engine READ engine NOTIFY engineChanged)
@@ -43,13 +43,25 @@ class ProjectLoader : public QObject
         Q_PROPERTY(unsigned int assetCount READ assetCount NOTIFY assetCountChanged)
 
     public:
+        enum class LoadStatus
+        {
+            Idle,
+            Loading,
+            Loaded,
+            Failed,
+            Aborted
+        };
+
+        Q_ENUM(LoadStatus)
+
         explicit ProjectLoader(QObject *parent = nullptr);
         ~ProjectLoader();
 
         const QString &fileName() const;
         void setFileName(const QString &newFileName);
 
-        bool loadStatus() const;
+        LoadStatus loadStatus() const;
+        Q_INVOKABLE void stopLoading();
 
         bool running() const;
 
@@ -155,10 +167,11 @@ class ProjectLoader : public QObject
         libscratchcpp::IEngine *m_engine = nullptr;
         libscratchcpp::IEngine *m_oldEngine = nullptr;
         QMutex m_engineMutex;
-        bool m_loadStatus = false;
+        LoadStatus m_loadStatus = LoadStatus::Idle;
         StageModel m_stage;
         QList<SpriteModel *> m_sprites;
         QList<SpriteModel *> m_clones;
+        QList<SpriteModel *> m_emptySpriteList;
         QList<MonitorModel *> m_monitors;
         std::vector<libscratchcpp::Monitor *> m_unpositionedMonitors;
         QStringList m_unsupportedBlocks;

test/projectloader/projectloader_test.cpp

@@ -46,9 +46,9 @@ class ProjectLoaderTest : public testing::Test
             ASSERT_EQ(monitorsSpy.count(), 1);
             ASSERT_TRUE(monitorAddedSpy.empty());
             ASSERT_EQ(loader->fileName(), fileName);
-            ASSERT_FALSE(loader->loadStatus());
+            ASSERT_EQ(loader->loadStatus(), ProjectLoader::LoadStatus::Loading);
 
-            while (!loader->loadStatus())
+            while (loader->loadStatus() != ProjectLoader::LoadStatus::Loaded)
                 ASSERT_LE(std::chrono::steady_clock::now(), startTime + timeout);
 
             ASSERT_EQ(loader->fileName(), fileName);
@@ -84,7 +84,7 @@ TEST_F(ProjectLoaderTest, Load)
 {
     ProjectLoader loader;
     ASSERT_TRUE(loader.fileName().isEmpty());
-    ASSERT_FALSE(loader.loadStatus());
+    ASSERT_EQ(loader.loadStatus(), ProjectLoader::LoadStatus::Idle);
     ASSERT_TRUE(loader.stage());
 
     load(&loader, "load_test.sb3");
@@ -111,13 +111,18 @@ TEST_F(ProjectLoaderTest, Load)
 
 TEST_F(ProjectLoaderTest, UnsupportedBlocks)
 {
+    static const std::chrono::milliseconds timeout(5000);
+    auto startTime = std::chrono::steady_clock::now();
+
     ProjectLoader loader;
     ASSERT_TRUE(loader.fileName().isEmpty());
-    ASSERT_FALSE(loader.loadStatus());
+    ASSERT_EQ(loader.loadStatus(), ProjectLoader::LoadStatus::Idle);
     ASSERT_TRUE(loader.stage());
 
     loader.setFileName("unsupported_blocks.sb3");
-    loader.start(); // wait until it loads
+
+    while (loader.loadStatus() != ProjectLoader::LoadStatus::Loaded)
+        ASSERT_LE(std::chrono::steady_clock::now(), startTime + timeout);
 
     auto engine = loader.engine();
     const auto &blocks = loader.unsupportedBlocks();