Cleanups

src/game.py

@@ -58,9 +58,7 @@ class game(Gtk.Box):  # pylint: disable=invalid-name
         self.removed = "removed" in data
         self.blacklisted = "blacklisted" in data
 
-        self.game_cover = GameCover(self.cover, path=self.get_cover())
+        self.game_cover = GameCover(self.cover, path=self.get_cover_path())
-        self.pixbuf = self.game_cover.get_pixbuf()
-        self.animation = self.game_cover.get_animation()
 
         self.title.set_label(self.name)
 
@@ -107,25 +105,18 @@ class game(Gtk.Box):  # pylint: disable=invalid-name
             sys.exit()
 
     def toggle_hidden(self):
-        games_dir = self.parent_widget.data_dir / "cartridges" / "games"
+        data = json.loads((self.games_dir / f"{self.game_id}.json").read_text("utf-8"))
-
-        if not games_dir.exists():
-            return
-
-        data = json.loads((games_dir / f"{self.game_id}.json").read_text("utf-8"))
 
         data["hidden"] = not data["hidden"]
 
         save_game(self.parent_widget, data)
 
-    def get_cover(self):
+    def get_cover_path(self):
-        covers_dir = self.parent_widget.data_dir / "cartridges" / "covers"
+        cover_path = self.parent_widget.covers_dir / f"{self.game_id}.gif"
+        if cover_path.is_file():
+            return cover_path
 
-        animated_cover_path = covers_dir / f"{self.game_id}.gif"
+        cover_path = self.parent_widget.covers_dir / f"{self.game_id}.tiff"
-        if animated_cover_path.is_file():
-            return animated_cover_path
-
-        cover_path = covers_dir / f"{self.game_id}.tiff"
         if cover_path.is_file():
             return cover_path
 

src/game_cover.py

@@ -63,9 +63,6 @@ class GameCover:
                     str(path), 200, 300, False
                 )
 
-        if not self.pixbuf:
-            self.pixbuf = self.placeholder_pixbuf
-
         if not self.animation:
             self.set_pixbuf(self.pixbuf)
 
@@ -77,6 +74,8 @@ class GameCover:
 
     def set_pixbuf(self, pixbuf):
         if self.picture.is_visible():
+            if not pixbuf:
+                pixbuf = self.placeholder_pixbuf
             self.picture.set_pixbuf(pixbuf)
         else:
             self.animation = None

src/preferences.py

@@ -351,7 +351,6 @@ class PreferencesWindow(Adw.PreferencesWindow):
         self.file_chooser.select_folder(self.parent_widget, None, function, None)
 
     def undo_remove_all(self, _widget, _unused):
-        covers_dir = self.parent_widget.data_dir / "cartridges" / "covers"
         deleted_covers_dir = (
             self.parent_widget.cache_dir / "cartridges" / "deleted_covers"
         )
@@ -363,19 +362,18 @@ class PreferencesWindow(Adw.PreferencesWindow):
                 save_game(self.parent_widget, data)
 
                 cover_path = deleted_covers_dir / f"{game_id}.tiff"
-                animated_cover_path = deleted_covers_dir / f"{game_id}.gif"
+                if not cover_path.is_file():
+                    cover_path = deleted_covers_dir / f"{game_id}.gif"
+                if not cover_path.is_file():
+                    continue
 
-                if cover_path.is_file():
+                move(cover_path, self.parent_widget.covers_dir)
-                    move(cover_path, covers_dir / f"{game_id}.tiff")
-                elif animated_cover_path.is_file():
-                    move(animated_cover_path, covers_dir / f"{game_id}.gif")
 
         self.parent_widget.update_games(self.removed_games)
         self.removed_games = []
         self.toast.dismiss()
 
     def remove_all_games(self, _widget):
-        covers_dir = self.parent_widget.data_dir / "cartridges" / "covers"
         deleted_covers_dir = (
             self.parent_widget.cache_dir / "cartridges" / "deleted_covers"
         )
@@ -387,16 +385,10 @@ class PreferencesWindow(Adw.PreferencesWindow):
                 game["removed"] = True
                 save_game(self.parent_widget, game)
 
-                cover_path = covers_dir / f'{game["game_id"]}.tiff'
+                cover_path = self.parent_widget.games[game["game_id"]].get_cover_path()
-                animated_cover_path = covers_dir / f'{game["game_id"]}.gif'
 
                 if cover_path.is_file():
-                    move(cover_path, deleted_covers_dir / f'{game["game_id"]}.tiff')
+                    move(cover_path, deleted_covers_dir)
-                elif animated_cover_path.is_file():
-                    move(
-                        animated_cover_path,
-                        deleted_covers_dir / f'{game["game_id"]}.gif',
-                    )
 
         self.parent_widget.update_games(self.parent_widget.games)
         if self.parent_widget.stack.get_visible_child() == self.parent_widget.overview:

src/utils/create_details_window.py

@@ -85,7 +85,7 @@ def create_details_window(parent_widget, game_id=None):
         apply_button = Gtk.Button.new_with_label(_("Confirm"))
     else:
         window.set_title(_("Edit Game Details"))
-        game_cover.new_pixbuf(path=parent_widget.games[game_id].get_cover())
+        game_cover.new_pixbuf(path=parent_widget.games[game_id].get_cover_path())
         developer = Gtk.Entry.new_with_buffer(
             Gtk.EntryBuffer.new(games[game_id].developer, -1)
         )
@@ -95,7 +95,7 @@ def create_details_window(parent_widget, game_id=None):
         )
         apply_button = Gtk.Button.new_with_label(_("Apply"))
 
-        if parent_widget.games[game_id].pixbuf:
+        if parent_widget.games[game_id].get_cover_path():
             cover_button_delete_revealer.set_reveal_child(True)
 
     image_filter = Gtk.FileFilter(name=_("Images"))
@@ -314,16 +314,10 @@ def create_details_window(parent_widget, game_id=None):
         values["executable"] = final_executable_split
 
         if cover_deleted:
-            (
+            (parent_widget.covers_dir / f"{game_id}.tiff").unlink(missing_ok=True)
-                parent_widget.data_dir / "cartridges" / "covers" / f"{game_id}.tiff"
+            (parent_widget.covers_dir / f"{game_id}.gif").unlink(missing_ok=True)
-            ).unlink(missing_ok=True)
-            (
-                parent_widget.data_dir / "cartridges" / "covers" / f"{game_id}.gif"
-            ).unlink(missing_ok=True)
 
-        elif not (
+        if not game_cover.get_pixbuf():
-            parent_widget.data_dir / "cartridges" / "covers" / f"{game_id}.tiff"
-        ).is_file():
             SGDBSave(parent_widget, {(game_id, values["name"])})
 
         save_cover(
@@ -334,7 +328,7 @@ def create_details_window(parent_widget, game_id=None):
             game_cover.get_animation(),
         )
 
-        path = parent_widget.data_dir / "cartridges" / "games" / f"{game_id}.json"
+        path = parent_widget.games_dir / f"{game_id}.json"
 
         if path.exists():
             data = json.loads(path.read_text("utf-8"))

src/utils/get_games.py

@@ -21,16 +21,17 @@ import json
 
 
 def get_games(parent_widget, game_ids=None):
-    games_dir = parent_widget.data_dir / "cartridges" / "games"
     games = {}
 
-    if not games_dir.exists():
+    if not parent_widget.games_dir.exists():
         return {}
 
     if game_ids:
-        game_files = [games_dir / f"{game_id}.json" for game_id in game_ids]
+        game_files = [
+            parent_widget.games_dir / f"{game_id}.json" for game_id in game_ids
+        ]
     else:
-        game_files = games_dir.iterdir()
+        game_files = parent_widget.games_dir.iterdir()
 
     for game in game_files:
         data = json.loads(game.read_text("utf-8"))

src/utils/save_cover.py

@@ -49,25 +49,25 @@ def save_cover(
     pixbuf=None,
     animation_path=None,
 ):
-    covers_dir = parent_widget.data_dir / "cartridges" / "covers"
+    parent_widget.covers_dir.mkdir(parents=True, exist_ok=True)
-    covers_dir.mkdir(parents=True, exist_ok=True)
+
+    # Remove previous covers
+    (parent_widget.covers_dir / f"{game_id}.tiff").unlink(missing_ok=True)
+    (parent_widget.covers_dir / f"{game_id}.gif").unlink(missing_ok=True)
 
     if animation_path:
-        (covers_dir / f"{game_id}.tiff").unlink(missing_ok=True)
+        copyfile(animation_path, parent_widget.covers_dir / f"{game_id}.gif")
-        copyfile(animation_path, covers_dir / f"{game_id}.gif")
         return
 
     if not pixbuf:
-        try:
+        if not cover_path:
-            pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
-                str(cover_path), *parent_widget.image_size, False
-            )
-        except GLib.GError:
             return
+        pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
+            str(cover_path), *parent_widget.image_size, False
+        )
 
-    open_file = Gio.File.new_for_path(str(covers_dir / f"{game_id}.tiff"))
+    pixbuf.savev(
-    pixbuf.save_to_streamv(
+        str(parent_widget.covers_dir / f"{game_id}.tiff"),
-        open_file.replace(None, False, Gio.FileCreateFlags.NONE),
         "tiff",
         ["compression"],
         ["8"] if parent_widget.schema.get_boolean("high-quality-images") else ["7"],

src/utils/save_game.py

@@ -21,10 +21,8 @@ import json
 
 
 def save_game(parent_widget, game):
-    games_dir = parent_widget.data_dir / "cartridges" / "games"
+    parent_widget.games_dir.mkdir(parents=True, exist_ok=True)
 
-    games_dir.mkdir(parents=True, exist_ok=True)
+    (parent_widget.games_dir / f'{game["game_id"]}.json').write_text(
-
-    (games_dir / f'{game["game_id"]}.json').write_text(
         json.dumps(game, indent=4, sort_keys=True), "utf-8"
     )

src/utils/steamgriddb.py

@@ -29,19 +29,9 @@ class SGDBSave:
     def update_cover(self, task, game):
         if self.parent_widget.schema.get_boolean("sgdb") and (
             self.parent_widget.schema.get_boolean("sgdb-prefer")
-            or not any(
+            or (
-                (
+                not (self.parent_widget.covers_dir / f"{game[0]}.gif").is_file()
-                    self.parent_widget.data_dir
+                and not (self.parent_widget.covers_dir / f"{game[0]}.tiff").is_file()
-                    / "cartridges"
-                    / "covers"
-                    / f"{game[0]}.tiff"
-                ).is_file(),
-                (
-                    self.parent_widget.data_dir
-                    / "cartridges"
-                    / "covers"
-                    / f"{game[0]}.gif"
-                ).is_file(),
             )
         ):
             if not self.importer:

src/window.py

@@ -89,6 +89,9 @@ class CartridgesWindow(Adw.ApplicationWindow):
             else Path.home() / ".cache"
         )
 
+        self.games_dir = self.data_dir / "cartridges" / "games"
+        self.covers_dir = self.data_dir / "cartridges" / "covers"
+
         self.games = {}
         self.visible_widgets = {}
         self.hidden_widgets = {}
@@ -113,15 +116,9 @@ class CartridgesWindow(Adw.ApplicationWindow):
         games = get_games(self)
         for game_id in games:
             if "removed" in games[game_id]:
-                (self.data_dir / "cartridges" / "games" / f"{game_id}.json").unlink(
+                (self.games_dir / f"{game_id}.json").unlink(missing_ok=True)
-                    missing_ok=True
+                (self.covers_dir / f"{game_id}.tiff").unlink(missing_ok=True)
-                )
+                (self.covers_dir / f"{game_id}.gif").unlink(missing_ok=True)
-                (self.data_dir / "cartridges" / "covers" / f"{game_id}.tiff").unlink(
-                    missing_ok=True
-                )
-                (self.data_dir / "cartridges" / "covers" / f"{game_id}.gif").unlink(
-                    missing_ok=True
-                )
 
         rmtree(self.cache_dir / "cartridges" / "deleted_covers", True)
 
@@ -291,8 +288,11 @@ class CartridgesWindow(Adw.ApplicationWindow):
 
         self.active_game_id = game_id
 
-        pixbuf = current_game.pixbuf
+        self.overview_game_cover.new_pixbuf(path=current_game.get_cover_path())
-        self.overview_game_cover.new_pixbuf(path=current_game.get_cover())
+        pixbuf = (
+            self.overview_game_cover.get_pixbuf()
+            or self.overview_game_cover.placeholder_pixbuf
+        )
 
         self.scaled_pixbuf = pixbuf.scale_simple(2, 3, GdkPixbuf.InterpType.BILINEAR)
         self.overview_blurred_cover.set_pixbuf(self.scaled_pixbuf)