CodeMirror/Rare
1
0
Fork 0
mirror of synced 2024-06-29 11:40:37 +12:00
Code Issues Projects Releases Wiki Activity

GameWidgets: Remove GameUtils from GameWidgets

Browse source 
Also remove attributes tracking the state of each application, those
are handled by `RareGame`

Temporarily disable save syncing related code, pending the move to
the game launcher process
This commit is contained in:
loathingKernel 2023-01-24 15:40:21 +02:00
parent b9e9ed8088
commit 915c41309d
5 changed files with 140 additions and 172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
rare/components/tabs/games/__init__.py
View file

@ -61,8 +61,6 @@ class GamesTab(QStackedWidget):
self.game_info_tabs.back_clicked.connect(lambda: self.setCurrentWidget(self.games))
self.addWidget(self.game_info_tabs)
self.game_info_tabs.info.uninstalled.connect(lambda x: self.setCurrentWidget(self.games))
self.integrations_tabs = IntegrationsTabs(self)
self.integrations_tabs.back_clicked.connect(lambda: self.setCurrentWidget(self.games))
self.addWidget(self.integrations_tabs)
@ -119,11 +117,10 @@ class GamesTab(QStackedWidget):
# signals
self.signals.game.installed.connect(self.update_count_games_label)
# self.signals.game.installed.connect(self.library_controller.update_list)
self.signals.game.uninstalled.connect(self.update_count_games_label)
self.signals.game.uninstalled.connect(lambda x: self.setCurrentIndex(0))
# self.signals.update_gamelist.connect(self.library_controller.update_list)
# self.game_utils.update_list.connect(self.library_controller.update_list)
# self.signals.game.uninstalled.connect(self.library_controller.update_list)
# self.signals.game.uninstalled.connect(lambda x: self.setCurrentWidget(self.games))
start_t = time.time()
self.setup_game_list()
@ -193,7 +190,7 @@ class GamesTab(QStackedWidget):
def add_library_widget(self, rgame: RareGame):
try:
icon_widget, list_widget = self.library_controller.add_game(rgame, self.game_utils)
icon_widget, list_widget = self.library_controller.add_game(rgame)
except Exception as e:
raise e
logger.error(f"{rgame.app_name} is broken. Don't add it to game list: {e}")

28
rare/components/tabs/games/game_widgets/__init__.py
View file

@ -8,7 +8,6 @@ from rare.models.apiresults import ApiResults
from rare.models.game import RareGame
from rare.models.signals import GlobalSignals
from rare.shared import RareCore
from rare.shared.game_utils import GameUtils
from .icon_game_widget import IconGameWidget
from .list_game_widget import ListGameWidget
@ -23,12 +22,12 @@ class LibraryWidgetController(QObject):
self.signals: GlobalSignals = self.rcore.signals()
self.api_results: ApiResults = self.rcore.api_results()
def add_game(self, rgame: RareGame, game_utils: GameUtils):
return self.add_widgets(rgame, game_utils)
def add_game(self, rgame: RareGame):
return self.add_widgets(rgame)
def add_widgets(self, rgame: RareGame, game_utils: GameUtils) -> Tuple[IconGameWidget, ListGameWidget]:
icon_widget = IconGameWidget(rgame, game_utils, self._icon_container)
list_widget = ListGameWidget(rgame, game_utils, self._list_container)
def add_widgets(self, rgame: RareGame) -> Tuple[IconGameWidget, ListGameWidget]:
icon_widget = IconGameWidget(rgame, self._icon_container)
list_widget = ListGameWidget(rgame, self._list_container)
return icon_widget, list_widget
@staticmethod
@ -131,20 +130,3 @@ class LibraryWidgetController(QObject):
iw = self._icon_container.findChild(IconGameWidget, app_name)
lw = self._list_container.findChild(ListGameWidget, app_name)
return iw, lw
# lk: this should go in downloads and happen once
def __find_game_for_dlc(self, app_name: str) -> Optional[str]:
game = self.core.get_game(app_name, False)
# lk: how can an app_name not refer to a game?
if not game:
return None
if game.is_dlc:
game_list = self.core.get_game_list(update_assets=False)
game = list(
filter(
lambda x: x.asset_infos["Windows"].catalog_item_id == game.metadata["mainGameItem"]["id"],
game_list,
)
)
return game[0].app_name
return app_name

169
rare/components/tabs/games/game_widgets/game_widget.py
View file

@ -3,9 +3,9 @@ import platform
from abc import abstractmethod
from logging import getLogger
from PyQt5.QtCore import pyqtSignal, QSettings, QStandardPaths, Qt
from PyQt5.QtCore import pyqtSignal, QStandardPaths, Qt, pyqtSlot
from PyQt5.QtGui import QMouseEvent
from PyQt5.QtWidgets import QMessageBox, QAction, QLabel
from PyQt5.QtWidgets import QMessageBox, QAction, QLabel, QPushButton
from rare.models.game import RareGame
from rare.shared import (
@ -14,7 +14,6 @@ from rare.shared import (
ArgumentsSingleton,
ImageManagerSingleton,
)
from rare.shared.game_utils import GameUtils
from rare.utils.misc import create_desktop_link
from .library_widget import LibraryWidget
@ -24,49 +23,29 @@ logger = getLogger("BaseGameWidget")
class GameWidget(LibraryWidget):
show_info = pyqtSignal(RareGame)
def __init__(self, rgame: RareGame, game_utils: GameUtils, parent=None):
def __init__(self, rgame: RareGame, 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.is_installed or self.rgame.is_origin:
self.launch_action = QAction(self.tr("Launch"), self)
self.launch_action.triggered.connect(self._launch)
self.addAction(self.launch_action)
else:
self.install_action = QAction(self.tr("Install"), self)
self.install_action.triggered.connect(self._install)
self.addAction(self.install_action)
if self.rgame.game.supports_cloud_saves:
sync = QAction(self.tr("Sync with cloud"), self)
sync.triggered.connect(self.sync_game)
self.addAction(sync)
# 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(
@ -100,17 +79,13 @@ class GameWidget(LibraryWidget):
self.addAction(self.create_start_menu)
reload_image = QAction(self.tr("Reload Image"), self)
reload_image.triggered.connect(self.reload_image)
reload_image.triggered.connect(self._on_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
)
if self.rgame.is_installed and not self.rgame.is_origin:
self.uninstall_action = QAction(self.tr("Uninstall"), self)
self.uninstall_action.triggered.connect(self._uninstall)
self.addAction(self.uninstall_action)
self.texts = {
"hover": {
@ -131,6 +106,25 @@ class GameWidget(LibraryWidget):
},
}
# signals
self.rgame.signals.widget.update.connect(
lambda: self.setPixmap(self.rgame.pixmap)
)
self.rgame.signals.widget.update.connect(
self.update_widget
)
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.finish.connect(self.set_status)
@abstractmethod
@ -145,10 +139,15 @@ class GameWidget(LibraryWidget):
label.setText("")
label.setVisible(False)
@abstractmethod
def update_widget(self, install_btn: QPushButton, launch_btn: QPushButton):
install_btn.setVisible(not self.rgame.is_installed)
launch_btn.setVisible(self.rgame.is_installed)
@property
def enterEventText(self) -> str:
if self.rgame.is_installed:
if self.game_running:
if self.rgame.state == RareGame.State.RUNNING:
return self.texts["status"]["running"]
elif (not self.rgame.is_origin) and self.rgame.needs_verification:
return self.texts["status"]["needs_verification"]
@ -160,7 +159,7 @@ class GameWidget(LibraryWidget):
return self.tr("Game Info")
# return self.texts["hover"]["launch" if self.igame else "launch_origin"]
else:
if not self.installing:
if not self.rgame.state == RareGame.State.DOWNLOADING:
return self.tr("Game Info")
else:
return self.tr("Installation running")
@ -168,10 +167,10 @@ class GameWidget(LibraryWidget):
@property
def leaveEventText(self) -> str:
if self.rgame.is_installed:
if self.game_running:
if self.rgame.state == RareGame.State.RUNNING:
return self.texts["status"]["running"]
elif self.syncing_cloud_saves:
return self.texts["status"]["syncing"]
# 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:
@ -181,7 +180,7 @@ class GameWidget(LibraryWidget):
else:
return ""
else:
if self.installing:
if self.rgame.state == RareGame.State.DOWNLOADING:
return "Installation..."
else:
return ""
@ -194,10 +193,29 @@ class GameWidget(LibraryWidget):
elif e.button() == 2:
pass # self.showMenu(e)
def reload_image(self) -> None:
@pyqtSlot()
def _on_reload_image(self) -> None:
self.rgame.refresh_pixmap()
def install(self):
@pyqtSlot()
@pyqtSlot(bool, bool)
def _launch(self, offline=False, skip_version_check=False):
if offline or (self.rgame.is_foreign and self.rgame.can_run_offline):
offline = True
# if self.rgame.game.supports_cloud_saves and not offline:
# self.syncing_cloud_saves = True
if self.rgame.has_update:
skip_version_check = True
self.rgame.launch(
offline=offline, skip_update_check=skip_version_check
)
@pyqtSlot()
def _install(self):
self.show_info.emit(self.rgame)
@pyqtSlot()
def _uninstall(self):
self.show_info.emit(self.rgame)
def create_desktop_link(self, type_of_link):
@ -241,35 +259,20 @@ class GameWidget(LibraryWidget):
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
# def sync_finished(self, app_name):
# self.syncing_cloud_saves = False
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_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 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
# def game_finished(self, app_name, error):
# if error:
# QMessageBox.warning(self, "Error", error)
# self.game_running = False

57
rare/components/tabs/games/game_widgets/icon_game_widget.py
View file

@ -4,7 +4,6 @@ from typing import Optional
from PyQt5.QtCore import QEvent, pyqtSlot
from rare.models.game import RareGame
from rare.shared.game_utils import GameUtils
from rare.shared.image_manager import ImageSize
from .game_widget import GameWidget
from .icon_widget import IconWidget
@ -13,24 +12,19 @@ logger = getLogger("IconGameWidget")
class IconGameWidget(GameWidget):
def __init__(self, rgame: RareGame, game_utils: GameUtils, parent=None):
super(IconGameWidget, self).__init__(rgame, game_utils, parent)
def __init__(self, rgame: RareGame, parent=None):
super(IconGameWidget, self).__init__(rgame, parent)
self.setObjectName(f"{rgame.app_name}")
self.setFixedSize(ImageSize.Display)
self.ui = IconWidget()
self.ui.setupUi(self)
self.game_utils.finished.connect(self.game_finished)
self.ui.title_label.setText(f"<h4>{self.rgame.app_title}</h4>")
self.ui.launch_btn.clicked.connect(self.game_launch)
self.ui.launch_btn.clicked.connect(self._launch)
self.ui.launch_btn.setVisible(self.rgame.is_installed)
self.ui.install_btn.clicked.connect(self.install)
self.ui.install_btn.clicked.connect(self._install)
self.ui.install_btn.setVisible(not self.rgame.is_installed)
# self.game_utils.game_launched.connect(self.game_started)
self.is_ready = True
self.ui.launch_btn.setEnabled(self.rgame.can_launch)
self.set_status()
@ -39,6 +33,10 @@ class IconGameWidget(GameWidget):
def set_status(self):
super(IconGameWidget, self).set_status(self.ui.status_label)
@pyqtSlot()
def update_widget(self):
super(IconGameWidget, self).update_widget(self.ui.install_btn, self.ui.launch_btn)
def enterEvent(self, a0: Optional[QEvent] = None) -> None:
if a0 is not None:
a0.accept()
@ -51,28 +49,19 @@ class IconGameWidget(GameWidget):
self.ui.leaveAnimation(self)
self.ui.tooltip_label.setText(self.leaveEventText)
def game_launch(self):
if not self.game_running:
if self.rgame.igame and self.rgame.needs_verification:
return
if self.rgame.has_update:
self.launch(skip_version_check=True)
else:
self.launch()
# def sync_finished(self, app_name):
# if not app_name == self.rgame.app_name:
# return
# super().sync_finished(app_name)
# self.leaveEvent(None)
def sync_finished(self, app_name):
if not app_name == self.rgame.app_name:
return
super().sync_finished(app_name)
self.leaveEvent(None)
def game_finished(self, app_name, error):
if app_name != self.rgame.app_name:
return
self.game_running = False
self.leaveEvent(None)
def game_started(self, app_name):
if app_name == self.rgame.app_name:
self.game_running = True
self.leaveEvent(None)
# def game_finished(self, app_name, error):
# if app_name != self.rgame.app_name:
# return
# self.game_running = False
# self.leaveEvent(None)
#
# def game_started(self, app_name):
# if app_name == self.rgame.app_name:
# self.game_running = True
# self.leaveEvent(None)

47
rare/components/tabs/games/game_widgets/list_game_widget.py
View file

@ -1,7 +1,6 @@
from logging import getLogger
from PyQt5.QtCore import Qt, QEvent, QRect, pyqtSlot
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtCore import Qt, QEvent, QRect, pyqtSlot, pyqtSignal
from PyQt5.QtGui import (
QPalette,
QBrush,
@ -12,7 +11,6 @@ from PyQt5.QtGui import (
)
from rare.models.game import RareGame
from rare.shared.game_utils import GameUtils
from rare.utils.misc import get_size
from rare.widgets.image_widget import ImageWidget
from .game_widget import GameWidget
@ -23,8 +21,8 @@ logger = getLogger("ListGameWidget")
class ListGameWidget(GameWidget):
def __init__(self, rgame: RareGame, game_utils: GameUtils, parent=None):
super(ListGameWidget, self).__init__(rgame, game_utils, parent)
def __init__(self, rgame: RareGame, parent=None):
super(ListGameWidget, self).__init__(rgame, parent)
self.setObjectName(f"{rgame.app_name}")
self.ui = ListWidget()
self.ui.setupUi(self)
@ -32,12 +30,12 @@ class ListGameWidget(GameWidget):
self.ui.title_label.setText(f"<h3>{self.rgame.app_title}</h3>")
self.ui.install_btn.setVisible(not self.rgame.is_installed)
self.ui.install_btn.clicked.connect(self.install)
self.ui.install_btn.clicked.connect(self._install)
self.ui.launch_btn.setText(
self.tr("Launch") if not self.rgame.is_origin else self.tr("Link/Play")
)
self.ui.launch_btn.clicked.connect(self.launch)
self.ui.launch_btn.clicked.connect(self._launch)
self.ui.launch_btn.setVisible(self.rgame.is_installed)
self.ui.developer_text.setText(self.rgame.developer)
@ -47,11 +45,6 @@ class ListGameWidget(GameWidget):
self.ui.size_text.setText(get_size(self.rgame.install_size) if self.rgame.install_size else "")
# self.game_utils.cloud_save_finished.connect(self.sync_finished)
# self.game_utils.finished.connect(self.game_finished)
# self.game_utils.game_launched.connect(self.game_started)
self.ui.launch_btn.setEnabled(self.rgame.can_launch)
self.set_status()
@ -60,6 +53,10 @@ class ListGameWidget(GameWidget):
def set_status(self):
super(ListGameWidget, self).set_status(self.ui.status_label)
@pyqtSlot()
def update_widget(self):
super(ListGameWidget, self).update_widget(self.ui.install_btn, self.ui.launch_btn)
def update_text(self, e=None):
if self.rgame.is_installed:
if self.rgame.has_update:
@ -68,8 +65,8 @@ class ListGameWidget(GameWidget):
self.ui.status_label.setText(self.texts["status"]["no_meta"])
elif self.rgame.igame and self.rgame.needs_verification:
self.ui.status_label.setText(self.texts["status"]["needs_verification"])
elif self.syncing_cloud_saves:
self.ui.status_label.setText(self.texts["status"]["syncing"])
# elif self.syncing_cloud_saves:
# self.ui.status_label.setText(self.texts["status"]["syncing"])
else:
self.ui.status_label.setText("")
self.ui.status_label.setVisible(False)
@ -90,18 +87,18 @@ class ListGameWidget(GameWidget):
self.ui.tooltip_label.setText(status)
self.ui.tooltip_label.setVisible(bool(status))
def game_started(self, app_name):
if app_name == self.rgame.app_name:
self.game_running = True
# self.update_text()
self.ui.launch_btn.setDisabled(True)
# def game_started(self, app_name):
# if app_name == self.rgame.app_name:
# self.game_running = True
# # self.update_text()
# self.ui.launch_btn.setDisabled(True)
def game_finished(self, app_name, error):
if app_name != self.rgame.app_name:
return
super().game_finished(app_name, error)
# self.update_text(None)
self.ui.launch_btn.setDisabled(False)
# def game_finished(self, app_name, error):
# if app_name != self.rgame.app_name:
# return
# super().game_finished(app_name, error)
# # self.update_text(None)
# self.ui.launch_btn.setDisabled(False)
"""
Painting and progress overrides.