4063195b4d
When updates are queued, they are removed from the update's list. An exceptions is made when the queued item comes from repairing (without updating), in which case the update is disabled for the runtime. A queued item can be either removed (if it is an update it will be added back to the updates groups) or forced to be updated now. If a queued item is forced, the currently running item will be added to the front of the queue. Downloads will be queued if there is no active download but there is a queue already. The download thread is now responsible for emitting the progress to `RareGame` InstallDialog: Pass `RareGame` and `InstallOptionsModel` only as arguments. The `update`, `repair` and `silent` arguments are already part of `InstallOptionsModel` `RareGame` is used to query information about the game. InstallInfoWorker: Pass only `InstallOptionsModel` as argument Emit `InstallQueueItemModel` as result, to re-use the worker when queuing stopped games RareGame: Query and store metadata property about entitlement grant date RareGame: Add `RareEosOverlay` class that imitates `RareGame` to handle the overlay LibraryWidgetController: Remove dead signal routing code, these signals are handled by `RareGame` Directly parent library widgets instead of reparenting them GameWidgets: Remove unused signals EOSGroup: Set install location based on preferences and use EOSOverlayApp from legendary GamesTab: Connect the `progress` signals of dlcs to the base game's signals GamesTab: Remove dead code GlobalSignals: Remove `ProgresSignals` RareCore: Mangle internal signleton's names Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
276 lines
10 KiB
Python
276 lines
10 KiB
Python
import os
|
|
import platform
|
|
from abc import abstractmethod
|
|
from logging import getLogger
|
|
|
|
from PyQt5.QtCore import pyqtSignal, QSettings, QStandardPaths, Qt
|
|
from PyQt5.QtGui import QMouseEvent
|
|
from PyQt5.QtWidgets import QMessageBox, QAction, QLabel
|
|
|
|
from rare.models.game import RareGame
|
|
from rare.shared import (
|
|
LegendaryCoreSingleton,
|
|
GlobalSignalsSingleton,
|
|
ArgumentsSingleton,
|
|
ImageManagerSingleton,
|
|
)
|
|
from rare.shared.game_utils import GameUtils
|
|
from rare.utils.misc import create_desktop_link
|
|
from .library_widget import LibraryWidget
|
|
|
|
logger = getLogger("BaseGameWidget")
|
|
|
|
|
|
class GameWidget(LibraryWidget):
|
|
show_info = pyqtSignal(RareGame)
|
|
|
|
def __init__(self, rgame: RareGame, game_utils: GameUtils, parent=None):
|
|
super(GameWidget, self).__init__(parent=parent)
|
|
self.core = LegendaryCoreSingleton()
|
|
self.signals = GlobalSignalsSingleton()
|
|
self.args = ArgumentsSingleton()
|
|
self.image_manager = ImageManagerSingleton()
|
|
|
|
self.game_utils = game_utils
|
|
|
|
self.rgame = rgame
|
|
self.rgame.signals.widget.update.connect(
|
|
lambda: self.setPixmap(self.rgame.pixmap)
|
|
)
|
|
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: RareGame = rgame
|
|
self.syncing_cloud_saves = False
|
|
|
|
self.game_running = False
|
|
|
|
self.settings = QSettings()
|
|
|
|
self.installing = False
|
|
self.setContextMenuPolicy(Qt.ActionsContextMenu)
|
|
launch = QAction(self.tr("Launch"), self)
|
|
launch.triggered.connect(self.launch)
|
|
self.addAction(launch)
|
|
|
|
if self.rgame.game.supports_cloud_saves:
|
|
sync = QAction(self.tr("Sync with cloud"), self)
|
|
sync.triggered.connect(self.sync_game)
|
|
self.addAction(sync)
|
|
|
|
desktop = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation)
|
|
if os.path.exists(
|
|
os.path.join(desktop, f"{self.rgame.app_title}.desktop")
|
|
) or os.path.exists(os.path.join(desktop, f"{self.rgame.app_title}.lnk")):
|
|
self.create_desktop = QAction(self.tr("Remove Desktop link"))
|
|
else:
|
|
self.create_desktop = QAction(self.tr("Create Desktop link"))
|
|
if self.rgame.is_installed:
|
|
self.create_desktop.triggered.connect(
|
|
lambda: self.create_desktop_link("desktop")
|
|
)
|
|
self.addAction(self.create_desktop)
|
|
|
|
applications = QStandardPaths.writableLocation(QStandardPaths.ApplicationsLocation)
|
|
if platform.system() == "Linux":
|
|
start_menu_file = os.path.join(applications, f"{self.rgame.app_title}.desktop")
|
|
elif platform.system() == "Windows":
|
|
start_menu_file = os.path.join(applications, "..", f"{self.rgame.app_title}.lnk")
|
|
else:
|
|
start_menu_file = ""
|
|
if platform.system() in ["Windows", "Linux"]:
|
|
if os.path.exists(start_menu_file):
|
|
self.create_start_menu = QAction(self.tr("Remove start menu link"))
|
|
else:
|
|
self.create_start_menu = QAction(self.tr("Create start menu link"))
|
|
if self.rgame.is_installed:
|
|
self.create_start_menu.triggered.connect(
|
|
lambda: self.create_desktop_link("start_menu")
|
|
)
|
|
self.addAction(self.create_start_menu)
|
|
|
|
reload_image = QAction(self.tr("Reload Image"), self)
|
|
reload_image.triggered.connect(self.reload_image)
|
|
self.addAction(reload_image)
|
|
|
|
if not self.rgame.is_origin:
|
|
uninstall = QAction(self.tr("Uninstall"), self)
|
|
self.addAction(uninstall)
|
|
uninstall.triggered.connect(
|
|
lambda: self.signals.game.uninstalled.emit(self.rgame.app_name)
|
|
if self.game_utils.uninstall_game(self.rgame)
|
|
else None
|
|
)
|
|
|
|
self.texts = {
|
|
"hover": {
|
|
"update_available": self.tr("Start without version check"),
|
|
"launch": self.tr("Launch Game"),
|
|
"launch_origin": self.tr("Launch/Link"),
|
|
"running": self.tr("Game running"),
|
|
"launch_offline": self.tr("Launch offline"),
|
|
"no_launch": self.tr("Can't launch game")
|
|
},
|
|
"status": {
|
|
"needs_verification": self.tr("Please verify game before playing"),
|
|
"running": self.tr("Game running"),
|
|
"syncing": self.tr("Syncing cloud saves"),
|
|
"update_available": self.tr("Update available"),
|
|
"no_meta": self.tr("Game is only offline available"),
|
|
"no_launch": self.tr("Can't launch game"),
|
|
},
|
|
}
|
|
|
|
self.rgame.signals.progress.finish.connect(self.set_status)
|
|
|
|
@abstractmethod
|
|
def set_status(self, label: QLabel):
|
|
if self.rgame.is_installed:
|
|
if self.rgame.has_update:
|
|
label.setText(self.texts["status"]["update_available"])
|
|
return
|
|
if self.rgame.needs_verification:
|
|
label.setText(self.texts["status"]["needs_verification"])
|
|
return
|
|
label.setText("")
|
|
label.setVisible(False)
|
|
|
|
@property
|
|
def enterEventText(self) -> str:
|
|
if self.rgame.is_installed:
|
|
if self.game_running:
|
|
return self.texts["status"]["running"]
|
|
elif (not self.rgame.is_origin) and self.rgame.needs_verification:
|
|
return self.texts["status"]["needs_verification"]
|
|
elif self.rgame.is_foreign:
|
|
return self.texts["hover"]["launch_offline"]
|
|
elif self.rgame.has_update:
|
|
return self.texts["hover"]["update_available"]
|
|
else:
|
|
return self.tr("Game Info")
|
|
# return self.texts["hover"]["launch" if self.igame else "launch_origin"]
|
|
else:
|
|
if not self.installing:
|
|
return self.tr("Game Info")
|
|
else:
|
|
return self.tr("Installation running")
|
|
|
|
@property
|
|
def leaveEventText(self) -> str:
|
|
if self.rgame.is_installed:
|
|
if self.game_running:
|
|
return self.texts["status"]["running"]
|
|
elif self.syncing_cloud_saves:
|
|
return self.texts["status"]["syncing"]
|
|
elif self.rgame.is_foreign:
|
|
return self.texts["status"]["no_meta"]
|
|
elif self.rgame.has_update:
|
|
return self.texts["status"]["update_available"]
|
|
elif (not self.rgame.is_origin) and self.rgame.needs_verification:
|
|
return self.texts["status"]["needs_verification"]
|
|
else:
|
|
return ""
|
|
else:
|
|
if self.installing:
|
|
return "Installation..."
|
|
else:
|
|
return ""
|
|
|
|
def mousePressEvent(self, e: QMouseEvent) -> None:
|
|
# left button
|
|
if e.button() == 1:
|
|
self.show_info.emit(self.rgame)
|
|
# right
|
|
elif e.button() == 2:
|
|
pass # self.showMenu(e)
|
|
|
|
def reload_image(self) -> None:
|
|
self.rgame.refresh_pixmap()
|
|
|
|
def install(self):
|
|
self.show_info.emit(self.rgame)
|
|
|
|
def create_desktop_link(self, type_of_link):
|
|
if type_of_link == "desktop":
|
|
shortcut_path = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation)
|
|
elif type_of_link == "start_menu":
|
|
shortcut_path = QStandardPaths.writableLocation(QStandardPaths.ApplicationsLocation)
|
|
else:
|
|
return
|
|
|
|
if platform.system() == "Windows":
|
|
shortcut_path = os.path.join(shortcut_path, f"{self.rgame.app_title}.lnk")
|
|
elif platform.system() == "Linux":
|
|
shortcut_path = os.path.join(shortcut_path, f"{self.rgame.app_title}.desktop")
|
|
else:
|
|
QMessageBox.warning(
|
|
self,
|
|
"Warning",
|
|
f"Create a Desktop link is currently not supported on {platform.system()}",
|
|
)
|
|
return
|
|
|
|
if not os.path.exists(shortcut_path):
|
|
try:
|
|
if not create_desktop_link(self.rgame.app_name, self.core, type_of_link):
|
|
return
|
|
except PermissionError:
|
|
QMessageBox.warning(
|
|
self, "Error", "Permission error. Cannot create Desktop Link"
|
|
)
|
|
if type_of_link == "desktop":
|
|
self.create_desktop.setText(self.tr("Remove Desktop link"))
|
|
elif type_of_link == "start_menu":
|
|
self.create_start_menu.setText(self.tr("Remove Start menu link"))
|
|
else:
|
|
if os.path.exists(shortcut_path):
|
|
os.remove(shortcut_path)
|
|
|
|
if type_of_link == "desktop":
|
|
self.create_desktop.setText(self.tr("Create Desktop link"))
|
|
elif type_of_link == "start_menu":
|
|
self.create_start_menu.setText(self.tr("Create Start menu link"))
|
|
|
|
def launch(self, offline=False, skip_version_check=False):
|
|
if self.game_running:
|
|
return
|
|
offline = offline or self.rgame.is_foreign
|
|
if self.rgame.is_foreign and not self.rgame.can_run_offline:
|
|
QMessageBox.warning(self, "Warning",
|
|
self.tr("This game is probably not in your library and it cannot be launched offline"))
|
|
return
|
|
|
|
if self.rgame.game.supports_cloud_saves and not offline:
|
|
self.syncing_cloud_saves = True
|
|
self.rgame.launch(
|
|
offline=offline, skip_update_check=skip_version_check
|
|
)
|
|
|
|
def sync_finished(self, app_name):
|
|
self.syncing_cloud_saves = False
|
|
|
|
def sync_game(self):
|
|
try:
|
|
sync = self.game_utils.cloud_save_utils.sync_before_launch_game(
|
|
self.rgame.app_name, True
|
|
)
|
|
except Exception:
|
|
sync = False
|
|
if sync:
|
|
self.syncing_cloud_saves = True
|
|
|
|
def game_finished(self, app_name, error):
|
|
if error:
|
|
QMessageBox.warning(self, "Error", error)
|
|
self.game_running = False
|