RareGame: Add enqueue and dequeue signals

They are used to insert and remove updates from downloads when
the installation of a game changes through `RareGame.set_installed`.
They piggy-back the signals with the same names in `GlobalSignals`

When importing a game from EGL, also check

rare/components/tabs/downloads/__init__.py

@@ -274,8 +274,9 @@ class DownloadsTab(QWidget):
     @pyqtSlot(UninstallOptionsModel)
     def __on_uninstall_dialog_closed(self, options: UninstallOptionsModel):
         if options and options.uninstall:
-            self.__remove_update(options.app_name)
+            rgame = self.rcore.get_game(options.app_name)
-            worker = UninstallWorker(self.core, self.rcore.get_game(options.app_name), options)
+            rgame.set_installed(False)
+            worker = UninstallWorker(self.core, rgame, options)
             worker.signals.result.connect(self.__on_uninstall_worker_result)
             self.threadpool.start(worker)
 
@@ -283,4 +284,3 @@ class DownloadsTab(QWidget):
     def __on_uninstall_worker_result(self, rgame: RareGame, success: bool, message: str):
         if not success:
             QMessageBox.warning(None, self.tr("Uninstall - {}").format(rgame.title), message, QMessageBox.Close)
-        rgame.set_installed(False)

rare/components/tabs/games/__init__.py

@@ -15,7 +15,6 @@ from rare.shared import (
     ImageManagerSingleton,
 )
 from rare.shared import RareCore
-from rare.shared.game_utils import GameUtils
 from rare.widgets.library_layout import LibraryLayout
 from rare.widgets.sliding_stack import SlidingStackedWidget
 from .game_info import GameInfoTabs
@@ -45,8 +44,6 @@ class GamesTab(QStackedWidget):
         self.dlcs: Dict[str, List[Game]] = self.api_results.dlcs
         self.no_assets: List[Game] = self.api_results.no_asset_games
 
-        self.game_utils = GameUtils(parent=self)
-
         self.games = QWidget(parent=self)
         self.games.setLayout(QVBoxLayout())
         self.addWidget(self.games)

rare/components/tabs/games/integrations/egl_sync_group.py

@@ -11,7 +11,7 @@ from legendary.models.game import InstalledGame
 
 from rare.lgndr.glue.exception import LgndrException
 from rare.models.pathspec import PathSpec
-from rare.shared import RareCore, LegendaryCoreSingleton, GlobalSignalsSingleton
+from rare.shared import RareCore
 from rare.shared.workers.wine_resolver import WineResolver
 from rare.ui.components.tabs.games.integrations.egl_sync_group import Ui_EGLSyncGroup
 from rare.ui.components.tabs.games.integrations.egl_sync_list_group import Ui_EGLSyncListGroup
@@ -25,7 +25,7 @@ class EGLSyncGroup(QGroupBox):
         super(EGLSyncGroup, self).__init__(parent=parent)
         self.ui = Ui_EGLSyncGroup()
         self.ui.setupUi(self)
-        self.core = LegendaryCoreSingleton()
+        self.core = RareCore.instance().core()
         self.ui.egl_path_info.setProperty("infoLabel", 1)
 
         self.thread_pool = QThreadPool.globalInstance()
@@ -175,7 +175,7 @@ class EGLSyncListItem(QListWidgetItem):
         super(EGLSyncListItem, self).__init__(parent=parent)
         self.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
         self.setCheckState(Qt.Unchecked)
-        self.core = LegendaryCoreSingleton()
+        self.core = RareCore.instance().core()
         self.game = game
         self.setText(self.app_title)
 
@@ -239,7 +239,7 @@ class EGLSyncListGroup(QGroupBox):
         self.ui.setupUi(self)
         self.ui.list.setFrameShape(QFrame.NoFrame)
         self.rcore = RareCore.instance()
-        self.core = LegendaryCoreSingleton()
+        self.core = RareCore.instance().core()
 
         self.ui.list.itemDoubleClicked.connect(
             lambda item: item.setCheckState(Qt.Unchecked)

rare/components/tabs/games/integrations/import_group.py

@@ -15,7 +15,7 @@ from rare.lgndr.cli import LegendaryCLI
 from rare.lgndr.core import LegendaryCore
 from rare.lgndr.glue.arguments import LgndrImportGameArgs
 from rare.lgndr.glue.monkeys import LgndrIndirectStatus
-from rare.shared import RareCore, LegendaryCoreSingleton, GlobalSignalsSingleton, ApiResultsSingleton
+from rare.shared import RareCore
 from rare.ui.components.tabs.games.integrations.import_group import Ui_ImportGroup
 from rare.utils.extra_widgets import IndicatorLineEdit, PathEdit
 from rare.widgets.elide_label import ElideLabel
@@ -62,8 +62,8 @@ class ImportWorker(QRunnable):
 
     def __init__(self, core: LegendaryCore, path: str, app_name: str = None, import_folder: bool = False, import_dlcs: bool = False):
         super(ImportWorker, self).__init__()
+        self.signals = ImportWorker.Signals()
         self.core = core
-        self.signals = self.Signals()
 
         self.path = Path(path)
         self.app_name = app_name
@@ -161,11 +161,12 @@ class ImportGroup(QGroupBox):
         self.ui = Ui_ImportGroup()
         self.ui.setupUi(self)
         self.rcore = RareCore.instance()
-        self.core = LegendaryCoreSingleton()
+        self.core = RareCore.instance().core()
-        self.signals = GlobalSignalsSingleton()
+        self.api_results = RareCore.instance().api_results()
-        self.api_results = ApiResultsSingleton()
 
+        #self.app_name_list = [rgame.app_name for rgame in self.rcore.games]
         self.app_name_list = [game.app_name for game in self.api_results.game_list]
+        #self.install_dir_list = [rgame.folder_name for rgame in self.rcore.games if not rgame.is_dlc]
         self.install_dir_list = [
             game.metadata.get("customAttributes", {})
             .get("FolderName", {})
@@ -186,6 +187,7 @@ class ImportGroup(QGroupBox):
         self.app_name_edit = IndicatorLineEdit(
             placeholder=self.tr("Use in case the app name was not found automatically"),
             completer=AppNameCompleter(
+                # app_names=[(rgame.app_name, rgame.app_title) for rgame in self.rcore.games]
                 app_names=[(i.app_name, i.app_title) for i in self.api_results.game_list]
             ),
             edit_func=self.app_name_edit_callback,
@@ -289,10 +291,7 @@ class ImportGroup(QGroupBox):
     def __on_import_progress(self, imported: ImportedGame, progress: int):
         self.info_progress.setValue(progress)
         if imported.result == ImportResult.SUCCESS or imported.result == ImportResult.FAILED:
-            rgame = self.rcore.get_game(imported.app_name)
+            self.rcore.get_game(imported.app_name).set_installed(True)
-            rgame.set_installed(True)
-            if rgame.has_update:
-                self.signals.download.enqueue.emit(rgame.app_name)
         status = "error" if not imported.result else (
             "failed" if imported.result == ImportResult.FAILED else "successful"
         )

rare/models/game.py

@@ -72,6 +72,10 @@ class RareGame(QObject):
         class Widget(QObject):
             update = pyqtSignal()
 
+        class Download(QObject):
+            enqueue = pyqtSignal(str)
+            dequeue = pyqtSignal(str)
+
         class Game(QObject):
             install = pyqtSignal(InstallOptionsModel)
             installed = pyqtSignal(str)
@@ -84,6 +88,7 @@ class RareGame(QObject):
             super(RareGame.Signals, self).__init__()
             self.progress = RareGame.Signals.Progress()
             self.widget = RareGame.Signals.Widget()
+            self.download = RareGame.Signals.Download()
             self.game = RareGame.Signals.Game()
 
     def __init__(self, legendary_core: LegendaryCore, image_manager: ImageManager, game: Game):
@@ -157,12 +162,12 @@ class RareGame(QObject):
         return RareGame.__metadata_json
 
     def __load_metadata(self):
-        metadata = self.__load_metadata_json()
+        metadata: Dict = self.__load_metadata_json()
         if self.app_name in metadata:
             self.metadata = RareGame.Metadata.from_dict(metadata[self.app_name])
 
     def __save_metadata(self):
-        metadata = self.__load_metadata_json()
+        metadata: Dict = self.__load_metadata_json()
         metadata[self.app_name] = self.metadata.as_dict()
         with open(os.path.join(data_dir(), "game_meta.json"), "w") as metadata_json:
             json.dump(metadata, metadata_json, indent=2)
@@ -281,7 +286,11 @@ class RareGame(QObject):
         if installed:
             self.update_igame()
             self.signals.game.installed.emit(self.app_name)
+            if self.has_update:
+                self.signals.download.enqueue.emit(self.app_name)
         else:
+            if self.has_update:
+                self.signals.download.dequeue.emit(self.app_name)
             self.igame = None
             self.signals.game.uninstalled.emit(self.app_name)
         self.set_pixmap()
@@ -418,6 +427,10 @@ class RareGame(QObject):
             == "Origin"
         )
 
+    @property
+    def folder_name(self) -> str:
+        return self.game.metadata.get("customAttributes", {}).get("FolderName", {}).get("value")
+
     def grant_date(self, force=False) -> datetime:
         if self.metadata.grant_date is None or force:
             entitlements = self.core.lgd.entitlements

rare/models/signals.py

@@ -21,10 +21,12 @@ class GlobalSignals:
         update_tray = pyqtSignal()
 
     class GameSignals(QObject):
+        # model
         install = pyqtSignal(InstallOptionsModel)
-        uninstall = pyqtSignal(UninstallOptionsModel)
         # str: app_name
         installed = pyqtSignal(str)
+        # model
+        uninstall = pyqtSignal(UninstallOptionsModel)
         # str: app_name
         uninstalled = pyqtSignal(str)
 

rare/shared/rare_core.py

@@ -145,9 +145,11 @@ class RareCore(QObject):
         return self.__games[app_name]
 
     def add_game(self, rgame: RareGame) -> None:
+        rgame.signals.download.enqueue.connect(self.__signals.download.enqueue)
+        rgame.signals.download.dequeue.connect(self.__signals.download.dequeue)
         rgame.signals.game.install.connect(self.__signals.game.install)
-        rgame.signals.game.uninstall.connect(self.__signals.game.uninstall)
         rgame.signals.game.installed.connect(self.__signals.game.installed)
+        rgame.signals.game.uninstall.connect(self.__signals.game.uninstall)
         rgame.signals.game.uninstalled.connect(self.__signals.game.uninstalled)
         rgame.signals.game.finished.connect(self.__signals.application.update_tray)
         rgame.signals.game.finished.connect(lambda: self.__signals.discord_rpc.set_title.emit(""))