Merge pull request #408 from loathingKernel/develop

Steam shortcuts, Discord RPC, MangoHud

rare/commands/launcher/__init__.py

@@ -9,7 +9,8 @@ from logging import getLogger
 from signal import signal, SIGINT, SIGTERM, strsignal
 from typing import Optional
 
-from PyQt5.QtCore import QObject, QProcess, pyqtSignal, QUrl, QRunnable, QThreadPool, QSettings, Qt, pyqtSlot
+from PyQt5 import sip
+from PyQt5.QtCore import QObject, QProcess, pyqtSignal, QUrl, QRunnable, QThreadPool, QSettings, Qt, pyqtSlot, QTimer
 from PyQt5.QtGui import QDesktopServices
 from PyQt5.QtNetwork import QLocalServer, QLocalSocket
 from PyQt5.QtWidgets import QApplication
@@ -78,10 +79,13 @@ class PreLaunch(QRunnable):
             proc.setProcessEnvironment(launch_args.environment)
             self.signals.pre_launch_command_started.emit()
             pre_launch_command = shlex.split(launch_args.pre_launch_command)
-            # self.logger.debug("Executing prelaunch command %s, %s", pre_launch_command[0], pre_launch_command[1:])
-            proc.start(pre_launch_command[0], pre_launch_command[1:])
+            self.logger.debug("Running pre-launch command %s, %s", pre_launch_command[0], pre_launch_command[1:])
             if launch_args.pre_launch_wait:
+                proc.start(pre_launch_command[0], pre_launch_command[1:])
+                self.logger.debug("Waiting for pre-launch command to finish")
                 proc.waitForFinished(-1)
+            else:
+                proc.startDetached(pre_launch_command[0], pre_launch_command[1:])
         return launch_args
 
 
@@ -149,7 +153,10 @@ class RareLauncher(RareApp):
         language = self.settings.value(*options.language)
         self.load_translator(language)
 
-        if QSettings(self).value(*options.log_games):
+        if (
+            QSettings(self).value(*options.log_games)
+            or (game.app_name in DETACHED_APP_NAMES and platform.system() == "Windows")
+        ):
             self.console = ConsoleDialog(game.app_title)
             self.console.show()
 
@@ -172,6 +179,10 @@ class RareLauncher(RareApp):
         self.success = True
         self.start_time = time.time()
 
+        # This launches the application after it has been instantiated.
+        # The timer's signal will be serviced once we call `exec()` on the application
+        QTimer.singleShot(0, self.start)
+
     @pyqtSlot()
     def __proc_log_stdout(self):
         self.console.log_stdout(
@@ -281,9 +292,31 @@ class RareLauncher(RareApp):
             self.console.set_env(args.environment)
         self.start_time = time.time()
 
+        if self.args.dry_run:
+            self.logger.info("Dry run %s (%s)", self.rgame.app_title, self.rgame.app_name)
+            self.logger.info("%s %s", args.executable, " ".join(args.arguments))
+            if self.console:
+                self.console.log(f"Dry run {self.rgame.app_title} ({self.rgame.app_name})")
+                self.console.log(f"{shlex.join([args.executable] + args.arguments)}")
+                self.console.accept_close = True
+            print(shlex.join([args.executable] + args.arguments))
+            self.stop()
+            return
+
         if args.is_origin_game:
             QDesktopServices.openUrl(QUrl(args.executable))
-            self.stop()  # stop because it is no subprocess
+            self.stop()  # stop because it is not a subprocess
+            return
+
+        self.logger.debug("Launch command %s, %s", args.executable, " ".join(args.arguments))
+        self.logger.debug("Working directory %s", args.working_directory)
+
+        if self.rgame.app_name in DETACHED_APP_NAMES and platform.system() == "Windows":
+            if self.console:
+                self.console.log(f"Launching as a detached process")
+            subprocess.Popen([args.executable] + args.arguments, cwd=args.working_directory,
+                             env={i: args.environment.value(i) for i in args.environment.keys()})
+            self.stop()  # stop because we do not attach to the output
             return
 
         if args.working_directory:
@@ -296,23 +329,6 @@ class RareLauncher(RareApp):
                 new_state=StateChangedModel.States.started
             )
         ))
-        if self.rgame.app_name in DETACHED_APP_NAMES and platform.system() == "Windows":
-            self.game_process.deleteLater()
-            if self.console:
-                self.console.log("Launching game as a detached process")
-            subprocess.Popen([args.executable] + args.arguments, cwd=args.working_directory,
-                             env={i: args.environment.value(i) for i in args.environment.keys()})
-            self.stop()
-            return
-        if self.args.dry_run:
-            self.logger.info("Dry run activated")
-            if self.console:
-                self.console.log(f"{args.executable} {' '.join(args.arguments)}")
-                self.console.log(f"Do not start {self.rgame.app_name}")
-                self.console.accept_close = True
-            print(args.executable, " ".join(args.arguments))
-            self.stop()
-            return
         # self.logger.debug("Executing prelaunch command %s, %s", args.executable, args.arguments)
         self.game_process.start(args.executable, args.arguments)
 
@@ -359,23 +375,22 @@ class RareLauncher(RareApp):
                 self.console.log("Uploading saves...")
         self.start_prepare(action)
 
-    def start(self, args: InitArgs):
-        if not args.offline:
+    def start(self):
+        if not self.args.offline:
             try:
                 if not self.core.login():
                     raise ValueError("You are not logged in")
             except ValueError:
                 # automatically launch offline if available
                 self.logger.error("Not logged in. Trying to launch the game in offline mode")
-                args.offline = True
+                self.args.offline = True
 
-        if not args.offline and self.rgame.auto_sync_saves:
+        if not self.args.offline and self.rgame.auto_sync_saves:
             self.logger.info("Start sync worker")
             worker = SyncCheckWorker(self.core, self.rgame)
             worker.signals.error_occurred.connect(self.error_occurred)
             worker.signals.sync_state_ready.connect(self.sync_ready)
             QThreadPool.globalInstance().start(worker)
-            return
         else:
             self.start_prepare()
 
@@ -388,20 +403,26 @@ class RareLauncher(RareApp):
                 self.game_process.finished.disconnect()
             if self.game_process.receivers(self.game_process.errorOccurred):
                 self.game_process.errorOccurred.disconnect()
-        except TypeError as e:
-            self.logger.error(f"Failed to disconnect process signals: {e}")
+        except (TypeError, RuntimeError) as e:
+            self.logger.error("Failed to disconnect process signals: %s", e)
 
-        self.logger.info("Stopping server")
+        if self.game_process.state() != QProcess.NotRunning:
+            self.game_process.kill()
+        exit_code = self.game_process.exitCode()
+        self.game_process.deleteLater()
+
+        self.logger.info("Stopping server %s", self.server.socketDescriptor())
         try:
             self.server.close()
             self.server.deleteLater()
-        except RuntimeError:
-            pass
+        except RuntimeError as e:
+            self.logger.error("Error occured while stopping server: %s", e)
+
         self.processEvents()
         if not self.console:
-            self.exit()
+            self.exit(exit_code)
         else:
-            self.console.on_process_exit(self.rgame.app_name, 0)
+            self.console.on_process_exit(self.rgame.app_title, exit_code)
 
 
 def launch(args: Namespace) -> int:
@@ -416,7 +437,7 @@ def launch(args: Namespace) -> int:
     # This prevents ghost QLocalSockets, which block the name, which makes it unable to start
     # No handling for SIGKILL
     def sighandler(s, frame):
-        app.logger.info(f"{strsignal(s)} received. Stopping")
+        app.logger.info("%s received. Stopping", strsignal(s))
         app.stop()
         app.exit(1)
     signal(SIGINT, sighandler)
@@ -426,7 +447,13 @@ def launch(args: Namespace) -> int:
         app.stop()
         app.exit(1)
         return 1
-    app.start(args)
-    # app.exit_app.connect(lambda: app.exit(0))
 
-    return app.exec_()
+    try:
+        exit_code = app.exec()
+    except Exception as e:
+        app.logger.error("Unhandled error %s", e)
+        exit_code = 1
+    finally:
+        if not sip.isdeleted(app.server):
+            app.server.close()
+    return exit_code

rare/commands/launcher/lgd_helper.py

@@ -2,7 +2,7 @@ import os
 import platform
 import shutil
 from argparse import Namespace
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from logging import getLogger
 from typing import List
 
@@ -43,8 +43,8 @@ class InitArgs(Namespace):
 @dataclass
 class LaunchArgs:
     executable: str = ""
-    arguments: List[str] = None
-    working_directory: str = None
+    arguments: List[str] = field(default_factory=list)
+    working_directory: str = ""
     environment: QProcessEnvironment = None
     pre_launch_command: str = ""
     pre_launch_wait: bool = False
@@ -129,9 +129,7 @@ def get_game_params(rgame: RareGameSlim, args: InitArgs, launch_args: LaunchArgs
             launch_args.environment.insert(name, value)
 
     full_params.extend(params.launch_command)
-    full_params.append(
-        os.path.join(params.game_directory, params.game_executable)
-    )
+    full_params.append(os.path.join(params.game_directory, params.game_executable))
     full_params.extend(params.game_parameters)
     full_params.extend(params.egl_parameters)
     full_params.extend(params.user_parameters)

rare/components/__init__.py

@@ -1,7 +1,7 @@
 import os
 import shutil
 from argparse import Namespace
-from datetime import datetime, timezone
+from datetime import datetime, timezone, UTC
 from typing import Optional
 
 import requests.exceptions
@@ -60,7 +60,7 @@ class Rare(RareApp):
 
     def poke_timer(self):
         dt_exp = datetime.fromisoformat(self.core.lgd.userdata['expires_at'][:-1]).replace(tzinfo=timezone.utc)
-        dt_now = datetime.utcnow().replace(tzinfo=timezone.utc)
+        dt_now = datetime.now(UTC)
         td = abs(dt_exp - dt_now)
         self.relogin_timer.start(int(td.total_seconds() - 60) * 1000)
         self.logger.info(f"Renewed session expires at {self.core.lgd.userdata['expires_at']}")

rare/components/main_window.py

@@ -101,9 +101,9 @@ class MainWindow(QMainWindow):
 
         if not self.args.offline:
             try:
-                from rare.utils.rpc import DiscordRPC
+                from rare.utils.discord_rpc import DiscordRPC
 
-                self.rpc = DiscordRPC()
+                self.discord_rpc = DiscordRPC()
             except ModuleNotFoundError:
                 logger.warning("Discord RPC module not found")
 

rare/components/tabs/__init__.py

@@ -5,7 +5,7 @@ from rare.shared import RareCore, LegendaryCoreSingleton, GlobalSignalsSingleton
 from rare.utils.misc import qta_icon, ExitCodes
 from .account import AccountWidget
 from .downloads import DownloadsTab
-from .games import GamesTab
+from .games import GamesLibrary
 from .settings import SettingsTab
 from .settings.debug import DebugSettings
 from .store import StoreTab
@@ -28,7 +28,7 @@ class MainTabWidget(QTabWidget):
         self.setTabBar(self.tab_bar)
 
         # Generate Tabs
-        self.games_tab = GamesTab(self)
+        self.games_tab = GamesLibrary(self)
         self.games_index = self.addTab(self.games_tab, self.tr("Games"))
 
         # Downloads Tab after Games Tab to use populated RareCore games list

rare/components/tabs/downloads/__init__.py

@@ -14,6 +14,7 @@ from rare.components.dialogs.install_dialog import InstallDialog
 from rare.components.dialogs.uninstall_dialog import UninstallDialog
 from rare.lgndr.models.downloading import UIUpdate
 from rare.models.game import RareGame
+from rare.models.image import ImageSize
 from rare.models.install import InstallOptionsModel, InstallQueueItemModel, UninstallOptionsModel
 from rare.models.options import options
 from rare.shared import RareCore
@@ -209,9 +210,9 @@ class DownloadsTab(QWidget):
         self.__thread = dl_thread
         self.download_widget.ui.kill_button.setDisabled(False)
         self.download_widget.ui.dl_name.setText(item.download.game.app_title)
-        self.download_widget.setPixmap(
-            RareCore.instance().image_manager().get_pixmap(rgame.app_name, True)
-        )
+        self.download_widget.setPixmap(self.rcore.image_manager().get_pixmap(
+            rgame.app_name, ImageSize.Wide, True
+        ))
 
         self.signals.application.notify.emit(
             self.tr("Downloads"),

rare/components/tabs/downloads/download.py

@@ -29,7 +29,7 @@ class DownloadWidget(ImageWidget):
 
     def prepare_pixmap(self, pixmap: QPixmap) -> QPixmap:
         device: QImage = QImage(
-            pixmap.size().width() * 3,
+            pixmap.size().width() * 1,
             int(self.sizeHint().height() * pixmap.devicePixelRatioF()) + 1,
             QImage.Format_ARGB32_Premultiplied,
         )
@@ -38,9 +38,9 @@ class DownloadWidget(ImageWidget):
         painter.fillRect(device.rect(), brush)
         # the gradient could be cached and reused as it is expensive
         gradient = QLinearGradient(0, 0, device.width(), 0)
-        gradient.setColorAt(0.15, Qt.transparent)
+        gradient.setColorAt(0.02, Qt.transparent)
         gradient.setColorAt(0.5, Qt.black)
-        gradient.setColorAt(0.85, Qt.transparent)
+        gradient.setColorAt(0.98, Qt.transparent)
         painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
         painter.fillRect(device.rect(), gradient)
         painter.end()

rare/components/tabs/downloads/widgets.py

@@ -34,7 +34,7 @@ class QueueInfoWidget(QWidget):
         self.image_manager = ImageManagerSingleton()
 
         self.image = ImageWidget(self)
-        self.image.setFixedSize(ImageSize.Icon)
+        self.image.setFixedSize(ImageSize.LibraryIcon)
         self.ui.image_layout.addWidget(self.image)
 
         self.ui.queue_info_layout.setAlignment(Qt.AlignTop)
@@ -50,7 +50,7 @@ class QueueInfoWidget(QWidget):
 
         if old_igame:
             self.ui.title.setText(old_igame.title)
-            self.image.setPixmap(self.image_manager.get_pixmap(old_igame.app_name, color=True))
+            self.image.setPixmap(self.image_manager.get_pixmap(old_igame.app_name, ImageSize.LibraryIcon))
 
     def update_information(self, game, igame, analysis, old_igame):
         self.ui.title.setText(game.app_title)
@@ -60,7 +60,7 @@ class QueueInfoWidget(QWidget):
         self.ui.local_version.setText(elide_text(self.ui.local_version, igame.version))
         self.ui.dl_size.setText(format_size(analysis.dl_size) if analysis else "")
         self.ui.install_size.setText(format_size(analysis.install_size) if analysis else "")
-        self.image.setPixmap(self.image_manager.get_pixmap(game.app_name, color=True))
+        self.image.setPixmap(self.image_manager.get_pixmap(game.app_name, ImageSize.LibraryIcon))
 
 
 class UpdateWidget(QFrame):

rare/components/tabs/games/__init__.py

@@ -17,15 +17,15 @@ from .game_info import GameInfoTabs
 from .game_widgets import LibraryWidgetController, LibraryFilter, LibraryOrder, LibraryView
 from .game_widgets.icon_game_widget import IconGameWidget
 from .game_widgets.list_game_widget import ListGameWidget
-from .head_bar import GameListHeadBar
+from .head_bar import LibraryHeadBar
 from .integrations import IntegrationsTabs
 
-logger = getLogger("GamesTab")
+logger = getLogger("GamesLibrary")
 
 
-class GamesTab(QStackedWidget):
+class GamesLibrary(QStackedWidget):
     def __init__(self, parent=None):
-        super(GamesTab, self).__init__(parent=parent)
+        super(GamesLibrary, self).__init__(parent=parent)
         self.rcore = RareCore.instance()
         self.core = LegendaryCoreSingleton()
         self.signals = GlobalSignalsSingleton()
@@ -37,7 +37,7 @@ class GamesTab(QStackedWidget):
         games_page_layout = QVBoxLayout(self.games_page)
         self.addWidget(self.games_page)
 
-        self.head_bar = GameListHeadBar(parent=self.games_page)
+        self.head_bar = LibraryHeadBar(parent=self.games_page)
         self.head_bar.goto_import.connect(self.show_import)
         self.head_bar.goto_egl_sync.connect(self.show_egl_sync)
         self.head_bar.goto_eos_ubisoft.connect(self.show_eos_ubisoft)
@@ -123,6 +123,7 @@ class GamesTab(QStackedWidget):
                 logger.warning("Excluding %s from the game list", rgame.app_title)
                 continue
         self.filter_games(self.head_bar.current_filter())
+        self.order_games(self.head_bar.current_order())
         self.update_count_games_label()
 
     def add_library_widget(self, rgame: RareGame):

rare/components/tabs/games/game_info/details.py

@@ -58,7 +58,7 @@ class GameDetails(QWidget, SideTabContents):
         self.rgame: Optional[RareGame] = None
 
         self.image = ImageWidget(self)
-        self.image.setFixedSize(ImageSize.Display)
+        self.image.setFixedSize(ImageSize.DisplayTall)
         self.ui.left_layout.insertWidget(0, self.image, alignment=Qt.AlignTop)
 
         self.ui.install_button.clicked.connect(self.__on_install)
@@ -270,7 +270,7 @@ class GameDetails(QWidget, SideTabContents):
     @pyqtSlot()
     def __update_widget(self):
         """ React to state updates from RareGame """
-        self.image.setPixmap(self.rgame.get_pixmap(True))
+        self.image.setPixmap(self.rgame.get_pixmap(ImageSize.DisplayTall, True))
 
         self.ui.lbl_version.setDisabled(self.rgame.is_non_asset)
         self.ui.version.setDisabled(self.rgame.is_non_asset)

rare/components/tabs/games/game_info/dlcs.py

@@ -23,28 +23,28 @@ class GameDlcWidget(QFrame):
         self.rdlc = rdlc
 
         self.image = ImageWidget(self)
-        self.image.setFixedSize(ImageSize.Icon)
+        self.image.setFixedSize(ImageSize.LibraryIcon)
         self.ui.dlc_layout.insertWidget(0, self.image)
 
         self.ui.dlc_name.setText(rdlc.app_title)
         self.ui.version.setText(rdlc.version)
         self.ui.app_name.setText(rdlc.app_name)
 
-        self.image.setPixmap(rdlc.pixmap)
-
+        # self.image.setPixmap(rdlc.get_pixmap_icon(rdlc.is_installed))
         self.__update()
+
         rdlc.signals.widget.update.connect(self.__update)
 
     @pyqtSlot()
     def __update(self):
         self.ui.action_button.setEnabled(self.rdlc.is_idle)
-        self.image.setPixmap(self.rdlc.pixmap)
+        self.image.setPixmap(self.rdlc.get_pixmap(ImageSize.LibraryIcon, self.rdlc.is_installed))
 
     def showEvent(self, a0: QShowEvent) -> None:
         if a0.spontaneous():
             return super().showEvent(a0)
-        if self.rdlc.pixmap.isNull():
-            self.rdlc.load_pixmap()
+        if not self.rdlc.has_pixmap:
+            self.rdlc.load_pixmaps()
         super().showEvent(a0)
 
 

rare/components/tabs/games/game_widgets/__init__.py

@@ -122,7 +122,7 @@ class IconViewContainer(ViewContainer):
             elif order_by == LibraryOrder.RECENT:
                 # Sort by recently played
                 self.layout().sort(
-                    key=lambda x: (not x.widget().rgame.is_installed, x.widget().rgame.is_non_asset, x.widget().rgame.metadata.last_played),
+                    key=lambda x: (x.widget().rgame.is_installed, not x.widget().rgame.is_non_asset, x.widget().rgame.metadata.last_played),
                     reverse=True,
                 )
             else:
@@ -164,7 +164,7 @@ class ListViewContainer(ViewContainer):
                 )
             elif order_by == LibraryOrder.RECENT:
                 list_widgets.sort(
-                    key=lambda x: (not x.rgame.is_installed, x.rgame.is_non_asset, x.rgame.metadata.last_played),
+                    key=lambda x: (x.rgame.is_installed, not x.rgame.is_non_asset, x.rgame.metadata.last_played),
                     reverse=True,
                 )
             else:

rare/components/tabs/games/game_widgets/game_widget.py

@@ -2,18 +2,22 @@ import platform
 import random
 from logging import getLogger
 
-from PyQt5.QtCore import pyqtSignal, Qt, pyqtSlot, QObject, QEvent, QTimer
+from PyQt5.QtCore import pyqtSignal, Qt, pyqtSlot, QObject, QEvent
 from PyQt5.QtGui import QMouseEvent, QShowEvent, QPaintEvent
 from PyQt5.QtWidgets import QMessageBox, QAction
 
 from rare.models.game import RareGame
-from rare.shared import (
-    LegendaryCoreSingleton,
-    GlobalSignalsSingleton,
-    ArgumentsSingleton,
-    ImageManagerSingleton,
-)
+from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton, ArgumentsSingleton, ImageManagerSingleton
 from rare.utils.paths import desktop_links_supported, desktop_link_path, create_desktop_link
+from rare.utils.steam_shortcuts import (
+    steam_shortcuts_supported,
+    steam_shortcut_exists,
+    remove_steam_shortcut,
+    remove_steam_coverart,
+    add_steam_shortcut,
+    add_steam_coverart,
+    save_steam_shortcuts,
+)
 from .library_widget import LibraryWidget
 
 logger = getLogger("GameWidget")
@@ -40,13 +44,14 @@ class GameWidget(LibraryWidget):
         self.install_action.triggered.connect(self._install)
 
         self.desktop_link_action = QAction(self)
-        self.desktop_link_action.triggered.connect(
-            lambda: self._create_link(self.rgame.folder_name, "desktop")
-        )
+        self.desktop_link_action.triggered.connect(lambda: self._create_link(self.rgame.folder_name, "desktop"))
 
         self.menu_link_action = QAction(self)
-        self.menu_link_action.triggered.connect(
-            lambda: self._create_link(self.rgame.folder_name, "start_menu")
+        self.menu_link_action.triggered.connect(lambda: self._create_link(self.rgame.folder_name, "start_menu"))
+
+        self.steam_shortcut_action = QAction(self)
+        self.steam_shortcut_action.triggered.connect(
+            lambda: self._create_steam_shortcut(self.rgame.app_name, self.rgame.app_title)
         )
 
         self.reload_action = QAction(self.tr("Reload Image"), self)
@@ -58,24 +63,15 @@ class GameWidget(LibraryWidget):
         self.update_actions()
 
         # signals
-        self.rgame.signals.widget.update.connect(lambda: self.setPixmap(self.rgame.pixmap))
+        self.rgame.signals.widget.update.connect(self.update_pixmap)
         self.rgame.signals.widget.update.connect(self.update_buttons)
         self.rgame.signals.widget.update.connect(self.update_state)
         self.rgame.signals.game.installed.connect(self.update_actions)
         self.rgame.signals.game.uninstalled.connect(self.update_actions)
 
-        self.rgame.signals.progress.start.connect(
-            lambda: self.showProgress(
-                self.image_manager.get_pixmap(self.rgame.app_name, True),
-                self.image_manager.get_pixmap(self.rgame.app_name, False)
-            )
-        )
-        self.rgame.signals.progress.update.connect(
-            lambda p: self.updateProgress(p)
-        )
-        self.rgame.signals.progress.finish.connect(
-            lambda e: self.hideProgress(e)
-        )
+        self.rgame.signals.progress.start.connect(self.start_progress)
+        self.rgame.signals.progress.update.connect(lambda p: self.updateProgress(p))
+        self.rgame.signals.progress.finish.connect(lambda e: self.hideProgress(e))
 
         self.state_strings = {
             RareGame.State.IDLE: "",
@@ -88,7 +84,7 @@ class GameWidget(LibraryWidget):
             "has_update": self.tr("Update available"),
             "needs_verification": self.tr("Needs verification"),
             "not_can_launch": self.tr("Can't launch"),
-            "save_not_up_to_date": self.tr("Save is not up-to-date")
+            "save_not_up_to_date": self.tr("Save is not up-to-date"),
         }
 
         self.hover_strings = {
@@ -104,10 +100,10 @@ class GameWidget(LibraryWidget):
     # lk: abstract class for typing, the `self.ui` attribute should be used
     # lk: by the Ui class in the children. It must contain at least the same
     # lk: attributes as `GameWidgetUi` class
-    __slots__ = "ui"
+    __slots__ = "ui", "update_pixmap", "start_progress"
 
     def paintEvent(self, a0: QPaintEvent) -> None:
-        if not self.visibleRegion().isNull() and self.rgame.pixmap.isNull():
+        if not self.visibleRegion().isNull() and not self.rgame.has_pixmap:
             self.startTimer(random.randrange(42, 2361, 129), Qt.CoarseTimer)
             # self.startTimer(random.randrange(42, 2361, 363), Qt.VeryCoarseTimer)
             # self.rgame.load_pixmap()
@@ -115,7 +111,7 @@ class GameWidget(LibraryWidget):
 
     def timerEvent(self, a0):
         self.killTimer(a0.timerId())
-        self.rgame.load_pixmap()
+        self.rgame.load_pixmaps()
 
     def showEvent(self, a0: QShowEvent) -> None:
         if a0.spontaneous():
@@ -131,9 +127,11 @@ class GameWidget(LibraryWidget):
                 self.ui.status_label.setText(self.state_strings["needs_verification"])
             elif not self.rgame.can_launch and self.rgame.is_installed:
                 self.ui.status_label.setText(self.state_strings["not_can_launch"])
-            elif self.rgame.igame and (
-                    self.rgame.game.supports_cloud_saves or self.rgame.game.supports_mac_cloud_saves
-            ) and not self.rgame.is_save_up_to_date:
+            elif (
+                self.rgame.igame
+                and (self.rgame.game.supports_cloud_saves or self.rgame.game.supports_mac_cloud_saves)
+                and not self.rgame.is_save_up_to_date
+            ):
                 self.ui.status_label.setText(self.state_strings["save_not_up_to_date"])
             else:
                 self.ui.status_label.setText(self.state_strings[self.rgame.state])
@@ -148,6 +146,8 @@ class GameWidget(LibraryWidget):
         self.ui.launch_btn.setVisible(self.rgame.is_installed)
         self.ui.launch_btn.setEnabled(self.rgame.can_launch)
 
+        self.steam_shortcut_action.setEnabled(self.rgame.has_pixmap)
+
     @pyqtSlot()
     def update_actions(self):
         for action in self.actions():
@@ -170,6 +170,13 @@ class GameWidget(LibraryWidget):
                 self.menu_link_action.setText(self.tr("Create Start Menu link"))
             self.addAction(self.menu_link_action)
 
+        if steam_shortcuts_supported() and self.rgame.is_installed:
+            if steam_shortcut_exists(self.rgame.app_name):
+                self.steam_shortcut_action.setText(self.tr("Remove from Steam"))
+            else:
+                self.steam_shortcut_action.setText(self.tr("Add to Steam"))
+            self.addAction(self.steam_shortcut_action)
+
         self.addAction(self.reload_action)
         if self.rgame.is_installed and not self.rgame.is_origin:
             self.addAction(self.uninstall_action)
@@ -222,9 +229,7 @@ class GameWidget(LibraryWidget):
             offline = True
         if self.rgame.has_update:
             skip_version_check = True
-        self.rgame.launch(
-            offline=offline, skip_update_check=skip_version_check
-        )
+        self.rgame.launch(offline=offline, skip_update_check=skip_version_check)
 
     @pyqtSlot()
     def _install(self):
@@ -234,7 +239,8 @@ class GameWidget(LibraryWidget):
     def _uninstall(self):
         self.show_info.emit(self.rgame)
 
-    def _create_link(self, name, link_type):
+    @pyqtSlot(str, str)
+    def _create_link(self, name: str, link_type: str):
         if not desktop_links_supported():
             QMessageBox.warning(
                 self,
@@ -257,16 +263,18 @@ class GameWidget(LibraryWidget):
             except PermissionError:
                 QMessageBox.warning(self, "Error", "Could not create shortcut.")
                 return
-
-            if link_type == "desktop":
-                self.desktop_link_action.setText(self.tr("Remove Desktop link"))
-            elif link_type == "start_menu":
-                self.menu_link_action.setText(self.tr("Remove Start Menu link"))
         else:
             if shortcut_path.exists():
                 shortcut_path.unlink(missing_ok=True)
+        self.update_actions()
 
-            if link_type == "desktop":
-                self.desktop_link_action.setText(self.tr("Create Desktop link"))
-            elif link_type == "start_menu":
-                self.menu_link_action.setText(self.tr("Create Start Menu link"))
+    @pyqtSlot(str, str)
+    def _create_steam_shortcut(self, app_name: str, app_title: str):
+        if steam_shortcut_exists(app_name):
+            if shortcut := remove_steam_shortcut(app_name):
+                remove_steam_coverart(shortcut)
+        else:
+            if shortcut := add_steam_shortcut(app_name, app_title):
+                add_steam_coverart(app_name, shortcut)
+        save_steam_shortcuts()
+        self.update_actions()

rare/components/tabs/games/game_widgets/icon_game_widget.py

@@ -1,7 +1,7 @@
 from logging import getLogger
 from typing import Optional
 
-from PyQt5.QtCore import QEvent
+from PyQt5.QtCore import QEvent, pyqtSlot
 
 from rare.models.game import RareGame
 from rare.models.image import ImageSize
@@ -15,7 +15,7 @@ class IconGameWidget(GameWidget):
     def __init__(self, rgame: RareGame, parent=None):
         super().__init__(rgame, parent)
         self.setObjectName(f"{rgame.app_name}")
-        self.setFixedSize(ImageSize.Library)
+        self.setFixedSize(ImageSize.LibraryTall)
         self.ui = IconWidget()
         self.ui.setupUi(self)
 
@@ -34,6 +34,17 @@ class IconGameWidget(GameWidget):
         self.ui.launch_btn.installEventFilter(self)
         self.ui.install_btn.installEventFilter(self)
 
+    @pyqtSlot()
+    def update_pixmap(self):
+        self.setPixmap(self.rgame.get_pixmap(ImageSize.LibraryTall, self.rgame.is_installed))
+
+    @pyqtSlot()
+    def start_progress(self):
+        self.showProgress(
+            self.rgame.get_pixmap(ImageSize.LibraryTall, True),
+            self.rgame.get_pixmap(ImageSize.LibraryTall, False)
+        )
+
     def enterEvent(self, a0: Optional[QEvent] = None) -> None:
         if a0 is not None:
             a0.accept()

rare/components/tabs/games/game_widgets/list_game_widget.py

@@ -1,6 +1,6 @@
 from logging import getLogger
 
-from PyQt5.QtCore import Qt, QEvent, QRect
+from PyQt5.QtCore import Qt, QEvent, QRect, pyqtSlot
 from PyQt5.QtGui import (
     QPalette,
     QBrush,
@@ -12,6 +12,7 @@ from PyQt5.QtGui import (
 )
 
 from rare.models.game import RareGame
+from rare.models.image import ImageSize
 from rare.utils.misc import format_size
 from .game_widget import GameWidget
 from .list_widget import ListWidget
@@ -50,6 +51,17 @@ class ListGameWidget(GameWidget):
         self.ui.launch_btn.installEventFilter(self)
         self.ui.install_btn.installEventFilter(self)
 
+    @pyqtSlot()
+    def update_pixmap(self):
+        self.setPixmap(self.rgame.get_pixmap(ImageSize.LibraryWide, self.rgame.is_installed))
+
+    @pyqtSlot()
+    def start_progress(self):
+        self.showProgress(
+            self.rgame.get_pixmap(ImageSize.LibraryWide, True),
+            self.rgame.get_pixmap(ImageSize.LibraryWide, False)
+        )
+
     def enterEvent(self, a0: QEvent = None) -> None:
         if a0 is not None:
             a0.accept()
@@ -70,7 +82,7 @@ class ListGameWidget(GameWidget):
 
     def prepare_pixmap(self, pixmap: QPixmap) -> QPixmap:
         device: QImage = QImage(
-            pixmap.size().width() * 3,
+            pixmap.size().width() * 1,
             int(self.sizeHint().height() * pixmap.devicePixelRatioF()) + 1,
             QImage.Format_ARGB32_Premultiplied
         )
@@ -79,9 +91,9 @@ class ListGameWidget(GameWidget):
         painter.fillRect(device.rect(), brush)
         # the gradient could be cached and reused as it is expensive
         gradient = QLinearGradient(0, 0, device.width(), 0)
-        gradient.setColorAt(0.15, Qt.transparent)
+        gradient.setColorAt(0.02, Qt.transparent)
         gradient.setColorAt(0.5, Qt.black)
-        gradient.setColorAt(0.85, Qt.transparent)
+        gradient.setColorAt(0.98, Qt.transparent)
         painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
         painter.fillRect(device.rect(), gradient)
         painter.end()
@@ -104,7 +116,7 @@ class ListGameWidget(GameWidget):
         brush = QBrush(self._pixmap)
         brush.setTransform(self._transform)
         width = int(self._pixmap.width() / self._pixmap.devicePixelRatioF())
-        origin = self.width() - width
+        origin = self.width() // 2
         painter.setBrushOrigin(origin, 0)
         fill_rect = QRect(origin, 0, width, self.height())
         painter.fillRect(fill_rect, brush)

rare/components/tabs/games/head_bar.py

@@ -1,9 +1,14 @@
-from PyQt5.QtCore import QSettings, pyqtSignal, pyqtSlot, QSize, Qt
+import logging
+
+from PyQt5.QtCore import QSettings, pyqtSlot, QSize, Qt
+from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtWidgets import (
+    QHBoxLayout,
+    QWidget,
+    QPushButton,
+)
 from PyQt5.QtWidgets import (
     QLabel,
-    QPushButton,
-    QWidget,
-    QHBoxLayout,
     QComboBox,
     QMenu,
     QAction, QSpacerItem, QSizePolicy,
@@ -11,11 +16,11 @@ from PyQt5.QtWidgets import (
 
 from rare.models.options import options, LibraryFilter, LibraryOrder
 from rare.shared import RareCore
-from rare.utils.extra_widgets import ButtonLineEdit
 from rare.utils.misc import qta_icon
+from rare.widgets.button_edit import ButtonLineEdit
 
 
-class GameListHeadBar(QWidget):
+class LibraryHeadBar(QWidget):
     filterChanged = pyqtSignal(object)
     orderChanged = pyqtSignal(object)
     viewChanged = pyqtSignal(object)
@@ -24,7 +29,8 @@ class GameListHeadBar(QWidget):
     goto_eos_ubisoft = pyqtSignal()
 
     def __init__(self, parent=None):
-        super(GameListHeadBar, self).__init__(parent=parent)
+        super(LibraryHeadBar, self).__init__(parent=parent)
+        self.logger = logging.getLogger(type(self).__name__)
         self.rcore = RareCore.instance()
         self.settings = QSettings(self)
 
@@ -47,12 +53,13 @@ class GameListHeadBar(QWidget):
         self.filter.addItem(self.tr("Include Unreal"),     LibraryFilter.INCLUDE_UE)
 
         try:
-            _filter = self.settings.value(*options.library_filter)
+            _filter = LibraryFilter(self.settings.value(*options.library_filter))
             if (index := self.filter.findData(_filter, Qt.UserRole)) < 0:
-                raise ValueError
+                raise ValueError(f"Filter '{_filter}' is not available")
             else:
                 self.filter.setCurrentIndex(index)
-        except (TypeError, ValueError):
+        except (TypeError, ValueError) as e:
+            self.logger.error("Error while loading library: %s", e)
             self.settings.setValue(options.library_filter.key, options.library_filter.default)
             _filter = LibraryFilter(options.library_filter.default)
             self.filter.setCurrentIndex(self.filter.findData(_filter, Qt.UserRole))
@@ -71,10 +78,11 @@ class GameListHeadBar(QWidget):
         try:
             _order = LibraryOrder(self.settings.value(*options.library_order))
             if (index := self.order.findData(_order, Qt.UserRole)) < 0:
-                raise ValueError
+                raise ValueError(f"Order '{_order}' is not available")
             else:
                 self.order.setCurrentIndex(index)
-        except (TypeError, ValueError):
+        except (TypeError, ValueError) as e:
+            self.logger.error("Error while loading library: %s", e)
             self.settings.setValue(options.library_order.key, options.library_order.default)
             _order = LibraryOrder(options.library_order.default)
             self.order.setCurrentIndex(self.order.findData(_order, Qt.UserRole))
@@ -166,3 +174,43 @@ class GameListHeadBar(QWidget):
         data = self.order.itemData(index, Qt.UserRole)
         self.orderChanged.emit(data)
         self.settings.setValue(options.library_order.key, int(data))
+
+
+class SelectViewWidget(QWidget):
+    toggled = pyqtSignal(bool)
+
+    def __init__(self, icon_view: bool, parent=None):
+        super(SelectViewWidget, self).__init__(parent=parent)
+        self.icon_button = QPushButton(self)
+        self.icon_button.setObjectName(f"{type(self).__name__}Button")
+        self.list_button = QPushButton(self)
+        self.list_button.setObjectName(f"{type(self).__name__}Button")
+
+        if icon_view:
+            self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="orange"))
+            self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="#eee"))
+        else:
+            self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="#eee"))
+            self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="orange"))
+
+        self.icon_button.clicked.connect(self.icon)
+        self.list_button.clicked.connect(self.list)
+
+        layout = QHBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.icon_button)
+        layout.addWidget(self.list_button)
+
+        self.setLayout(layout)
+
+    def icon(self):
+        self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="orange"))
+        self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="#eee"))
+        self.toggled.emit(True)
+
+    def list(self):
+        self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="#eee"))
+        self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="orange"))
+        self.toggled.emit(False)
+
+

rare/components/tabs/settings/rare.py

@@ -6,7 +6,7 @@ from PyQt5.QtCore import QSettings, Qt, pyqtSlot, QUrl
 from PyQt5.QtGui import QDesktopServices
 from PyQt5.QtWidgets import QWidget, QMessageBox
 
-from rare.components.tabs.settings.widgets.rpc import RPCSettings
+from rare.components.tabs.settings.widgets.discord_rpc import DiscordRPCSettings
 from rare.models.options import options, LibraryView
 from rare.shared import LegendaryCoreSingleton
 from rare.ui.components.tabs.settings.rare import Ui_RareSettings
@@ -75,8 +75,8 @@ class RareSettings(QWidget):
             self.ui.view_combo.setCurrentIndex(0)
         self.ui.view_combo.currentIndexChanged.connect(self.on_view_combo_changed)
 
-        self.rpc = RPCSettings(self)
-        self.ui.right_layout.insertWidget(1, self.rpc, alignment=Qt.AlignTop)
+        self.discord_rpc_settings = DiscordRPCSettings(self)
+        self.ui.right_layout.insertWidget(1, self.discord_rpc_settings, alignment=Qt.AlignTop)
 
         self.ui.sys_tray.setChecked(self.settings.value(*options.sys_tray))
         self.ui.sys_tray.stateChanged.connect(

rare/components/tabs/settings/widgets/discord_rpc.py

@@ -3,34 +3,34 @@ from PyQt5.QtWidgets import QGroupBox
 
 from rare.shared import GlobalSignalsSingleton
 from rare.models.options import options
-from rare.ui.components.tabs.settings.widgets.rpc import Ui_RPCSettings
+from rare.ui.components.tabs.settings.widgets.discord_rpc import Ui_DiscordRPCSettings
 
 
-class RPCSettings(QGroupBox):
+class DiscordRPCSettings(QGroupBox):
     def __init__(self, parent):
-        super(RPCSettings, self).__init__(parent=parent)
-        self.ui = Ui_RPCSettings()
+        super(DiscordRPCSettings, self).__init__(parent=parent)
+        self.ui = Ui_DiscordRPCSettings()
         self.ui.setupUi(self)
         self.signals = GlobalSignalsSingleton()
 
         self.settings = QSettings()
 
-        self.ui.enable.setCurrentIndex(self.settings.value(*options.rpc_enable))
+        self.ui.enable.setCurrentIndex(self.settings.value(*options.discord_rpc_mode))
         self.ui.enable.currentIndexChanged.connect(self.__enable_changed)
 
-        self.ui.show_game.setChecked((self.settings.value(*options.rpc_name)))
+        self.ui.show_game.setChecked((self.settings.value(*options.discord_rpc_game)))
         self.ui.show_game.stateChanged.connect(
-            lambda: self.settings.setValue(options.rpc_name.key, self.ui.show_game.isChecked())
+            lambda: self.settings.setValue(options.discord_rpc_game.key, self.ui.show_game.isChecked())
         )
 
-        self.ui.show_os.setChecked((self.settings.value(*options.rpc_os)))
+        self.ui.show_os.setChecked((self.settings.value(*options.discord_rpc_os)))
         self.ui.show_os.stateChanged.connect(
-            lambda: self.settings.setValue(options.rpc_os.key, self.ui.show_os.isChecked())
+            lambda: self.settings.setValue(options.discord_rpc_os.key, self.ui.show_os.isChecked())
         )
 
-        self.ui.show_time.setChecked((self.settings.value(*options.rpc_time)))
+        self.ui.show_time.setChecked((self.settings.value(*options.discord_rpc_time)))
         self.ui.show_time.stateChanged.connect(
-            lambda: self.settings.setValue(options.rpc_time.key, self.ui.show_time.isChecked())
+            lambda: self.settings.setValue(options.discord_rpc_time.key, self.ui.show_time.isChecked())
         )
 
         try:
@@ -40,5 +40,5 @@ class RPCSettings(QGroupBox):
             self.setToolTip(self.tr("Pypresence is not installed"))
 
     def __enable_changed(self, i):
-        self.settings.setValue(options.rpc_enable.key, i)
-        self.signals.discord_rpc.apply_settings.emit()
+        self.settings.setValue(options.discord_rpc_mode.key, i)
+        self.signals.discord_rpc.update_settings.emit()

rare/components/tabs/settings/widgets/overlay.py

@@ -45,11 +45,11 @@ class OverlayComboBox(QComboBox):
         self.setCurrentIndex(0)
 
     def getValue(self) -> Optional[str]:
-        return f"{self.option}={self.currentText()}" if self.currentIndex() > 0 else None
+        return f"{self.option}={self.currentData(Qt.UserRole)}" if self.currentIndex() > 0 else None
 
     def setValue(self, options: Dict[str, str]):
         if (value := options.get(self.option, None)) is not None:
-            self.setCurrentText(value)
+            self.setCurrentIndex(self.findData(value, Qt.UserRole))
             options.pop(self.option)
         else:
             self.setDefault()
@@ -93,10 +93,13 @@ class OverlayNumberInput(OverlayLineEdit):
 
 
 class OverlaySelectInput(OverlayComboBox):
-    def __init__(self, option: str, values: List, parent=None):
+    def __init__(self, option: str, values: Tuple, parent=None):
         super().__init__(option, parent=parent)
+        for item in values:
+            text, data = item
+            self.addItem(text, data)
         # self.addItems([str(v) for v in values])
-        self.addItems(map(str, values))
+        # self.addItems(map(str, values))
 
 
 class ActivationStates(IntEnum):
@@ -241,23 +244,42 @@ class DxvkSettings(OverlaySettings):
             OverlayCheckBox("api", self.tr("D3D feature level")),
             OverlayCheckBox("compiler", self.tr("Compiler activity")),
         ]
-        form = [(OverlayNumberInput("scale", 1.0), self.tr("Scale"))]
+        form = [
+            (OverlayNumberInput("scale", 1.0), self.tr("Scale"))
+        ]
         self.setupWidget(grid, form, "DXVK_HUD", "0", "1")
 
     def update_settings_override(self, state: ActivationStates):
         pass
 
 
-mangohud_position = [
-    "default",
-    "top-left",
-    "top-right",
-    "middle-left",
-    "middle-right",
-    "bottom-left",
-    "bottom-right",
-    "top-center",
-]
+mangohud_position = (
+    ("default", "default"),
+    ("top-left", "top-left"),
+    ("top-right", "top-right"),
+    ("middle-left", "middle-left"),
+    ("middle-right", "middle-right"),
+    ("bottom-left", "bottom-left"),
+    ("bottom-right", "bottom-right"),
+    ("top-center", "top-center"),
+)
+
+mangohud_vsync = (
+    ("config", None),
+    ("adaptive", "0"),
+    ("off", "1"),
+    ("mailbox", "2"),
+    ("on", "3"),
+)
+
+mangohud_gl_vsync = (
+    ("config", None),
+    ("off", "0"),
+    ("on", "1"),
+    ("half", "2"),
+    ("third", "3"),
+    ("quarter", "4"),
+)
 
 
 class MangoHudSettings(OverlaySettings):
@@ -283,6 +305,9 @@ class MangoHudSettings(OverlaySettings):
             OverlayCheckBox("gpu_power", self.tr("GPU power consumption")),
         ]
         form = [
+            (OverlayNumberInput("fps_limit", 0), self.tr("FPS Limit")),
+            (OverlaySelectInput("vsync", mangohud_vsync), self.tr("Vulkan VSync")),
+            (OverlaySelectInput("gl_vsync", mangohud_gl_vsync), self.tr("OpenGL VSync")),
             (OverlayNumberInput("font_size", 24), self.tr("Font size")),
             (OverlaySelectInput("position", mangohud_position), self.tr("Position")),
         ]

rare/components/tabs/store/api/models/query.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime, timezone, UTC
 from typing import List
 
 
 @dataclass
 class SearchDateRange:
     start_date: datetime = datetime(year=1990, month=1, day=1, tzinfo=timezone.utc)
-    end_date: datetime = datetime.utcnow().replace(tzinfo=timezone.utc)
+    end_date: datetime = datetime.now(UTC)
 
     def __str__(self):
         def fmt_date(date: datetime) -> str:

rare/components/tabs/store/api/models/response.py

@@ -45,8 +45,8 @@ class ImageUrlModel:
 @dataclass
 class KeyImagesModel:
     key_images: Optional[List[ImageUrlModel]] = None
-    tall_types = ("DieselStoreFrontTall", "OfferImageTall", "Thumbnail", "ProductLogo", "DieselGameBoxLogo")
-    wide_types = ("DieselStoreFrontWide", "OfferImageWide", "VaultClosed", "ProductLogo")
+    tall_types = ("DieselGameBoxTall", "DieselStoreFrontTall", "OfferImageTall", "DieselGameBoxLogo", "Thumbnail", "ProductLogo")
+    wide_types = ("DieselGameBoxwide", "DieselStoreFrontWide", "OfferImageWide", "DieselGameBox", "VaultClosed", "ProductLogo")
 
     def __getitem__(self, item):
         return self.key_images[item]

rare/components/tabs/store/landing.py

@@ -1,5 +1,5 @@
-import datetime
 import logging
+from datetime import datetime, UTC
 from typing import List
 
 from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal, QObject, QEvent
@@ -184,7 +184,7 @@ class LandingWidget(QWidget, SideTabContents):
             self.free_games_next.layout().removeWidget(w)
             w.deleteLater()
 
-        date = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc)
+        date = datetime.now(UTC)
         free_now = []
         free_next = []
         for item in free_games:

rare/components/tabs/store/search.py

@@ -12,7 +12,7 @@ from PyQt5.QtWidgets import (
 from legendary.core import LegendaryCore
 
 from rare.ui.components.tabs.store.search import Ui_SearchWidget
-from rare.utils.extra_widgets import ButtonLineEdit
+from rare.widgets.button_edit import ButtonLineEdit
 from rare.widgets.side_tab import SideTabContents
 from rare.widgets.sliding_stack import SlidingStackedWidget
 from .api.models.query import SearchStoreQuery

rare/components/tabs/store/widgets/details.py

@@ -41,7 +41,7 @@ class StoreDetailsWidget(QWidget, SideTabContents):
         self.catalog_offer: CatalogOfferModel = None
 
         self.image = LoadingImageWidget(store_api.cached_manager, self)
-        self.image.setFixedSize(ImageSize.Display)
+        self.image.setFixedSize(ImageSize.DisplayTall)
         self.ui.left_layout.insertWidget(0, self.image, alignment=Qt.AlignTop)
         self.ui.left_layout.setAlignment(Qt.AlignTop)
 
@@ -176,7 +176,9 @@ class StoreDetailsWidget(QWidget, SideTabContents):
 
         key_images = self.catalog_offer.keyImages
         img_url = key_images.for_dimensions(self.image.size().width(), self.image.size().height())
-        self.image.fetchPixmap(img_url.url)
+        # FIXME: check why there was no tall image
+        if img_url:
+            self.image.fetchPixmap(img_url.url)
 
         # self.image_stack.setCurrentIndex(0)
         about = product_data.about

rare/components/tabs/store/widgets/items.py

@@ -76,7 +76,7 @@ class StoreItemWidget(ItemWidget):
 class ResultsItemWidget(ItemWidget):
     def __init__(self, manager: QtRequests, catalog_game: CatalogOfferModel, parent=None):
         super(ResultsItemWidget, self).__init__(manager, catalog_game, parent=parent)
-        self.setFixedSize(ImageSize.Display)
+        self.setFixedSize(ImageSize.DisplayTall)
         self.ui.setupUi(self)
 
         key_images = catalog_game.keyImages

rare/models/game.py

@@ -8,10 +8,11 @@ from threading import Lock
 from typing import List, Optional, Dict, Set
 
 from PyQt5.QtCore import QRunnable, pyqtSlot, QProcess, QThreadPool
-from PyQt5.QtGui import QPixmap, QPixmapCache
+from PyQt5.QtGui import QPixmap
 from legendary.lfs import eos
 from legendary.models.game import Game, InstalledGame
 
+from rare.models.image import ImageSize
 from rare.lgndr.core import LegendaryCore
 from rare.models.base_game import RareGameBase, RareGameSlim
 from rare.models.install import InstallOptionsModel, UninstallOptionsModel
@@ -29,23 +30,31 @@ class RareGame(RareGameSlim):
     class Metadata:
         queued: bool = False
         queue_pos: Optional[int] = None
-        last_played: datetime = datetime.min
-        grant_date: datetime = datetime.min
+        last_played: datetime = datetime.min.replace(tzinfo=UTC)
+        grant_date: datetime = datetime.min.replace(tzinfo=UTC)
         steam_appid: Optional[int] = None
         steam_grade: Optional[str] = None
-        steam_date: datetime = datetime.min
+        steam_date: datetime = datetime.min.replace(tzinfo=UTC)
+        steam_shortcut: Optional[int] = None
         tags: List[str] = field(default_factory=list)
 
+        # For compatibility with previously created game metadata
+        @staticmethod
+        def parse_date(strdate: str):
+            dt = datetime.fromisoformat(strdate) if strdate else datetime.min
+            return dt.replace(tzinfo=UTC)
+
         @classmethod
         def from_dict(cls, data: Dict):
             return cls(
                 queued=data.get("queued", False),
                 queue_pos=data.get("queue_pos", None),
-                last_played=datetime.fromisoformat(x) if (x := data.get("last_played", "")) else datetime.min,
-                grant_date=datetime.fromisoformat(x) if (x := data.get("grant_date", "")) else datetime.min,
+                last_played=RareGame.Metadata.parse_date(data.get("last_played", "")),
+                grant_date=RareGame.Metadata.parse_date(data.get("grant_date", "")),
                 steam_appid=data.get("steam_appid", None),
                 steam_grade=data.get("steam_grade", None),
-                steam_date=datetime.fromisoformat(x) if (x := data.get("steam_date", "")) else datetime.min,
+                steam_date=RareGame.Metadata.parse_date(data.get("steam_date", "")),
+                steam_shortcut=data.get("steam_shortcut", None),
                 tags=data.get("tags", []),
             )
 
@@ -54,11 +63,12 @@ class RareGame(RareGameSlim):
             return dict(
                 queued=self.queued,
                 queue_pos=self.queue_pos,
-                last_played=self.last_played.isoformat() if self.last_played else datetime.min,
-                grant_date=self.grant_date.isoformat() if self.grant_date else datetime.min,
+                last_played=self.last_played.isoformat() if self.last_played else datetime.min.replace(tzinfo=UTC),
+                grant_date=self.grant_date.isoformat() if self.grant_date else datetime.min.replace(tzinfo=UTC),
                 steam_appid=self.steam_appid,
                 steam_grade=self.steam_grade,
-                steam_date=self.steam_date.isoformat() if self.steam_date else datetime.min,
+                steam_date=self.steam_date.isoformat() if self.steam_date else datetime.min.replace(tzinfo=UTC),
+                steam_shortcut=self.steam_shortcut,
                 tags=self.tags,
             )
 
@@ -76,7 +86,7 @@ class RareGame(RareGameSlim):
         if self.game.app_title == "Unreal Engine":
             self.game.app_title += f" {self.game.app_name.split('_')[-1]}"
 
-        self.pixmap: QPixmap = QPixmap()
+        self.has_pixmap: bool = False
         self.metadata: RareGame.Metadata = RareGame.Metadata()
         self.__load_metadata()
         self.grant_date()
@@ -118,7 +128,7 @@ class RareGame(RareGameSlim):
     @pyqtSlot(int)
     def __game_launched(self, code: int):
         self.state = RareGame.State.RUNNING
-        self.metadata.last_played = datetime.now()
+        self.metadata.last_played = datetime.now(UTC)
         if code == GameProcess.Code.ON_STARTUP:
             return
         self.__save_metadata()
@@ -430,16 +440,16 @@ class RareGame(RareGameSlim):
         if platform.system() == "Windows" or self.is_unreal:
             return "na"
         if self.metadata.steam_grade != "pending":
-            elapsed_time = abs(datetime.utcnow() - self.metadata.steam_date)
+            elapsed_time = abs(datetime.now(UTC) - self.metadata.steam_date)
 
             if elapsed_time.days > 3:
                 logger.info("Refreshing ProtonDB grade for %s", self.app_title)
 
-                def _set_steam_grade():
+                def set_steam_grade():
                     appid, rating = get_rating(self.core, self.app_name)
                     self.set_steam_grade(appid, rating)
 
-                worker = QRunnable.create(_set_steam_grade)
+                worker = QRunnable.create(set_steam_grade)
                 QThreadPool.globalInstance().start(worker)
                 self.metadata.steam_grade = "pending"
         return self.metadata.steam_grade
@@ -458,13 +468,13 @@ class RareGame(RareGameSlim):
         if appid and self.steam_appid is None:
             self.set_steam_appid(appid)
         self.metadata.steam_grade = grade
-        self.metadata.steam_date = datetime.utcnow()
+        self.metadata.steam_date = datetime.now(UTC)
         self.__save_metadata()
         self.signals.widget.update.emit()
 
     def grant_date(self, force=False) -> datetime:
         if (entitlements := self.core.lgd.entitlements) is None:
-            return self.metadata.grant_date.replace(tzinfo=UTC)
+            return self.metadata.grant_date
         if self.metadata.grant_date == datetime.min.replace(tzinfo=UTC) or force:
             logger.debug("Grant date for %s not found in metadata, resolving", self.app_name)
             matching = filter(lambda ent: ent["namespace"] == self.game.namespace, entitlements)
@@ -474,7 +484,7 @@ class RareGame(RareGameSlim):
             ) if entitlement else datetime.min.replace(tzinfo=UTC)
             self.metadata.grant_date = grant_date
             self.__save_metadata()
-        return self.metadata.grant_date.replace(tzinfo=UTC)
+        return self.metadata.grant_date
 
     def set_origin_attributes(self, path: str, size: int = 0) -> None:
         self.__origin_install_path = path
@@ -495,19 +505,19 @@ class RareGame(RareGameSlim):
             return bool(not self.is_foreign or self.can_run_offline)
         return False
 
-    def get_pixmap(self, color=True) -> QPixmap:
-        QPixmapCache.clear()
-        return self.image_manager.get_pixmap(self.app_name, color)
+    def get_pixmap(self, preset: ImageSize.Preset, color=True) -> QPixmap:
+        return self.image_manager.get_pixmap(self.app_name, preset, color)
 
+    @pyqtSlot(object)
     def set_pixmap(self):
-        self.pixmap = self.image_manager.get_pixmap(self.app_name, self.is_installed)
-        QPixmapCache.clear()
-        if not self.pixmap.isNull():
+        # self.pixmap = not self.image_manager.get_pixmap(self.app_name, self.is_installed).isNull()
+        self.has_pixmap = True
+        if self.has_pixmap:
             self.signals.widget.update.emit()
 
-    def load_pixmap(self):
-        """ Do not call this function, call set_pixmap instead. This is only used for startup image loading """
-        if self.pixmap.isNull():
+    def load_pixmaps(self):
+        """ Do not call this function, call set_pixmap instead. This is only used for initial image loading """
+        if not self.has_pixmap:
             self.image_manager.download_image(self.game, self.set_pixmap, 0, False)
 
     def refresh_pixmap(self):

rare/models/image.py

@@ -1,25 +1,32 @@
 from enum import Enum
+from typing import Tuple
 
 from PyQt5.QtCore import QSize
 
 
-class Orientation(Enum):
+class ImageType(Enum):
     Tall = 0
     Wide = 1
+    Icon = 3
+    Logo = 2
 
 
 class ImageSize:
     class Preset:
-        def __init__(self, divisor: float, pixel_ratio: float, orientation: Orientation = Orientation.Tall,
+        def __init__(self, divisor: float, pixel_ratio: float, orientation: ImageType = ImageType.Tall,
                      base: 'ImageSize.Preset' = None):
             self.__divisor = divisor
             self.__pixel_ratio = pixel_ratio
-            if orientation == Orientation.Tall:
+            if orientation == ImageType.Tall:
                 self.__img_factor = 67
                 self.__size = QSize(self.__img_factor * 3, self.__img_factor * 4) * pixel_ratio / divisor
-            else:
-                self.__img_factor = 17
+            if orientation == ImageType.Wide:
+                self.__img_factor = 34
                 self.__size = QSize(self.__img_factor * 16, self.__img_factor * 9) * pixel_ratio / divisor
+            if orientation == ImageType.Icon:
+                self.__img_factor = 128
+                self.__size = QSize(self.__img_factor * 1, self.__img_factor * 1) * pixel_ratio / divisor
+            self.__orientation = orientation
             # lk: for prettier images set this to true
             # self.__smooth_transform: bool = True
             self.__smooth_transform = divisor <= 2
@@ -49,38 +56,45 @@ class ImageSize:
         def pixel_ratio(self) -> float:
             return self.__pixel_ratio
 
+        @property
+        def orientation(self) -> ImageType:
+            return self.__orientation
+
+        @property
+        def aspect_ratio(self) -> Tuple[int, int]:
+            if self.__orientation == ImageType.Tall:
+                return 3, 4
+            elif self.__orientation == ImageType.Wide:
+                return 16, 9
+            else:
+                return 0, 0
+
         @property
         def base(self) -> 'ImageSize.Preset':
             return self.__base
 
-    Image = Preset(1, 1)
+    Tall = Preset(1, 1)
     """! @brief Size and pixel ratio of the image on disk"""
 
-    ImageWide = Preset(1, 1, Orientation.Wide)
-    """! @brief Size and pixel ratio for wide 16/9 image on disk"""
-
-    Display = Preset(1, 1, base=Image)
+    DisplayTall = Preset(1, 1, base=Tall)
     """! @brief Size and pixel ratio for displaying"""
 
-    DisplayWide = Preset(1, 1, Orientation.Wide, base=ImageWide)
-    """! @brief Size and pixel ratio for wide 16/9 image display"""
-
-    LibraryWide = Preset(1.21, 1, Orientation.Wide, base=ImageWide)
-
-    Library = Preset(1.21, 1, base=Image)
+    LibraryTall = Preset(1.21, 1, base=Tall)
     """! @brief Same as Display"""
 
-    Small = Preset(3, 1, base=Image)
-    """! @brief Small image size for displaying"""
+    Wide = Preset(1, 1, ImageType.Wide)
+    """! @brief Size and pixel ratio for wide 16/9 image on disk"""
 
-    SmallWide = Preset(3, 1, Orientation.Wide, base=ImageWide)
-    """! @brief Small image size for displaying"""
+    DisplayWide = Preset(2, 1, ImageType.Wide, base=Wide)
+    """! @brief Size and pixel ratio for wide 16/9 image display"""
 
-    Smaller = Preset(4, 1, base=Image)
-    """! @brief Smaller image size for displaying"""
+    LibraryWide = Preset(2.41, 1, ImageType.Wide, base=Wide)
 
-    SmallerWide = Preset(4, 1, Orientation.Wide, base=ImageWide)
-    """! @brief Smaller image size for displaying"""
+    Icon = Preset(1, 1, ImageType.Icon)
+    """! @brief Size and pixel ratio of the icon on disk"""
 
-    Icon = Preset(5, 1, base=Image)
-    """! @brief Smaller image size for UI icons"""
+    DisplayIcon = Preset(1, 1, ImageType.Icon, base=Icon)
+    """! @brief Size and pixel ratio of the icon on disk"""
+
+    LibraryIcon = Preset(2.2, 1, ImageType.Icon, base=Icon)
+    """! @brief Size and pixel ratio of the icon on disk"""

rare/models/options.py

@@ -45,10 +45,10 @@ class Defaults(Namespace):
     )
     library_order = Value(key="library_order", default=int(LibraryOrder.TITLE), dtype=int)
 
-    rpc_enable = Value(key="rpc_enable", default=0, dtype=int)
-    rpc_name = Value(key="rpc_game", default=True, dtype=bool)
-    rpc_time = Value(key="rpc_time", default=True, dtype=bool)
-    rpc_os = Value(key="rpc_os", default=True, dtype=bool)
+    discord_rpc_mode = Value(key="discord_rpc_mode", default=0, dtype=int)
+    discord_rpc_game = Value(key="discord_rpc_game", default=True, dtype=bool)
+    discord_rpc_time = Value(key="discord_rpc_time", default=True, dtype=bool)
+    discord_rpc_os = Value(key="discord_rpc_os", default=True, dtype=bool)
 
 
 options = Defaults()

rare/models/signals.py

@@ -37,10 +37,12 @@ class GlobalSignals:
         dequeue = pyqtSignal(str)
 
     class DiscordRPCSignals(QObject):
-        # str: app_title
-        set_title = pyqtSignal(str)
+        # str: app_name
+        update_presence = pyqtSignal(str)
+        # str: app_name
+        remove_presence = pyqtSignal(str)
         # none
-        apply_settings = pyqtSignal()
+        update_settings = pyqtSignal()
 
     def __init__(self):
         self.application = GlobalSignals.ApplicationSignals()

rare/models/steam.py

@@ -0,0 +1,154 @@
+import binascii
+import shlex
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, UTC
+from typing import Dict, List, Type, Any
+
+
+class SteamUser:
+    def __init__(self, long_id: str, user: Dict):
+        super(SteamUser, self).__init__()
+        self._long_id: str = long_id
+        self._user = user.copy()
+
+    @property
+    def long_id(self) -> int:
+        return int(self._long_id)
+
+    @property
+    def short_id(self) -> int:
+        return self.long_id & 0xFFFFFFFF
+
+    @property
+    def account_name(self) -> str:
+        return self._user.get("AccountName", "")
+
+    @property
+    def persona_name(self) -> str:
+        return self._user.get("PersonaName", "")
+
+    @property
+    def most_recent(self) -> bool:
+        return bool(int(self._user.get("MostRecent", "0")))
+
+    @property
+    def last_login(self) -> datetime:
+        return datetime.fromtimestamp(float(self._user.get("Timestamp", "0")), UTC)
+
+    @property
+    def __dict__(self):
+        return dict(
+            long_id=self.long_id,
+            short_id=self.short_id,
+            account_name=self.account_name,
+            persona_name=self.persona_name,
+            most_recent=self.most_recent,
+            last_login=self.last_login,
+        )
+
+    def __repr__(self):
+        return repr(vars(self))
+
+
+@dataclass
+class SteamShortcut:
+
+    appid: int
+    AppName: str
+    Exe: str
+    StartDir: str
+    icon: str
+    ShortcutPath: str
+    LaunchOptions: str
+    IsHidden: bool
+    AllowDesktopConfig: bool
+    AllowOverlay: bool
+    OpenVR: bool
+    Devkit: bool
+    DevkitGameID: str
+    DevkitOverrideAppID: int
+    LastPlayTime: int
+    FlatpakAppID: str
+    tags: Dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls: Type["SteamShortcut"], src: Dict[str, Any]) -> "SteamShortcut":
+        d = src.copy()
+        tmp = cls(
+            appid=d.pop("appid", 0),
+            AppName=d.pop("AppName", ""),
+            Exe=d.pop("Exe", ""),
+            StartDir=d.pop("StartDir", ""),
+            icon=d.pop("icon", ""),
+            ShortcutPath=d.pop("ShortcutPath", ""),
+            LaunchOptions=d.pop("LaunchOptions", ""),
+            IsHidden=bool(d.pop("IsHidden", 0)),
+            AllowDesktopConfig=bool(d.pop("AllowDesktopConfig", 1)),
+            AllowOverlay=bool(d.pop("AllowOverlay", 1)),
+            OpenVR=bool(d.pop("OpenVR", 0)),
+            Devkit=bool(d.pop("Devkit", 0)),
+            DevkitGameID=d.pop("DevkitGameID", ""),
+            DevkitOverrideAppID=d.pop("DevkitOverrideAppID", 0),
+            LastPlayTime=d.pop("LastPlayTime", 0),
+            FlatpakAppID=d.pop("FlatpakAppID", ""),
+            tags=d.pop("tags", {}),
+        )
+        return tmp
+
+    @classmethod
+    def create(
+        cls: Type["SteamShortcut"],
+        app_name: str,
+        app_title: str,
+        executable: str,
+        start_dir: str,
+        icon: str,
+        launch_options: List[str],
+    ) -> "SteamShortcut":
+        shortcut = cls.from_dict({})
+        shortcut.appid = cls.calculate_appid(app_name)
+        shortcut.AppName = app_title
+        shortcut.Exe = shlex.quote(executable)
+        shortcut.StartDir = shlex.quote(start_dir)
+        shortcut.icon = shlex.quote(icon)
+        shortcut.LaunchOptions = shlex.join(launch_options)
+        return shortcut
+
+    @staticmethod
+    def calculate_appid(app_name) -> int:
+        key = "rare_steam_shortcut_" + app_name
+        top = binascii.crc32(str.encode(key, "utf-8")) | 0x80000000
+        return (((top << 32) | 0x02000000) >> 32) - 0x100000000
+
+    def shortcut_appid(self) -> int:
+        return self.appid
+
+    def coverart_appid(self) -> int:
+        return self.shortcut_appid() + 0x100000000
+
+    @property
+    def grid_wide(self) -> str:
+        return f"{self.coverart_appid()}.png"
+
+    @property
+    def grid_tall(self) -> str:
+        return f"{self.coverart_appid()}p.png"
+
+    @property
+    def game_hero(self) -> str:
+        return f"{self.coverart_appid()}_hero.png"
+
+    @property
+    def game_logo(self) -> str:
+        return f"{self.coverart_appid()}_logo.png"
+
+    @property
+    def last_played(self):
+        return datetime.fromtimestamp(float(self.LastPlayTime), UTC)
+
+    @property
+    def __dict__(self):
+        ret = dict(
+            shortcut_appid=self.shortcut_appid(), grid_appid=self.coverart_appid(), last_played=self.last_played
+        )
+        return ret

rare/resources/static_css/stylesheet.py

@@ -196,16 +196,8 @@ css.QPushButton[css_name(ListWidget, "Button")].textAlign.setValue("left")
 css.QLabel[css_name(ListWidget, "InfoLabel")].color.setValue("#999")
 
 
-# WaitingSpinner
-from rare.utils.extra_widgets import WaitingSpinner
-css.QLabel[css_name(WaitingSpinner)].setValues(
-    marginLeft="auto",
-    marginRight="auto",
-)
-
-
 # SelectViewWidget
-from rare.utils.extra_widgets import SelectViewWidget
+from rare.components.tabs.games.head_bar import SelectViewWidget
 css.QPushButton[css_name(SelectViewWidget, "Button")].setValues(
     border="none",
     backgroundColor="transparent",
@@ -213,7 +205,7 @@ css.QPushButton[css_name(SelectViewWidget, "Button")].setValues(
 
 
 # ButtonLineEdit
-from rare.utils.extra_widgets import ButtonLineEdit
+from rare.widgets.button_edit import ButtonLineEdit
 css.QPushButton[css_name(ButtonLineEdit, "Button")].setValues(
     backgroundColor="transparent",
     border="0px",

rare/resources/static_css/stylesheet.qss

@@ -108,10 +108,6 @@ QPushButton#ListWidgetButton {
 QLabel#ListWidgetInfoLabel {
     color: #999;
 }
-QLabel#WaitingSpinner {
-    margin-left: auto;
-    margin-right: auto;
-}
 QPushButton#SelectViewWidgetButton {
     border: none;
     background-color: transparent;

rare/shared/image_manager.py

@@ -2,6 +2,7 @@ import hashlib
 import json
 import pickle
 import zlib
+
 # from concurrent import futures
 from logging import getLogger
 from pathlib import Path
@@ -9,32 +10,24 @@ from typing import TYPE_CHECKING, Optional, Set
 from typing import Tuple, Dict, Union, Type, List, Callable
 
 import requests
-from PyQt5.QtCore import (
-    Qt,
-    pyqtSignal,
-    QObject,
-    QSize,
-    QThreadPool,
-    QRunnable,
-    QRect,
-    QRectF,
-)
-from PyQt5.QtGui import (
-    QPixmap,
-    QImage,
-    QPainter,
-    QPainterPath,
-    QBrush,
-    QTransform,
-    QPen,
-)
+from PyQt5.QtCore import Qt, pyqtSignal, QObject, QSize, QThreadPool, QRunnable, QRect, QRectF, pyqtSlot
+from PyQt5.QtGui import QPixmap, QImage, QPainter, QPainterPath, QBrush, QTransform, QPen
 from PyQt5.QtWidgets import QApplication
 from legendary.models.game import Game
 
 from rare.lgndr.core import LegendaryCore
-from rare.models.image import ImageSize
+from rare.models.image import ImageSize, ImageType
 from rare.models.signals import GlobalSignals
-from rare.utils.paths import image_dir, resources_path, desktop_icon_suffix
+from rare.utils.paths import (
+    image_dir,
+    image_dir_game,
+    image_tall_path,
+    image_wide_path,
+    image_icon_path,
+    resources_path,
+    desktop_icon_suffix,
+    desktop_icon_path,
+)
 
 # from requests_futures.sessions import FuturesSession
 
@@ -66,8 +59,12 @@ class ImageManager(QObject):
 
     def __init__(self, signals: GlobalSignals, core: LegendaryCore):
         # lk: the ordering in __img_types matters for the order of fallbacks
-        # self.__img_types: Tuple = ("DieselGameBoxTall", "Thumbnail", "DieselGameBoxLogo", "DieselGameBox", "OfferImageTall")
-        self.__img_types: Tuple = ("DieselGameBoxTall", "Thumbnail", "DieselGameBoxLogo", "OfferImageTall")
+        # {'AndroidIcon', 'DieselGameBox', 'DieselGameBoxLogo', 'DieselGameBoxTall', 'DieselGameBoxWide',
+        #  'ESRB', 'Featured', 'OfferImageTall', 'OfferImageWide', 'Screenshot', 'Thumbnail'}
+        self.__img_tall_types: Tuple = ("DieselGameBoxTall", "OfferImageTall", "Thumbnail")
+        self.__img_wide_types: Tuple = ("DieselGameBoxWide", "DieselGameBox", "OfferImageWide", "Screenshot")
+        self.__img_logo_types: Tuple = ("DieselGameBoxLogo",)
+        self.__img_types: Tuple = self.__img_tall_types + self.__img_wide_types + self.__img_logo_types
         self.__dl_retries = 1
         self.__worker_app_names: Set[str] = set()
         super(QObject, self).__init__()
@@ -79,36 +76,35 @@ class ImageManager(QObject):
             self.image_dir.mkdir()
             logger.info(f"Created image directory at {self.image_dir}")
 
-        self.device = ImageSize.Preset(1, QApplication.instance().devicePixelRatio())
-
         self.threadpool = QThreadPool()
-        self.threadpool.setMaxThreadCount(4)
+        self.threadpool.setMaxThreadCount(6)
 
-    def __img_dir(self, app_name: str) -> Path:
-        return self.image_dir.joinpath(app_name)
+    @staticmethod
+    def __img_json(app_name: str) -> Path:
+        return image_dir_game(app_name).joinpath("image.json")
 
-    def __img_json(self, app_name: str) -> Path:
-        return self.__img_dir(app_name).joinpath("image.json")
+    @staticmethod
+    def __img_cache(app_name: str) -> Path:
+        return image_dir_game(app_name).joinpath("image.cache")
 
-    def __img_cache(self, app_name: str) -> Path:
-        return self.__img_dir(app_name).joinpath("image.cache")
-
-    def __img_color(self, app_name: str) -> Path:
-        return self.__img_dir(app_name).joinpath("installed.png")
-
-    def __img_gray(self, app_name: str) -> Path:
-        return self.__img_dir(app_name).joinpath("uninstalled.png")
-
-    def __img_desktop_icon(self, app_name: str) -> Path:
-        return self.__img_dir(app_name).joinpath(f"icon.{desktop_icon_suffix()}")
+    @staticmethod
+    def __img_all(app_name: str) -> Tuple:
+        return (
+            image_tall_path(app_name),
+            image_tall_path(app_name, color=False),
+            image_wide_path(app_name),
+            image_wide_path(app_name, color=False),
+            image_icon_path(app_name),
+            image_icon_path(app_name, color=False),
+            desktop_icon_path(app_name),
+        )
 
     def __prepare_download(self, game: Game, force: bool = False) -> Tuple[List, Dict]:
-        if force and self.__img_dir(game.app_name).exists():
-            self.__img_color(game.app_name).unlink(missing_ok=True)
-            self.__img_gray(game.app_name).unlink(missing_ok=True)
-            self.__img_desktop_icon(game.app_name).unlink(missing_ok=True)
-        if not self.__img_dir(game.app_name).is_dir():
-            self.__img_dir(game.app_name).mkdir()
+        if force and image_dir_game(game.app_name).exists():
+            for file in self.__img_all(game.app_name):
+                file.unlink(missing_ok=True)
+        if not image_dir_game(game.app_name).is_dir():
+            image_dir_game(game.app_name).mkdir()
 
         # Load image checksums
         if not self.__img_json(game.app_name).is_file():
@@ -116,39 +112,59 @@ class ImageManager(QObject):
         else:
             json_data = json.load(open(self.__img_json(game.app_name), "r"))
 
+        # Only download the best matching candidate for each image category
+        def best_match(key_images: List, image_types: Tuple) -> Dict:
+            matches = sorted(
+                filter(lambda image: image["type"] in image_types, key_images),
+                key=lambda x: image_types.index(x["type"]) if x["type"] in image_types else len(image_types),
+                reverse=False,
+            )
+            try:
+                best = matches[0]
+            except IndexError as e:
+                best = {}
+            return best
+
+        candidates = tuple(
+            image
+            for image in [
+                best_match(game.metadata.get("keyImages", []), self.__img_tall_types),
+                best_match(game.metadata.get("keyImages", []), self.__img_wide_types),
+                best_match(game.metadata.get("keyImages", []), self.__img_logo_types),
+            ]
+            if bool(image)
+        )
+
         # lk: Find updates or initialize if images are missing.
         # lk: `updates` will be empty for games without images
         # lk: so everything below it is skipped
         updates = []
-        if not (
-            self.__img_color(game.app_name).is_file()
-            and self.__img_gray(game.app_name).is_file()
-            and self.__img_desktop_icon(game.app_name).is_file()
-        ):
+        if not all(file.is_file() for file in self.__img_all(game.app_name)):
             # lk: fast path for games without images, convert Rare's logo
-            if not game.metadata.get("keyImages", []):
+            if not candidates:
                 cache_data: Dict = dict(zip(self.__img_types, [None] * len(self.__img_types)))
-                cache_data["DieselGameBoxTall"] = open(
-                    resources_path.joinpath("images", "cover.png"), "rb"
-                ).read()
+                with open(resources_path.joinpath("images", "cover.png"), "rb") as fd:
+                    cache_data["DieselGameBoxTall"] = fd.read()
+                    fd.seek(0)
+                    cache_data["DieselGameBoxWide"] = fd.read()
                 # cache_data["DieselGameBoxLogo"] = open(
                 #         resources_path.joinpath("images", "Rare_nonsquared.png"), "rb").read()
                 self.__convert(game, cache_data)
                 json_data["cache"] = None
-                json_data["scale"] = ImageSize.Image.pixel_ratio
-                json_data["size"] = ImageSize.Image.size.__str__()
+                json_data["scale"] = ImageSize.Tall.pixel_ratio
+                json_data["size"] = {"w": ImageSize.Tall.size.width(), "h": ImageSize.Tall.size.height()}
                 json.dump(json_data, open(self.__img_json(game.app_name), "w"))
             else:
-                updates = [image for image in game.metadata["keyImages"] if image["type"] in self.__img_types]
+                updates = [image for image in candidates if image["type"] in self.__img_types]
         else:
-            for image in game.metadata.get("keyImages", []):
+            for image in candidates:
                 if image["type"] in self.__img_types:
                     if image["type"] not in json_data.keys() or json_data[image["type"]] != image["md5"]:
                         updates.append(image)
 
         return updates, json_data
 
-    def __download(self, updates, json_data, game, use_async: bool = False) -> bool:
+    def __download(self, updates: List, json_data: Dict, game: Game, use_async: bool = False) -> bool:
         # Decompress existing image.cache
         if not self.__img_cache(game.app_name).is_file():
             cache_data = dict(zip(self.__img_types, [None] * len(self.__img_types)))
@@ -156,32 +172,45 @@ class ImageManager(QObject):
             cache_data = self.__decompress(game)
 
         # lk: filter updates again against the cache now that it is available
-        updates = [
+        # images in cache don't need to be downloaded again.
+        downloads = [
             image
             for image in updates
-            if cache_data.get(image["type"], None) is None or json_data[image["type"]] != image["md5"]
+            if (cache_data.get(image["type"], None) is None or json_data[image["type"]] != image["md5"])
         ]
 
         # Download
         # # lk: Keep this here, so I don't have to go looking for it again,
         # # lk: it might be useful in the future.
-        # if use_async and len(updates) > 1:
+        # if use_async:
         #     session = FuturesSession(max_workers=len(self.__img_types))
         #     image_requests = []
-        #     for image in updates:
+        #     for image in downloads:
         #         logger.info(f"Downloading {image['type']} for {game.app_title}")
         #         json_data[image["type"]] = image["md5"]
-        #         payload = {"resize": 1, "w": ImageSize.Image.size.width(), "h": ImageSize.Image.size.height()}
+        #         if image["type"] in self.__img_tall_types:
+        #             payload = {"resize": 1, "w": ImageSize.Image.size.width(), "h": ImageSize.Image.size.height()}
+        #         elif image["type"] in self.__img_wide_types:
+        #             payload = {"resize": 1, "w": ImageSize.ImageWide.size.width(), "h": ImageSize.ImageWide.size.height()}
+        #         else:
+        #             # Set the larger of the sizes for everything else
+        #             payload = {"resize": 1, "w": ImageSize.ImageWide.size.width(), "h": ImageSize.ImageWide.size.height()}
         #         req = session.get(image["url"], params=payload)
         #         req.image_type = image["type"]
         #         image_requests.append(req)
         #     for req in futures.as_completed(image_requests):
         #         cache_data[req.image_type] = req.result().content
         # else:
-        for image in updates:
+        for image in downloads:
             logger.info(f"Downloading {image['type']} for {game.app_name} ({game.app_title})")
             json_data[image["type"]] = image["md5"]
-            payload = {"resize": 1, "w": ImageSize.Image.size.width(), "h": ImageSize.Image.size.height()}
+            if image["type"] in self.__img_tall_types:
+                payload = {"resize": 1, "w": ImageSize.Tall.size.width(), "h": ImageSize.Tall.size.height()}
+            elif image["type"] in self.__img_wide_types:
+                payload = {"resize": 1, "w": ImageSize.Wide.size.width(), "h": ImageSize.Wide.size.height()}
+            else:
+                # Set the larger of the sizes for everything else
+                payload = {"resize": 1, "w": ImageSize.Wide.size.width(), "h": ImageSize.Wide.size.height()}
             try:
                 # cache_data[image["type"]] = requests.get(image["url"], params=payload).content
                 cache_data[image["type"]] = requests.get(image["url"], params=payload, timeout=10).content
@@ -203,8 +232,8 @@ class ImageManager(QObject):
             archive_hash = None
 
         json_data["cache"] = archive_hash
-        json_data["scale"] = ImageSize.Image.pixel_ratio
-        json_data["size"] = {"w": ImageSize.Image.size.width(), "h": ImageSize.Image.size.height()}
+        json_data["scale"] = ImageSize.Tall.pixel_ratio
+        json_data["size"] = {"w": ImageSize.Tall.size.width(), "h": ImageSize.Tall.size.height()}
 
         # write image.json
         with open(self.__img_json(game.app_name), "w") as file:
@@ -219,13 +248,13 @@ class ImageManager(QObject):
         if ImageManager.__icon_overlay is not None:
             return ImageManager.__icon_overlay
         rounded_path = QPainterPath()
-        margin = 0.1
+        margin = 0.05
         rounded_path.addRoundedRect(
             QRectF(
                 rect.width() * margin,
                 rect.height() * margin,
                 rect.width() - (rect.width() * margin * 2),
-                rect.height() - (rect.width() * margin * 2)
+                rect.height() - (rect.width() * margin * 2),
             ),
             rect.height() * 0.2,
             rect.height() * 0.2,
@@ -244,7 +273,7 @@ class ImageManager(QObject):
         painter.fillRect(icon.rect(), Qt.transparent)
         overlay = ImageManager.__generate_icon_overlay(icon.rect())
         brush = QBrush(cover)
-        scale = max(icon.width()/cover.width(), icon.height()/cover.height())
+        scale = max(icon.width() / cover.width(), icon.height() / cover.height())
         transform = QTransform().scale(scale, scale)
         brush.setTransform(transform)
         painter.fillPath(overlay, brush)
@@ -255,52 +284,68 @@ class ImageManager(QObject):
         return icon
 
     def __convert(self, game, images, force=False) -> None:
-        for image in [self.__img_color(game.app_name), self.__img_gray(game.app_name)]:
-            if force and image.exists():
-                image.unlink(missing_ok=True)
+        for file in self.__img_all(game.app_name):
+            if force and file.exists():
+                file.unlink(missing_ok=True)
 
-        cover_data = None
-        for image_type in self.__img_types:
-            if images[image_type] is not None:
-                cover_data = images[image_type]
-                break
+        def find_image_data(image_types: Tuple):
+            data = None
+            for image_type in image_types:
+                if images.get(image_type, None) is not None:
+                    data = images[image_type]
+                    break
+            return data
 
-        cover = QImage()
-        cover.loadFromData(cover_data)
-        cover.convertToFormat(QImage.Format_ARGB32_Premultiplied)
-        # lk: Images are not always 4/3, crop them to size
-        factor = min(cover.width() // 3, cover.height() // 4)
-        rem_w = (cover.width() - factor * 3) // 2
-        rem_h = (cover.height() - factor * 4) // 2
-        cover = cover.copy(rem_w, rem_h, factor * 3, factor * 4)
+        tall_data = find_image_data(self.__img_tall_types)
+        wide_data = find_image_data(self.__img_wide_types)
+        logo_data = find_image_data(self.__img_logo_types)
 
-        if images["DieselGameBoxLogo"] is not None:
-            logo = QImage()
-            logo.loadFromData(images["DieselGameBoxLogo"])
-            logo.convertToFormat(QImage.Format_ARGB32_Premultiplied)
-            if logo.width() > cover.width():
-                logo = logo.scaled(cover.width(), cover.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
-            painter = QPainter(cover)
-            painter.drawImage((cover.width() - logo.width()) // 2, cover.height() - logo.height(), logo)
-            painter.end()
+        def convert_image(image_data, logo_data, preset: ImageSize.Preset) -> QImage:
+            image = QImage()
+            image.loadFromData(image_data)
+            image.convertToFormat(QImage.Format_ARGB32_Premultiplied)
+            # lk: Images are not always at the correct aspect ratio, so crop them to size
+            wr, hr = preset.aspect_ratio
+            factor = min(image.width() // wr, image.height() // hr)
+            rem_w = (image.width() - factor * wr) // 2
+            rem_h = (image.height() - factor * hr) // 2
+            image = image.copy(rem_w, rem_h, factor * wr, factor * hr)
 
-        cover = cover.scaled(ImageSize.Image.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            if logo_data is not None:
+                logo = QImage()
+                logo.loadFromData(logo_data)
+                logo.convertToFormat(QImage.Format_ARGB32_Premultiplied)
+                if logo.width() > image.width():
+                    logo = logo.scaled(image.width(), image.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                painter = QPainter(image)
+                painter.drawImage((image.width() - logo.width()) // 2, image.height() - logo.height(), logo)
+                painter.end()
 
-        icon = self.__convert_icon(cover)
-        icon.save(str(self.__img_desktop_icon(game.app_name)), format=desktop_icon_suffix().upper())
+            return image.scaled(preset.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
 
-        # this is not required if we ever want to re-apply the alpha channel
-        # cover = cover.convertToFormat(QImage.Format_Indexed8)
+        tall = convert_image(tall_data, logo_data, ImageSize.Tall)
+        wide = convert_image(wide_data, logo_data, ImageSize.Wide)
 
-        # add the alpha channel back to the cover
-        cover = cover.convertToFormat(QImage.Format_ARGB32_Premultiplied)
+        icon = self.__convert_icon(tall)
+        icon.save(desktop_icon_path(game.app_name).as_posix(), format=desktop_icon_suffix().upper())
 
-        cover.save(str(self.__img_color(game.app_name)), format="PNG")
-        # quick way to convert to grayscale
-        cover = cover.convertToFormat(QImage.Format_Grayscale8)
-        # add the alpha channel back to the grayscale cover
-        cover = cover.convertToFormat(QImage.Format_ARGB32_Premultiplied)
-        cover.save(str(self.__img_gray(game.app_name)), format="PNG")
+        def save_image(image: QImage, color_path: Path, gray_path: Path):
+            # this is not required if we ever want to re-apply the alpha channel
+            # image = image.convertToFormat(QImage.Format_Indexed8)
+            # add the alpha channel back to the cover
+            image = image.convertToFormat(QImage.Format_ARGB32_Premultiplied)
+            image.save(color_path.as_posix(), format="PNG")
+            # quick way to convert to grayscale, but keep the alpha channel
+            alpha = image.convertToFormat(QImage.Format_Alpha8)
+            image = image.convertToFormat(QImage.Format_Grayscale8)
+            # add the alpha channel back to the grayscale cover
+            image = image.convertToFormat(QImage.Format_ARGB32_Premultiplied)
+            image.setAlphaChannel(alpha)
+            image.save(gray_path.as_posix(), format="PNG")
+
+        save_image(icon, image_icon_path(game.app_name), image_icon_path(game.app_name, color=False))
+        save_image(tall, image_tall_path(game.app_name), image_tall_path(game.app_name, color=False))
+        save_image(wide, image_wide_path(game.app_name), image_wide_path(game.app_name, color=False))
 
     def __compress(self, game: Game, data: Dict) -> None:
         archive = open(self.__img_cache(game.app_name), "wb")
@@ -319,22 +364,41 @@ class ImageManager(QObject):
             archive.close()
         return data
 
+    def __append_to_queue(self, game: Game):
+        self.__worker_app_names.add(game.app_name)
+
+    @pyqtSlot(object)
+    def __remove_from_queue(self, game: Game):
+        self.__worker_app_names.remove(game.app_name)
+
     def download_image(
-        self, game: Game, load_callback: Callable[[], None], priority: int, force: bool = False
+            self, game: Game, load_callback: Callable[[], None], priority: int, force: bool = False
     ) -> None:
         if game.app_name in self.__worker_app_names:
             return
-        self.__worker_app_names.add(game.app_name)
+        self.__append_to_queue(game)
         updates, json_data = self.__prepare_download(game, force)
         if not updates:
-            self.__worker_app_names.remove(game.app_name)
+            self.__remove_from_queue(game)
             load_callback()
         else:
-            image_worker = ImageManager.Worker(self.__download, updates, json_data, game)
-            image_worker.signals.completed.connect(lambda g: self.__worker_app_names.remove(g.app_name))
+            # Copy the data because we are going to be a thread and we modify them later on
+            image_worker = ImageManager.Worker(self.__download, updates.copy(), json_data.copy(), game)
+            image_worker.signals.completed.connect(self.__remove_from_queue)
             image_worker.signals.completed.connect(load_callback)
             self.threadpool.start(image_worker, priority)
 
+    def download_image_launch(
+            self, game: Game, callback: Callable[[Game], None], priority: int, force: bool = False
+    ) -> None:
+        if self.__img_cache(game.app_name).is_file() and not force:
+            return
+
+        def _callback():
+            callback(game)
+
+        self.download_image(game, _callback, priority, force)
+
     def download_image_blocking(self, game: Game, force: bool = False) -> None:
         updates, json_data = self.__prepare_download(game, force)
         if not updates:
@@ -342,44 +406,56 @@ class ImageManager(QObject):
         if updates:
             self.__download(updates, json_data, game, use_async=True)
 
+    @staticmethod
     def __get_cover(
-        self, container: Union[Type[QPixmap], Type[QImage]], app_name: str, color: bool = True
+            container: Union[Type[QPixmap], Type[QImage]], app_name: str, preset: ImageSize.Preset, color: bool,
     ) -> Union[QPixmap, QImage]:
         ret = container()
-        if not app_name:
-            raise RuntimeError("app_name is an empty string")
-        if color:
-            if self.__img_color(app_name).is_file():
-                ret.load(str(self.__img_color(app_name)))
+        if preset.orientation == ImageType.Icon:
+            if image_icon_path(app_name, color).is_file():
+                ret.load(image_icon_path(app_name, color).as_posix())
+        elif preset.orientation == ImageType.Tall:
+            if image_tall_path(app_name, color).is_file():
+                ret.load(image_tall_path(app_name, color).as_posix())
+        elif preset.orientation == ImageType.Wide:
+            if image_wide_path(app_name, color).is_file():
+                ret.load(image_wide_path(app_name, color).as_posix())
         else:
-            if self.__img_gray(app_name).is_file():
-                ret.load(str(self.__img_gray(app_name)))
+            raise RuntimeError("Unknown image preset")
         if not ret.isNull():
-            ret.setDevicePixelRatio(ImageSize.Image.pixel_ratio)
+            device = ImageSize.Preset(
+                divisor=preset.base.divisor,
+                pixel_ratio=QApplication.instance().devicePixelRatio(),
+                orientation=preset.base.orientation,
+                base=preset
+            )
+            ret.setDevicePixelRatio(preset.pixel_ratio)
             # lk: Scaling happens at painting. It might be inefficient so leave this here as an alternative
             # lk: If this is uncommented, the transformation in ImageWidget should be adjusted also
-            ret = ret.scaled(self.device.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-            ret.setDevicePixelRatio(self.device.pixel_ratio)
+            ret = ret.scaled(device.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            ret.setDevicePixelRatio(device.pixel_ratio)
         return ret
 
-    def get_pixmap(self, app_name: str, color: bool = True) -> QPixmap:
+    def get_pixmap(self, app_name: str, preset: ImageSize.Preset, color: bool = True) -> QPixmap:
         """
         Use when the image is to be presented directly on the screen.
 
         @param app_name: The RareGame object for this game
+        @param preset:
         @param color: True to load the colored pixmap, False to load the grayscale
         @return: QPixmap
         """
-        pixmap: QPixmap = self.__get_cover(QPixmap, app_name, color)
+        pixmap: QPixmap = self.__get_cover(QPixmap, app_name, preset, color)
         return pixmap
 
-    def get_image(self, app_name: str, color: bool = True) -> QImage:
+    def get_image(self, app_name: str, preset: ImageSize.Preset, color: bool = True) -> QImage:
         """
         Use when the image has to be manipulated before being rendered.
 
         @param app_name: The RareGame object for this game
+        @param preset:
         @param color: True to load the colored image, False to load the grayscale
         @return: QImage
         """
-        image: QImage = self.__get_cover(QImage, app_name, color)
+        image: QImage = self.__get_cover(QImage, app_name, preset, color)
         return image

rare/shared/rare_core.py

@@ -17,6 +17,7 @@ from rare.models.game import RareGame, RareEosOverlay
 from rare.models.signals import GlobalSignals
 from rare.utils.metrics import timelogger
 from rare.utils import config_helper
+from rare.utils.steam_shortcuts import load_steam_shortcuts
 from .image_manager import ImageManager
 from .workers import (
     QueueWorker,
@@ -282,12 +283,19 @@ class RareCore(QObject):
     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.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.launched.connect(self.__signals.application.update_tray)
+        rgame.signals.game.launched.connect(self.__signals.discord_rpc.update_presence)
+
         rgame.signals.game.finished.connect(self.__signals.application.update_tray)
-        rgame.signals.game.finished.connect(lambda: self.__signals.discord_rpc.set_title.emit(""))
+        rgame.signals.game.finished.connect(self.__signals.discord_rpc.remove_presence)
+
         self.__library[rgame.app_name] = rgame
 
     def __filter_games(self, condition: Callable[[RareGame], bool]) -> Iterator[RareGame]:
@@ -347,6 +355,7 @@ class RareCore(QObject):
             self.__wrappers.import_wrappers(
                 self.__core, self.__settings, [rgame.app_name for rgame in self.games]
             )
+            load_steam_shortcuts()
             self.progress.emit(100, self.tr("Launching Rare"))
             self.completed.emit()
             QTimer.singleShot(100, self.__post_init)

rare/shared/workers/wine_resolver.py

@@ -157,17 +157,17 @@ class OriginWineWorker(WinePathResolver):
                     if install_dir:
                         logger.debug("Found Unix install directory %s", install_dir)
                     else:
-                        logger.info("Could not find Unix install directory for %s", rgame.app_title)
+                        logger.info("Could not find Unix install directory for '%s'", rgame.app_title)
                 else:
-                    logger.info("Could not find Wine install directory for %s", rgame.app_title)
+                    logger.info("Could not find Wine install directory for '%s'", rgame.app_title)
 
             if install_dir:
                 if os.path.isdir(install_dir):
                     install_size = path_size(install_dir)
                     rgame.set_origin_attributes(install_dir, install_size)
-                    logger.info("Origin game %s (%s, %s)", rgame.app_title, install_dir, format_size(install_size))
+                    logger.info("Origin game '%s' (%s, %s)", rgame.app_title, install_dir, format_size(install_size))
                 else:
-                    logger.warning("Origin game %s (%s does not exist)", rgame.app_title, install_dir)
+                    logger.warning("Origin game '%s' (%s does not exist)", rgame.app_title, install_dir)
             else:
-                logger.info("Origin game %s is not installed", rgame.app_title)
+                logger.info("Origin game '%s' is not installed", rgame.app_title)
         logger.info("Origin worker finished in %ss", time.time() - t)

rare/ui/components/tabs/settings/rare.py

@@ -16,8 +16,8 @@ class Ui_RareSettings(object):
         RareSettings.setObjectName("RareSettings")
         RareSettings.resize(629, 447)
         RareSettings.setWindowTitle("RareSettings")
-        self.rare_layout = QtWidgets.QHBoxLayout(RareSettings)
-        self.rare_layout.setObjectName("rare_layout")
+        self.main_layout = QtWidgets.QHBoxLayout(RareSettings)
+        self.main_layout.setObjectName("main_layout")
         self.left_layout = QtWidgets.QVBoxLayout()
         self.left_layout.setObjectName("left_layout")
         self.interface_group = QtWidgets.QGroupBox(RareSettings)
@@ -93,7 +93,7 @@ class Ui_RareSettings(object):
         self.left_layout.addWidget(self.settings_group)
         spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
         self.left_layout.addItem(spacerItem1)
-        self.rare_layout.addLayout(self.left_layout)
+        self.main_layout.addLayout(self.left_layout)
         self.right_layout = QtWidgets.QVBoxLayout()
         self.right_layout.setObjectName("right_layout")
         self.log_dir_group = QtWidgets.QGroupBox(RareSettings)
@@ -130,7 +130,7 @@ class Ui_RareSettings(object):
         self.right_layout.addWidget(self.groupBox)
         spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
         self.right_layout.addItem(spacerItem2)
-        self.rare_layout.addLayout(self.right_layout)
+        self.main_layout.addLayout(self.right_layout)
 
         self.retranslateUi(RareSettings)
 
@@ -145,7 +145,7 @@ class Ui_RareSettings(object):
         self.settings_group.setTitle(_translate("RareSettings", "Behavior"))
         self.save_size.setText(_translate("RareSettings", "Restore window size on application startup"))
         self.notification.setText(_translate("RareSettings", "Show notifications when downloads complete"))
-        self.log_games.setText(_translate("RareSettings", "Show console windows when launching games"))
+        self.log_games.setText(_translate("RareSettings", "Show console window when launching games"))
         self.sys_tray.setText(_translate("RareSettings", "Exit to system tray"))
         self.auto_update.setText(_translate("RareSettings", "Queue game updates on application startup"))
         self.confirm_start.setText(_translate("RareSettings", "Confirm before launching games"))

rare/ui/components/tabs/settings/rare.ui

@@ -13,7 +13,7 @@
   <property name="windowTitle">
    <string notr="true">RareSettings</string>
   </property>
-  <layout class="QHBoxLayout" name="rare_layout">
+  <layout class="QHBoxLayout" name="main_layout">
    <item>
     <layout class="QVBoxLayout" name="left_layout">
      <item>
@@ -115,7 +115,7 @@
         <item row="6" column="0">
          <widget class="QCheckBox" name="log_games">
           <property name="text">
-           <string>Show console windows when launching games</string>
+           <string>Show console window when launching games</string>
           </property>
          </widget>
         </item>

rare/ui/components/tabs/settings/widgets/discord_rpc.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'rare/ui/components/tabs/settings/widgets/discord_rpc.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.10
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_DiscordRPCSettings(object):
+    def setupUi(self, DiscordRPCSettings):
+        DiscordRPCSettings.setObjectName("DiscordRPCSettings")
+        DiscordRPCSettings.resize(370, 149)
+        DiscordRPCSettings.setWindowTitle("DiscordRPCSettings")
+        self.main_layout = QtWidgets.QGridLayout(DiscordRPCSettings)
+        self.main_layout.setObjectName("main_layout")
+        self.enable = QtWidgets.QComboBox(DiscordRPCSettings)
+        self.enable.setObjectName("enable")
+        self.enable.addItem("")
+        self.enable.addItem("")
+        self.enable.addItem("")
+        self.main_layout.addWidget(self.enable, 0, 1, 1, 1)
+        self.label = QtWidgets.QLabel(DiscordRPCSettings)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.label.sizePolicy().hasHeightForWidth())
+        self.label.setSizePolicy(sizePolicy)
+        self.label.setObjectName("label")
+        self.main_layout.addWidget(self.label, 0, 0, 1, 1)
+        self.show_game = QtWidgets.QCheckBox(DiscordRPCSettings)
+        self.show_game.setObjectName("show_game")
+        self.main_layout.addWidget(self.show_game, 1, 0, 1, 2)
+        self.show_os = QtWidgets.QCheckBox(DiscordRPCSettings)
+        self.show_os.setObjectName("show_os")
+        self.main_layout.addWidget(self.show_os, 2, 0, 1, 2)
+        self.show_time = QtWidgets.QCheckBox(DiscordRPCSettings)
+        self.show_time.setObjectName("show_time")
+        self.main_layout.addWidget(self.show_time, 3, 0, 1, 2)
+
+        self.retranslateUi(DiscordRPCSettings)
+
+    def retranslateUi(self, DiscordRPCSettings):
+        _translate = QtCore.QCoreApplication.translate
+        DiscordRPCSettings.setTitle(_translate("DiscordRPCSettings", "Discord RPC"))
+        self.enable.setItemText(0, _translate("DiscordRPCSettings", "When Playing"))
+        self.enable.setItemText(1, _translate("DiscordRPCSettings", "Always"))
+        self.enable.setItemText(2, _translate("DiscordRPCSettings", "Never"))
+        self.label.setText(_translate("DiscordRPCSettings", "Show"))
+        self.show_game.setText(_translate("DiscordRPCSettings", "Show Game"))
+        self.show_os.setText(_translate("DiscordRPCSettings", "Show OS"))
+        self.show_time.setText(_translate("DiscordRPCSettings", "Show Time playing"))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    DiscordRPCSettings = QtWidgets.QGroupBox()
+    ui = Ui_DiscordRPCSettings()
+    ui.setupUi(DiscordRPCSettings)
+    DiscordRPCSettings.show()
+    sys.exit(app.exec_())

rare/ui/components/tabs/settings/widgets/discord_rpc.ui

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>DiscordRPCSettings</class>
+ <widget class="QGroupBox" name="DiscordRPCSettings">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>370</width>
+    <height>149</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string notr="true">DiscordRPCSettings</string>
+  </property>
+  <property name="title">
+   <string>Discord RPC</string>
+  </property>
+  <layout class="QGridLayout" name="main_layout">
+   <item row="0" column="1">
+    <widget class="QComboBox" name="enable">
+     <item>
+      <property name="text">
+       <string>When Playing</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Always</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Never</string>
+      </property>
+     </item>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Show</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="2">
+    <widget class="QCheckBox" name="show_game">
+     <property name="text">
+      <string>Show Game</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0" colspan="2">
+    <widget class="QCheckBox" name="show_os">
+     <property name="text">
+      <string>Show OS</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0" colspan="2">
+    <widget class="QCheckBox" name="show_time">
+     <property name="text">
+      <string>Show Time playing</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

rare/ui/components/tabs/settings/widgets/rpc.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Form implementation generated from reading ui file 'rare/ui/components/tabs/settings/widgets/rpc.ui'
-#
-# Created by: PyQt5 UI code generator 5.15.6
-#
-# WARNING: Any manual changes made to this file will be lost when pyuic5 is
-# run again.  Do not edit this file unless you know what you are doing.
-
-
-from PyQt5 import QtCore, QtGui, QtWidgets
-
-
-class Ui_RPCSettings(object):
-    def setupUi(self, RPCSettings):
-        RPCSettings.setObjectName("RPCSettings")
-        RPCSettings.resize(174, 146)
-        RPCSettings.setWindowTitle("DiscordRPC")
-        self.layout = QtWidgets.QGridLayout(RPCSettings)
-        self.layout.setObjectName("layout")
-        self.enable = QtWidgets.QComboBox(RPCSettings)
-        self.enable.setObjectName("enable")
-        self.enable.addItem("")
-        self.enable.addItem("")
-        self.enable.addItem("")
-        self.layout.addWidget(self.enable, 0, 1, 1, 1)
-        self.label = QtWidgets.QLabel(RPCSettings)
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Preferred)
-        sizePolicy.setHorizontalStretch(0)
-        sizePolicy.setVerticalStretch(0)
-        sizePolicy.setHeightForWidth(self.label.sizePolicy().hasHeightForWidth())
-        self.label.setSizePolicy(sizePolicy)
-        self.label.setObjectName("label")
-        self.layout.addWidget(self.label, 0, 0, 1, 1)
-        self.show_game = QtWidgets.QCheckBox(RPCSettings)
-        self.show_game.setObjectName("show_game")
-        self.layout.addWidget(self.show_game, 1, 0, 1, 2)
-        self.show_os = QtWidgets.QCheckBox(RPCSettings)
-        self.show_os.setObjectName("show_os")
-        self.layout.addWidget(self.show_os, 2, 0, 1, 2)
-        self.show_time = QtWidgets.QCheckBox(RPCSettings)
-        self.show_time.setObjectName("show_time")
-        self.layout.addWidget(self.show_time, 3, 0, 1, 2)
-
-        self.retranslateUi(RPCSettings)
-
-    def retranslateUi(self, RPCSettings):
-        _translate = QtCore.QCoreApplication.translate
-        RPCSettings.setTitle(_translate("RPCSettings", "Discord RPC"))
-        self.enable.setItemText(0, _translate("RPCSettings", "When Playing"))
-        self.enable.setItemText(1, _translate("RPCSettings", "Always"))
-        self.enable.setItemText(2, _translate("RPCSettings", "Never"))
-        self.label.setText(_translate("RPCSettings", "Show"))
-        self.show_game.setText(_translate("RPCSettings", "Show Game"))
-        self.show_os.setText(_translate("RPCSettings", "Show OS"))
-        self.show_time.setText(_translate("RPCSettings", "Show Time playing"))
-
-
-if __name__ == "__main__":
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    RPCSettings = QtWidgets.QGroupBox()
-    ui = Ui_RPCSettings()
-    ui.setupUi(RPCSettings)
-    RPCSettings.show()
-    sys.exit(app.exec_())

rare/ui/components/tabs/settings/widgets/rpc.ui

@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
-    <class>RPCSettings</class>
-    <widget class="QGroupBox" name="RPCSettings">
-        <property name="geometry">
-            <rect>
-                <x>0</x>
-                <y>0</y>
-                <width>174</width>
-                <height>146</height>
-            </rect>
-        </property>
-        <property name="windowTitle">
-            <string notr="true">DiscordRPC</string>
-        </property>
-        <property name="title">
-            <string>Discord RPC</string>
-        </property>
-        <layout class="QGridLayout" name="layout">
-            <item row="0" column="1">
-                <widget class="QComboBox" name="enable">
-                    <item>
-                        <property name="text">
-                            <string>When Playing</string>
-                        </property>
-                    </item>
-                    <item>
-                        <property name="text">
-                            <string>Always</string>
-                        </property>
-                    </item>
-                    <item>
-                        <property name="text">
-                            <string>Never</string>
-                        </property>
-                    </item>
-                </widget>
-            </item>
-            <item row="0" column="0">
-                <widget class="QLabel" name="label">
-                    <property name="sizePolicy">
-                        <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
-                            <horstretch>0</horstretch>
-                            <verstretch>0</verstretch>
-                        </sizepolicy>
-                    </property>
-                    <property name="text">
-                        <string>Show</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="0" colspan="2">
-                <widget class="QCheckBox" name="show_game">
-                    <property name="text">
-                        <string>Show Game</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="2" column="0" colspan="2">
-                <widget class="QCheckBox" name="show_os">
-                    <property name="text">
-                        <string>Show OS</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="3" column="0" colspan="2">
-                <widget class="QCheckBox" name="show_time">
-                    <property name="text">
-                        <string>Show Time playing</string>
-                    </property>
-                </widget>
-            </item>
-        </layout>
-    </widget>
-    <resources/>
-    <connections/>
-</ui>

rare/utils/compat/steam.py

@@ -10,19 +10,19 @@ import vdf
 
 logger = getLogger("SteamTools")
 
-steam_compat_client_install_paths = [os.path.expanduser("~/.local/share/Steam")]
+steam_client_install_paths = [os.path.expanduser("~/.local/share/Steam")]
 
 
 def find_steam() -> Optional[str]:
     # return the first valid path
-    for path in steam_compat_client_install_paths:
+    for path in steam_client_install_paths:
         if os.path.isdir(path) and os.path.isfile(os.path.join(path, "steam.sh")):
             return path
     return None
 
 
 def find_libraries(steam_path: str) -> Set[str]:
-    vdf_path = os.path.join(steam_path, "steamapps", "libraryfolders.vdf")
+    vdf_path = os.path.join(steam_path, "config", "libraryfolders.vdf")
     with open(vdf_path, "r") as f:
         libraryfolders = vdf.load(f)["libraryfolders"]
     # libraries = [os.path.join(folder["path"], "steamapps") for key, folder in libraryfolders.items()]
@@ -157,7 +157,6 @@ def find_runtimes(steam_path: str, library: str) -> Dict[str, SteamRuntime]:
             with open(vdf_file, "r") as f:
                 toolmanifest = vdf.load(f)
                 if toolmanifest["manifest"]["compatmanager_layer_name"] == "container-runtime":
-                    print(toolmanifest["manifest"])
                     runtimes.update(
                         {
                             appmanifest["AppState"]["appid"]: SteamRuntime(

rare/utils/compat/utils.py

@@ -1,5 +1,5 @@
 import os
-import platform
+import platform as pf
 import subprocess
 from configparser import ConfigParser
 from logging import getLogger
@@ -8,9 +8,9 @@ from typing import Mapping, Dict, List, Tuple
 from PyQt5.QtCore import QProcess, QProcessEnvironment
 
 from rare.utils import config_helper as config
-if platform.system() != "Windows":
+if pf.system() != "Windows":
     from . import wine
-    if platform.system() != "Darwin":
+    if pf.system() in {"Linux", "FreeBSD"}:
         from . import steam
 
 logger = getLogger("CompatUtils")
@@ -29,7 +29,7 @@ def read_registry(registry: str, prefix: str) -> ConfigParser:
 
 
 def get_configured_qprocess(command: List[str], environment: Mapping) -> QProcess:
-    logger.debug("Executing command:  %s", command)
+    logger.debug("Executing command: %s", command)
     proc = QProcess()
     proc.setProcessChannelMode(QProcess.SeparateChannels)
     penv = QProcessEnvironment()
@@ -42,7 +42,7 @@ def get_configured_qprocess(command: List[str], environment: Mapping) -> QProces
 
 
 def get_configured_subprocess(command: List[str], environment: Mapping) -> subprocess.Popen:
-    logger.debug("Executing command:  %s", command)
+    logger.debug("Executing command: %s", command)
     return subprocess.Popen(
         command,
         stdin=None,
@@ -90,8 +90,7 @@ def execute(command: List[str], arguments: List[str], environment: Mapping) -> T
     # In flatpak our environment is passed through `flatpak-spawn` arguments
     if os.environ.get("container") == "flatpak":
         flatpak_command = ["flatpak-spawn", "--host"]
-        for name, value in environment.items():
-            flatpak_command.append(f"--env={name}={value}")
+        flatpak_command.extend(f"--env={name}={value}" for name, value in environment.items())
         _command = flatpak_command + command
         _environment = os.environ.copy()
     else:

rare/utils/discord_rpc.py

@@ -1,39 +1,47 @@
 import platform
 import time
 from logging import getLogger
+from typing import List
 
-import pypresence.exceptions
-from PyQt5.QtCore import QObject, QSettings
-from pypresence import Presence
+from PyQt5.QtCore import QObject, QSettings, pyqtSlot
+from pypresence import Presence, exceptions
 
-from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton
 from rare.models.options import options
+from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton
 
 client_id = "830732538225360908"
-logger = getLogger("RPC")
+logger = getLogger("DiscordRPC")
 
 
 class DiscordRPC(QObject):
     def __init__(self):
         super(DiscordRPC, self).__init__()
-        self.RPC = None
+        self.rpc = None
         self.state = 1  # 0: game, 1: always active, 2: off
         self.core = LegendaryCoreSingleton()
         self.signals = GlobalSignalsSingleton()
 
         self.settings = QSettings()
-        if self.settings.value(*options.rpc_enable) == 1:  # show always
+        if self.settings.value(*options.discord_rpc_mode) == 1:  # show always
             self.state = 2
             self.set_discord_rpc()
 
-        self.signals.discord_rpc.set_title.connect(self.update_presence)
-        self.signals.discord_rpc.apply_settings.connect(self.changed_settings)
+        self.signals.discord_rpc.update_presence.connect(self.update_presence)
+        self.signals.discord_rpc.remove_presence.connect(self.remove_presence)
+        self.signals.discord_rpc.update_settings.connect(self.update_settings)
 
-    def update_presence(self, app_name):
+    @pyqtSlot(str)
+    def update_presence(self, app_name: str):
         self.set_discord_rpc(app_name)
 
-    def changed_settings(self, game_running: list = None):
-        value = self.settings.value(*options.rpc_enable)
+    @pyqtSlot(str)
+    def remove_presence(self, app_name: str):
+        self.set_discord_rpc(None)
+
+    @pyqtSlot()
+    @pyqtSlot(list)
+    def update_settings(self, game_running: List = None):
+        value = self.settings.value(*options.discord_rpc_mode)
         if value == 2:
             self.remove_rpc()
             return
@@ -45,15 +53,15 @@ class DiscordRPC(QObject):
             self.set_discord_rpc(game_running[0])
 
     def remove_rpc(self):
-        if self.settings.value(*options.rpc_enable) != 1:
-            if not self.RPC:
+        if self.settings.value(*options.discord_rpc_mode) != 1:
+            if not self.rpc:
                 return
             try:
-                self.RPC.close()
+                self.rpc.close()
             except Exception:
                 logger.warning("Already closed")
-            del self.RPC
-            self.RPC = None
+            del self.rpc
+            self.rpc = None
             logger.info("Remove RPC")
             self.state = 2
         else:
@@ -61,56 +69,50 @@ class DiscordRPC(QObject):
             self.set_discord_rpc()
 
     def set_discord_rpc(self, app_name=None):
-        if not self.RPC:
+        if not self.rpc:
             try:
-                self.RPC = Presence(
-                    client_id
-                )  # Rare app: https://discord.com/developers/applications
-                self.RPC.connect()
+                self.rpc = Presence(client_id)  # Rare app: https://discord.com/developers/applications
+                self.rpc.connect()
             except ConnectionRefusedError as e:
                 logger.warning(f"Discord is not active\n{e}")
-                self.RPC = None
+                self.rpc = None
                 return
             except FileNotFoundError as e:
                 logger.warning(f"File not found error\n{e}")
-                self.RPC = None
+                self.rpc = None
                 return
-            except pypresence.exceptions.InvalidPipe as e:
+            except exceptions.InvalidPipe as e:
                 logger.error(f"Is Discord running? \n{e}")
-                self.RPC = None
+                self.rpc = None
                 return
             except Exception as e:
                 logger.error(str(e))
-                self.RPC = None
+                self.rpc = None
                 return
         self.update_rpc(app_name)
 
     def update_rpc(self, app_name=None):
-        if self.settings.value(*options.rpc_enable) == 2 or (
-                not app_name and self.settings.value(*options.rpc_enable) == 0
+        if self.settings.value(*options.discord_rpc_mode) == 2 or (
+            not app_name and self.settings.value(*options.discord_rpc_mode) == 0
         ):
             self.remove_rpc()
             return
         title = None
         if not app_name:
-            self.RPC.update(
-                large_image="logo", details="https://github.com/RareDevs/Rare"
-            )
+            self.rpc.update(large_image="logo", details="https://github.com/RareDevs/Rare")
             return
-        if self.settings.value(*options.rpc_name):
+        if self.settings.value(*options.discord_rpc_game):
             try:
                 title = self.core.get_installed_game(app_name).title
             except AttributeError:
                 logger.error(f"Could not get title of game: {app_name}")
                 title = app_name
         start = None
-        if self.settings.value(*options.rpc_time):
+        if self.settings.value(*options.discord_rpc_time):
             start = str(time.time()).split(".")[0]
         os = None
-        if self.settings.value(*options.rpc_os):
+        if self.settings.value(*options.discord_rpc_os):
             os = f"via Rare on {platform.system()}"
 
-        self.RPC.update(
-            large_image="logo", details=title, large_text=title, state=os, start=start
-        )
+        self.rpc.update(large_image="logo", details=title, large_text=title, state=os, start=start)
         self.state = 0

rare/utils/extra_widgets.py

@@ -1,147 +0,0 @@
-from logging import getLogger
-
-from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtGui import QPixmap, QImage, QMovie
-from PyQt5.QtWidgets import (
-    QStyle,
-    QLabel,
-    QHBoxLayout,
-    QWidget,
-    QPushButton,
-    QLineEdit,
-)
-
-from rare.utils.misc import qta_icon
-from rare.utils.paths import cache_dir
-from rare.utils.qt_requests import QtRequests
-
-logger = getLogger("ExtraWidgets")
-
-# FIXME: move this?
-class WaitingSpinner(QLabel):
-    def __init__(self, parent=None):
-        super(WaitingSpinner, self).__init__(parent=parent)
-        self.setObjectName(type(self).__name__)
-        self.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
-        self.movie = QMovie(":/images/loader.gif")
-        self.setMovie(self.movie)
-        self.movie.start()
-
-
-class SelectViewWidget(QWidget):
-    toggled = pyqtSignal(bool)
-
-    def __init__(self, icon_view: bool, parent=None):
-        super(SelectViewWidget, self).__init__(parent=parent)
-        self.icon_button = QPushButton(self)
-        self.icon_button.setObjectName(f"{type(self).__name__}Button")
-        self.list_button = QPushButton(self)
-        self.list_button.setObjectName(f"{type(self).__name__}Button")
-
-        if icon_view:
-            self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="orange"))
-            self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="#eee"))
-        else:
-            self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="#eee"))
-            self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="orange"))
-
-        self.icon_button.clicked.connect(self.icon)
-        self.list_button.clicked.connect(self.list)
-
-        layout = QHBoxLayout()
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.addWidget(self.icon_button)
-        layout.addWidget(self.list_button)
-
-        self.setLayout(layout)
-
-    def icon(self):
-        self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="orange"))
-        self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="#eee"))
-        self.toggled.emit(True)
-
-    def list(self):
-        self.icon_button.setIcon(qta_icon("mdi.view-grid-outline", "ei.th-large", color="#eee"))
-        self.list_button.setIcon(qta_icon("fa5s.list", "ei.th-list", color="orange"))
-        self.toggled.emit(False)
-
-
-class ImageLabel(QLabel):
-    image = None
-    img_size = None
-    name = ""
-
-    def __init__(self, parent=None):
-        super(ImageLabel, self).__init__(parent=parent)
-        self.manager = QtRequests(
-            cache=str(cache_dir().joinpath("store")),
-            parent=self
-        )
-
-    def update_image(self, url, name="", size: tuple = (240, 320)):
-        self.setFixedSize(*size)
-        self.img_size = size
-        self.name = name
-        for c in r'<>?":|\/* ':
-            self.name = self.name.replace(c, "")
-        if self.img_size[0] > self.img_size[1]:
-            name_extension = "wide"
-        else:
-            name_extension = "tall"
-        self.name = f"{self.name}_{name_extension}.png"
-        self.manager.get(url, self.image_ready)
-
-    def image_ready(self, data):
-        try:
-            self.setPixmap(QPixmap())
-        except Exception:
-            logger.warning("C++ object already removed, when image ready")
-            return
-        image = QImage()
-        image.loadFromData(data)
-        image = image.scaled(
-            *self.img_size[:2],
-            Qt.KeepAspectRatio,
-            transformMode=Qt.SmoothTransformation,
-        )
-
-        pixmap = QPixmap().fromImage(image)
-        self.setPixmap(pixmap)
-
-
-class ButtonLineEdit(QLineEdit):
-    buttonClicked = pyqtSignal()
-
-    def __init__(self, icon_name, placeholder_text: str, parent=None):
-        super(ButtonLineEdit, self).__init__(parent=parent)
-        self.setObjectName(type(self).__name__)
-
-        self.button = QPushButton(self)
-        self.button.setObjectName(f"{type(self).__name__}Button")
-        self.button.setIcon(qta_icon(icon_name))
-        self.button.setCursor(Qt.ArrowCursor)
-        self.button.clicked.connect(self.buttonClicked.emit)
-
-        self.setPlaceholderText(placeholder_text)
-        # frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
-        # button_size = self.button.sizeHint()
-        #
-        # self.setStyleSheet(
-        #     f"QLineEdit#{self.objectName()} {{padding-right: {(button_size.width() + frame_width + 1)}px; }}"
-        # )
-        # self.setMinimumSize(
-        #     max(self.minimumSizeHint().width(), button_size.width() + frame_width * 2 + 2),
-        #     max(
-        #         self.minimumSizeHint().height(),
-        #         button_size.height() + frame_width * 2 + 2,
-        #     ),
-        # )
-
-    def resizeEvent(self, event):
-        frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
-        button_size = self.button.sizeHint()
-        self.button.move(
-            self.rect().right() - frame_width - button_size.width(),
-            (self.rect().bottom() - button_size.height() + 1) // 2,
-        )
-        super(ButtonLineEdit, self).resizeEvent(event)

rare/utils/json_formatter.py

@@ -280,29 +280,29 @@ if __name__ == "__main__":
     view.setModel(model)
 
     document = json.loads(
-        """\
-    {
-        "firstName": "John",
-        "lastName": "Smith",
-        "age": 25,
-        "address": {
-            "streetAddress": "21 2nd Street",
-            "city": "New York",
-            "state": "NY",
-            "postalCode": "10021"
-        },
-        "phoneNumber": [
-            {
-                "type": "home",
-                "number": "212 555-1234"
+        """
+        {
+            "firstName": "John",
+            "lastName": "Smith",
+            "age": 25,
+            "address": {
+                "streetAddress": "21 2nd Street",
+                "city": "New York",
+                "state": "NY",
+                "postalCode": "10021"
             },
-            {
-                "type": "fax",
-                "number": "646 555-4567"
-            }
-        ]
-    }
-    """
+            "phoneNumber": [
+                {
+                    "type": "home",
+                    "number": "212 555-1234"
+                },
+                {
+                    "type": "fax",
+                    "number": "646 555-4567"
+                }
+            ]
+        }
+        """
     )
 
     model.load(document)
@@ -310,9 +310,7 @@ if __name__ == "__main__":
     model.load(document)
 
     # Sanity check
-    assert json.dumps(model.json(), sort_keys=True) == json.dumps(
-        document, sort_keys=True
-    )
+    assert json.dumps(model.json(), sort_keys=True) == json.dumps(document, sort_keys=True)
 
     view.show()
     view.resize(500, 300)

rare/utils/paths.py

@@ -55,6 +55,22 @@ def image_dir() -> Path:
     return data_dir().joinpath("images")
 
 
+def image_dir_game(app_name: str) -> Path:
+    return image_dir().joinpath(app_name)
+
+
+def image_tall_path(app_name: str, color: bool = True) -> Path:
+    return image_dir_game(app_name).joinpath("tall.png" if color else "tall_gray.png")
+
+
+def image_wide_path(app_name: str, color: bool = True) -> Path:
+    return image_dir_game(app_name).joinpath("wide.png" if color else "wide_gray.png")
+
+
+def image_icon_path(app_name: str, color: bool = True) -> Path:
+    return image_dir_game(app_name).joinpath("icon.png" if color else "icon_gray.png")
+
+
 def log_dir() -> Path:
     return cache_dir().joinpath("logs")
 
@@ -105,19 +121,25 @@ __link_suffix = {
         "icon": "png",
     },
     "Darwin": {
-         "link": "",
-         "icon": "icns",
+        "link": "",
+        "icon": "icns",
     },
 }
 
+
 def desktop_links_supported() -> bool:
     supported_systems = [k for (k, v) in __link_suffix.items() if v["link"]]
     return platform.system() in supported_systems
 
+
 def desktop_icon_suffix() -> str:
     return __link_suffix[platform.system()]["icon"]
 
 
+def desktop_icon_path(app_name: str) -> Path:
+    return image_dir_game(app_name).joinpath(f"desktop_icon.{desktop_icon_suffix()}")
+
+
 __link_type = {
     "desktop": desktop_dir(),
     # lk: for some undocumented reason, on Windows we used the parent directory
@@ -125,8 +147,11 @@ __link_type = {
     "start_menu": applications_dir().parent if platform.system() == "Windows" else applications_dir(),
 }
 
+
 def desktop_link_types() -> List:
     return list(__link_type.keys())
+
+
 # fmt: on
 
 
@@ -212,7 +237,7 @@ def create_desktop_link(app_name: str, app_title: str = "", link_name: str = "",
         app_title = "Rare"
         link_name = "Rare"
     else:
-        icon_path = image_dir().joinpath(app_name, f"icon.{desktop_icon_suffix()}")
+        icon_path = desktop_icon_path(app_name)
         if not app_title or not link_name:
             logger.error("Missing app_title or link_name")
             return False

rare/utils/steam_shortcuts.py

@@ -0,0 +1,194 @@
+import os
+import platform
+import shutil
+from logging import getLogger
+from pathlib import Path
+from typing import Optional, List, Dict
+from dataclasses import asdict
+
+import vdf
+
+from rare.utils.paths import image_icon_path, image_wide_path, image_tall_path, desktop_icon_path, get_rare_executable
+from rare.models.steam import SteamUser, SteamShortcut
+
+if platform.system() == "Windows":
+    # noinspection PyUnresolvedReferences
+    import winreg  # pylint: disable=E0401
+
+logger = getLogger("SteamShortcuts")
+
+steam_client_install_paths = [os.path.expanduser("~/.local/share/Steam")]
+
+
+def find_steam() -> Optional[str]:
+    if platform.system() == "Windows":
+        # Find the Steam install directory or raise an error
+        try:  # 32-bit
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "SOFTWARE\\Valve\\Steams")
+        except FileNotFoundError:
+            try:  # 64-bit
+                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "SOFTWARE\\Wow6432Node\\Valve\\Steam")
+            except FileNotFoundError as e:
+                return None
+        return winreg.QueryValueEx(key, "InstallPath")[0]
+    # return the first valid path
+    elif platform.system() in {"Linux", "FreeBSD"}:
+        for path in steam_client_install_paths:
+            if os.path.isdir(path) and os.path.isfile(os.path.join(path, "steam.sh")):
+                return path
+    return None
+
+
+def find_steam_users(steam_path: str) -> List[SteamUser]:
+    _users = []
+    vdf_path = os.path.join(steam_path, "config", "loginusers.vdf")
+    with open(vdf_path, 'r') as f:
+        users = vdf.load(f).get("users", {})
+    for long_id, user in users.items():
+        _users.append(SteamUser(long_id, user))
+    return _users
+
+
+def _load_shortcuts(steam_path: str, user: SteamUser) -> Dict[str, SteamShortcut]:
+    _shortcuts = {}
+    vdf_path = os.path.join(steam_path, "userdata", str(user.short_id), "config", "shortcuts.vdf")
+    with open(vdf_path, 'rb') as f:
+        shortcuts = vdf.binary_load(f).get("shortcuts", {})
+    for idx, shortcut in shortcuts.items():
+        _shortcuts[idx] = SteamShortcut.from_dict(shortcut)
+    return _shortcuts
+
+
+def _save_shortcuts(steam_path: str, user: SteamUser, shortcuts: Dict[str, SteamShortcut]) -> None:
+    _shortcuts = {k: asdict(v) for k, v in shortcuts.items()}
+    vdf_path = os.path.join(steam_path, "userdata", str(user.short_id), "config", "shortcuts.vdf")
+    with open(vdf_path, 'wb') as f:
+        vdf.binary_dump({"shortcuts": _shortcuts}, f)
+
+
+__steam_dir: Optional[str] = None
+__steam_user: Optional[SteamUser] = None
+__steam_shortcuts: Optional[Dict] = None
+
+
+def steam_shortcuts_supported() -> bool:
+    return __steam_dir is not None and __steam_user is not None and __steam_shortcuts is not None
+
+
+def load_steam_shortcuts():
+    global __steam_shortcuts, __steam_dir, __steam_user
+
+    if __steam_shortcuts is not None:
+        return
+
+    steam_dir = find_steam()
+    if not steam_dir:
+        logger.error("Failed to find Steam install directory")
+        return
+    __steam_dir = steam_dir
+
+    steam_users = find_steam_users(steam_dir)
+    if not steam_users:
+        logger.error("Failed to find any Steam users")
+        return
+    else:
+        steam_user = next(filter(lambda x: x.most_recent, steam_users))
+        logger.info("Found most recently logged-in user %s(%s)", steam_user.account_name, steam_user.persona_name)
+    __steam_user = steam_user
+
+    __steam_shortcuts = _load_shortcuts(steam_dir, steam_user)
+
+
+def save_steam_shortcuts():
+    if __steam_shortcuts:
+        _save_shortcuts(__steam_dir, __steam_user, __steam_shortcuts)
+        logger.info("Saved Steam shortcuts for user %s(%s)", __steam_user.account_name, __steam_user.persona_name)
+    else:
+        logger.error("Failed to save Steam shortcuts")
+
+
+def steam_shortcut_exists(app_name: str) -> bool:
+    return SteamShortcut.calculate_appid(app_name) in {s.appid for s in __steam_shortcuts.values()}
+
+
+def remove_steam_shortcut(app_name: str) -> Optional[SteamShortcut]:
+    global __steam_shortcuts
+
+    if not steam_shortcut_exists(app_name):
+        logger.error("Game %s doesn't have an associated Steam shortcut", app_name)
+        return None
+
+    appid = SteamShortcut.calculate_appid(app_name)
+    removed = next(filter(lambda item: item[1].appid == appid, __steam_shortcuts.items()))
+    shortcuts = dict(filter(lambda item: item[1].appid != appid, __steam_shortcuts.items()))
+    __steam_shortcuts = shortcuts
+    return removed[1]
+
+
+def add_steam_shortcut(app_name: str, app_title: str) -> SteamShortcut:
+    global __steam_shortcuts
+
+    if steam_shortcut_exists(app_name):
+        logger.info("Removing old Steam shortcut for %s", app_name)
+        remove_steam_shortcut(app_name)
+
+    command = get_rare_executable()
+    arguments = ["launch", app_name]
+    if len(command) > 1:
+        arguments = command[1:] + arguments
+    shortcut = SteamShortcut.create(
+        app_name=app_name,
+        app_title=f"{app_title} (Rare)",
+        executable=command[0],
+        start_dir=os.path.dirname(command[0]),
+        icon=desktop_icon_path(app_name).as_posix(),
+        launch_options=arguments,
+    )
+
+    key = int(max(__steam_shortcuts.keys(), default="0"))
+    __steam_shortcuts[str(key+1)] = shortcut
+    return shortcut
+
+
+def add_steam_coverart(app_name: str, shortcut: SteamShortcut):
+    steam_grid_dir = os.path.join(__steam_dir, "userdata", str(__steam_user.short_id), "config", "grid")
+    shutil.copy(image_wide_path(app_name), os.path.join(steam_grid_dir, shortcut.game_hero))
+    shutil.copy(image_icon_path(app_name), os.path.join(steam_grid_dir, shortcut.game_logo))
+    shutil.copy(image_wide_path(app_name), os.path.join(steam_grid_dir, shortcut.grid_wide))
+    shutil.copy(image_tall_path(app_name), os.path.join(steam_grid_dir, shortcut.grid_tall))
+
+
+def remove_steam_coverart(shortcut: SteamShortcut):
+    steam_grid_dir = os.path.join(__steam_dir, "userdata", str(__steam_user.short_id), "config", "grid")
+    Path(steam_grid_dir).joinpath(shortcut.game_hero).unlink(missing_ok=True)
+    Path(steam_grid_dir).joinpath(shortcut.game_logo).unlink(missing_ok=True)
+    Path(steam_grid_dir).joinpath(shortcut.grid_wide).unlink(missing_ok=True)
+    Path(steam_grid_dir).joinpath(shortcut.grid_tall).unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+
+    from pprint import pprint
+
+    load_steam_shortcuts()
+
+    print(__steam_dir)
+    print(__steam_user)
+    print(__steam_shortcuts)
+
+    def print_shortcuts():
+        for k, s in __steam_shortcuts.items():
+            print({k: asdict(s)})
+            print(vars(s))
+        print()
+
+    print_shortcuts()
+
+    add_steam_shortcut("test1", "Test1")
+    add_steam_shortcut("test2", "Test2")
+    add_steam_shortcut("test3", "Test3")
+    add_steam_shortcut("test1", "Test1")
+
+    remove_steam_shortcut("test2")
+
+    print_shortcuts()

rare/widgets/button_edit.py

@@ -0,0 +1,42 @@
+from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt5.QtWidgets import QStyle, QPushButton, QLineEdit
+
+from rare.utils.misc import qta_icon
+
+
+class ButtonLineEdit(QLineEdit):
+    buttonClicked = pyqtSignal()
+
+    def __init__(self, icon_name, placeholder_text: str, parent=None):
+        super(ButtonLineEdit, self).__init__(parent=parent)
+        self.setObjectName(type(self).__name__)
+
+        self.button = QPushButton(self)
+        self.button.setObjectName(f"{type(self).__name__}Button")
+        self.button.setIcon(qta_icon(icon_name))
+        self.button.setCursor(Qt.ArrowCursor)
+        self.button.clicked.connect(self.buttonClicked.emit)
+
+        self.setPlaceholderText(placeholder_text)
+        # frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
+        # button_size = self.button.sizeHint()
+        #
+        # self.setStyleSheet(
+        #     f"QLineEdit#{self.objectName()} {{padding-right: {(button_size.width() + frame_width + 1)}px; }}"
+        # )
+        # self.setMinimumSize(
+        #     max(self.minimumSizeHint().width(), button_size.width() + frame_width * 2 + 2),
+        #     max(
+        #         self.minimumSizeHint().height(),
+        #         button_size.height() + frame_width * 2 + 2,
+        #     ),
+        # )
+
+    def resizeEvent(self, event):
+        frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
+        button_size = self.button.sizeHint()
+        self.button.move(
+            self.rect().right() - frame_width - button_size.width(),
+            (self.rect().bottom() - button_size.height() + 1) // 2,
+        )
+        super(ButtonLineEdit, self).resizeEvent(event)