add LoadingIndicator, update PyRunner

automatically get level from trle.net on the working thread

Author: noisecode3

CMakeLists.txt

@@ -91,6 +91,8 @@ set(SOURCES_MC
     src/FileManager.cpp
     src/GameFileTree.hpp
     src/GameFileTree.cpp
+    src/LoadingIndicator.hpp
+    src/LoadingIndicator.cpp
     src/Model.hpp
     src/Model.cpp
     src/Network.hpp

src/Controller.cpp

@@ -50,6 +50,16 @@ void Controller::initializeThread() {
         model.setupGame(id);
     });
 
+    connect(this, &Controller::updateLevelThreadSignal,
+            this, [this](int id) {
+        model.updateLevel(id);
+    });
+
+    connect(this, &Controller::syncLevelsThreadSignal,
+            this, [this]() {
+        model.syncLevels();
+    });
+
     //  Comming back from model or other model objects
     auto tickSignal = [this](){ emit controllerTickSignal(); };
     connect(&model, &Model::modelTickSignal,
@@ -75,10 +85,11 @@ void Controller::initializeThread() {
             this, [this]() {
         emit controllerReloadLevelList();
     }, Qt::QueuedConnection);
-}
 
-void Controller::checkCommonFiles() {
-    emit checkCommonFilesThreadSignal();
+    connect(&model, &Model::modelLoadingDoneSignal,
+            this, [this]() {
+        emit controllerLoadingDone();
+    }, Qt::QueuedConnection);
 }
 
 void Controller::setup(const QString& level, const QString& game) {
@@ -97,6 +108,15 @@ void Controller::setupLevel(int id) {
     emit setupLevelThreadSignal(id);
 }
 
+void Controller::updateLevel(int id) {
+    emit updateLevelThreadSignal(id);
+}
+
+void Controller::syncLevels() {
+    emit syncLevelsThreadSignal();
+}
+
+
 // Using the GUI Threads
 int Controller::checkGameDirectory(int id) {
     return model.checkGameDirectory(id);
@@ -114,10 +134,6 @@ const QString Controller::getWalkthrough(int id) {
     return model.getWalkthrough(id);
 }
 
-bool Controller::updateLevel(int id) {
-    return model.updateLevel(id);
-}
-
 bool Controller::link(int id) {
     return model.setLink(id);
 }

src/Controller.hpp

@@ -32,26 +32,29 @@ class Controller : public QObject {
     }
 
     int checkGameDirectory(int id);
-    void checkCommonFiles();
+    // void checkCommonFiles();
     void setup(const QString& level, const QString& game);
     void setupGame(int id);
     void setupLevel(int id);
+    void updateLevel(int id);
+    void syncLevels();
 
     void getList(QVector<ListItemData>* list);
     void getCoverList(QVector<ListItemData*>* items);
     const InfoData getInfo(int id);
     const QString getWalkthrough(int id);
     bool link(int id);
-    bool updateLevel(int id);
     int getItemState(int id);
 
  signals:
     void controllerGenerateList(const QList<int>& availableGames);
     void controllerTickSignal();
     void controllerDownloadError(int status);
     void controllerReloadLevelList();
+    void controllerLoadingDone();
 
-    void checkCommonFilesThreadSignal();
+    void updateLevelThreadSignal(int id);
+    void syncLevelsThreadSignal();
     void setupThreadSignal(const QString& level, const QString& game);
     void setupGameThreadSignal(int id);
     void setupLevelThreadSignal(int id);

src/LoadingIndicator.cpp

@@ -0,0 +1,61 @@
+/* TombRaiderLinuxLauncher
+ * Martin Bångens Copyright (C) 2025
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "../src/LoadingIndicator.hpp"
+#include <QPainter>
+#include <QtMath>
+
+LoadingIndicator::LoadingIndicator(QWidget* parent) : QWidget(parent) {
+    setAttribute(Qt::WA_TransparentForMouseEvents);
+    setAttribute(Qt::WA_OpaquePaintEvent, false);
+
+    m_anim = new QPropertyAnimation(this, "angle");
+    m_anim->setStartValue(0);
+    m_anim->setEndValue(360);
+    m_anim->setDuration(1000);
+    m_anim->setLoopCount(-1);
+}
+
+void LoadingIndicator::paintEvent(QPaintEvent*) {
+    QPainter p(this);
+    p.setRenderHint(QPainter::Antialiasing);
+
+    int count = 12;
+    qreal radius = qMin(width(), height()) / 2.5;
+    QPointF center = rect().center();
+
+    for (int i = 0; i < count; ++i) {
+        qreal theta = (360.0 / count) * i + m_angle;
+        qreal alpha = 255.0 * (i + 1) / count;
+
+        QPointF dotPos = center + QPointF(
+            radius * std::cos(qDegreesToRadians(theta)),
+            radius * std::sin(qDegreesToRadians(theta)));
+
+        QColor color = Qt::gray;
+        color.setAlphaF(alpha / 255.0);
+
+        p.setBrush(color);
+        p.setPen(Qt::NoPen);
+        p.drawEllipse(dotPos, 4, 4);
+    }
+}
+void LoadingIndicator::showEvent(QShowEvent* event) {
+    QWidget::showEvent(event);
+    m_anim->start();
+}
+
+void LoadingIndicator::hideEvent(QHideEvent* event) {
+    QWidget::hideEvent(event);
+    m_anim->stop();
+}

src/LoadingIndicator.hpp

@@ -0,0 +1,39 @@
+/* TombRaiderLinuxLauncher
+ * Martin Bångens Copyright (C) 2025
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#pragma once
+
+#include <QWidget>
+#include <QPropertyAnimation>
+
+class LoadingIndicator : public QWidget {
+    Q_OBJECT
+    Q_PROPERTY(qreal angle READ angle WRITE setAngle)
+
+ public:
+    explicit LoadingIndicator(QWidget* parent = nullptr);
+    QSize sizeHint() const override { return QSize(64, 64); }
+
+    qreal angle() const { return m_angle; }
+    void setAngle(qreal a) { m_angle = a; update(); }
+
+ protected:
+    void paintEvent(QPaintEvent* event) override;
+    void showEvent(QShowEvent* event) override;
+    void hideEvent(QHideEvent* event) override;
+
+ private:
+    qreal m_angle = 0;
+    QPropertyAnimation* m_anim;
+};
+

src/Model.cpp

@@ -21,7 +21,7 @@ bool Model::setupDirectories(const QString& level, const QString& game) {
     if (fileManager.setUpCamp(level, game) &&
             downloader.setUpCamp(level) &&
             data.initializeDatabase(level) &&
-            m_pyRunner.setUpCamp(level.toStdString())) {
+            m_pyRunner.setUpCamp(level)) {
         status = true;
     }
     return status;
@@ -206,8 +206,16 @@ void Model::setupGame(int id) {
     }
 }
 
-bool Model::updateLevel(const int id) {
-    return m_pyRunner.updateLevel(id);
+void Model::updateLevel(const int id) {
+    // qint64 status = m_pyRunner.updateLevel(id);
+    (void)m_pyRunner.updateLevel(id);
+    emit this->modelLoadingDoneSignal();
+}
+
+void Model::syncLevels() {
+    // qint64 status = m_pyRunner.syncCards();
+    (void)m_pyRunner.syncCards();
+    emit this->modelLoadingDoneSignal();
 }
 
 bool Model::unpackLevel(const int id, const QString& name, const QString& exe) {

src/Model.hpp

@@ -77,12 +77,14 @@ class Model : public QObject {
     const QString getWalkthrough(int id);
     bool setupDirectories(const QString& level, const QString& game);
     void setup(const QString& level, const QString& game);
-    bool updateLevel(const int id);
+    void updateLevel(const int id);
+    void syncLevels();
 
  signals:
     void generateListSignal(QList<int> availableGames);
     void modelTickSignal();
     void modelReloadLevelListSignal();
+    void modelLoadingDoneSignal();
 
  private:
     bool getLevelHaveFile(

src/PyRunner.cpp

@@ -12,94 +12,104 @@
  */
 
 #include "../src/PyRunner.hpp"
-#include <Python.h>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <filesystem>
+#include <QDebug>
+#include <QString>
+#include <QVector>
+#include <QFile>
 #include <cstdio>
 
-namespace fs = std::filesystem;
+#undef slots
+#undef signals
+#include <Python.h>
+PyThreadState *g_mainState = nullptr;
 
 PyRunner::PyRunner() : m_status(0) {
     Py_Initialize();
+    g_mainState = PyEval_SaveThread();
 }
 
-PyRunner::PyRunner(const std::string& cwd) : m_cwd(cwd), m_status(0) {
+PyRunner::PyRunner(const QString& cwd) : m_cwd(cwd), m_status(0) {
     Py_Initialize();
+    g_mainState = PyEval_SaveThread();
 }
 
 PyRunner::~PyRunner() {
-    Py_Finalize();
+    PyEval_RestoreThread(g_mainState);
+    Py_FinalizeEx();
 }
 
-bool PyRunner::setUpCamp(const std::string& level) {
-    if (!fs::exists(level)) return false;
+bool PyRunner::setUpCamp(const QString& level) {
+    bool status = true;
+    if (!QFile::exists(level)) {
+        status = false;
+    }
     m_cwd = level;
-    return true;
+    return status;
 }
 
-void PyRunner::run(const std::string& script,
-        const std::vector<std::string>& args) {
+void PyRunner::run(const QString& script,
+        const QVector<QString>& args) {
     if (!Py_IsInitialized()) {
-        std::cerr << "Python not initialized!" << std::endl;
+        qDebug() << "Python not initialized!";
         m_status = 1;
         return;
     }
 
-    std::cerr << "[PyRunner] Executing script file: " << script << std::endl;
+    PyGILState_STATE gil = PyGILState_Ensure();
+    qDebug() << "[PyRunner] Executing script file: " << script << Qt::endl;
 
     // Add working dir to sys.path
-    if (!m_cwd.empty()) {
+    if (!m_cwd.isEmpty()) {
         PyObject *sysPath = PySys_GetObject("path");
-        PyObject *cwdPath = PyUnicode_FromString(m_cwd.c_str());
+        PyObject *cwdPath = PyUnicode_FromString(m_cwd.toStdString().c_str());
         PyList_Insert(sysPath, 0, cwdPath);
         Py_DECREF(cwdPath);
     }
 
     // Set sys.argv
     PyObject *argvList = PyList_New(args.size());
     for (size_t i = 0; i < args.size(); ++i) {
-        PyObject *arg = PyUnicode_FromString(args[i].c_str());
+        PyObject *arg = PyUnicode_FromString(args[i].toStdString().c_str());
         PyList_SET_ITEM(argvList, i, arg);  // steals ref
     }
     PySys_SetObject("argv", argvList);
     Py_DECREF(argvList);
 
-    std::string fullpath =
-        m_cwd.empty() ? script : (m_cwd + "/" + script + ".py");
-    FILE* fp = fopen(fullpath.c_str(), "r");
+    QString fullpath =
+        m_cwd.isEmpty() ? script : (m_cwd + "/" + script + ".py");
+    FILE* fp = fopen(fullpath.toStdString().c_str(), "r");
     if (!fp) {
-        std::cerr << "[PyRunner] Failed to open script file: "
-            << fullpath << std::endl;
+        qDebug() << "[PyRunner] Failed to open script file: "
+            << fullpath << Qt::endl;
         m_status = 1;
         return;
     }
 
-    int result = PyRun_SimpleFile(fp, fullpath.c_str());
+    int result = PyRun_SimpleFile(fp, fullpath.toStdString().c_str());
     fclose(fp);
+    PyGILState_Release(gil);
 
     if (result != 0) {
-        std::cerr << "[PyRunner] Python script returned error.\n";
+        qDebug() << "[PyRunner] Python script returned error.\n";
         m_status = 1;
     } else {
-        std::cerr << "[PyRunner] Script executed successfully.\n";
+        qDebug() << "[PyRunner] Script executed successfully.\n";
         m_status = 0;
     }
 }
 
-int64_t PyRunner::updateLevel(int64_t lid) {
+qint64 PyRunner::updateLevel(qint64 lid) {
     run("tombll_manage_data",
-            {"tombll_manage_data.py", "-u", std::to_string(lid)});
+            {"tombll_manage_data.py", "-u", QString("%1").arg(lid)});
     return m_status;
 }
 
-int64_t PyRunner::syncCards(int64_t lid) {
+qint64 PyRunner::syncCards() {
     run("tombll_manage_data", {"tombll_manage_data.py", "-sc"});
     return m_status;
 }
 
-int64_t PyRunner::getStatus() const {
+qint64 PyRunner::getStatus() const {
     return m_status;
 }