{text}
" + self._cursor_output.insertHtml(html) self.scroll_to_last_line() def error(self, text): - self._cursor_output.insertHtml(f'{text}') + html = f"{text}
" + self._cursor_output.insertHtml(html) self.scroll_to_last_line() def scroll_to_last_line(self): diff --git a/rare/components/main_window.py b/rare/components/main_window.py index c017a1e7..2b8ec3d0 100644 --- a/rare/components/main_window.py +++ b/rare/components/main_window.py @@ -1,5 +1,4 @@ import os -import time from logging import getLogger from PyQt5.QtCore import Qt, QSettings, QTimer, QSize diff --git a/rare/components/tabs/account/__init__.py b/rare/components/tabs/account/__init__.py index 54f52ad1..8b327b73 100644 --- a/rare/components/tabs/account/__init__.py +++ b/rare/components/tabs/account/__init__.py @@ -3,6 +3,7 @@ import webbrowser from PyQt5.QtWidgets import QWidget, QVBoxLayout, QMessageBox, QLabel, QPushButton from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton +from rare.utils.utils import icon class MiniWidget(QWidget): @@ -18,7 +19,7 @@ class MiniWidget(QWidget): self.layout.addWidget(QLabel(self.tr("Logged in as {}").format(username))) - self.open_browser = QPushButton(self.tr("Account settings")) + self.open_browser = QPushButton(icon("fa.external-link"), self.tr("Account settings")) self.open_browser.clicked.connect( lambda: webbrowser.open( "https://www.epicgames.com/account/personal?productName=epicgames" diff --git a/rare/components/tabs/games/game_info/__init__.py b/rare/components/tabs/games/game_info/__init__.py index df48e2b3..ec3b1c82 100644 --- a/rare/components/tabs/games/game_info/__init__.py +++ b/rare/components/tabs/games/game_info/__init__.py @@ -18,7 +18,7 @@ class GameInfoTabs(SideTabWidget): self.info = GameInfo(self, game_utils) self.addTab(self.info, self.tr("Information")) - self.settings = GameSettings(self.core, self) + self.settings = GameSettings(self) self.addTab(self.settings, self.tr("Settings")) self.dlc_list = dlcs @@ -30,12 +30,12 @@ class GameInfoTabs(SideTabWidget): def update_game(self, app_name: str): self.setCurrentIndex(1) self.info.update_game(app_name) - self.settings.update_game(app_name) + self.settings.load_settings(app_name) # DLC Tab: Disable if no dlcs available if ( - len(self.dlc_list.get(self.core.get_game(app_name).catalog_item_id, [])) - == 0 + len(self.dlc_list.get(self.core.get_game(app_name).catalog_item_id, [])) + == 0 ): self.setTabEnabled(3, False) else: diff --git a/rare/components/tabs/games/game_info/game_settings.py b/rare/components/tabs/games/game_info/game_settings.py index 16d17de9..d3b0be90 100644 --- a/rare/components/tabs/games/game_info/game_settings.py +++ b/rare/components/tabs/games/game_info/game_settings.py @@ -1,75 +1,29 @@ import os import platform from logging import getLogger -from pathlib import Path -from typing import Tuple -from PyQt5.QtCore import QSettings, QThreadPool, Qt -from PyQt5.QtWidgets import ( - QWidget, - QFileDialog, - QMessageBox, - QLabel, - QPushButton, - QSizePolicy -) -from legendary.core import LegendaryCore -from legendary.models.game import InstalledGame, Game +from PyQt5.QtCore import Qt, QThreadPool +from PyQt5.QtWidgets import QSizePolicy, QPushButton, QLabel, QFileDialog, QMessageBox +from legendary.models.game import Game, InstalledGame -from rare.components.tabs.settings.linux import LinuxSettings -from rare.components.tabs.settings.widgets.wrapper import WrapperSettings -from rare.ui.components.tabs.games.game_info.game_settings import Ui_GameSettings -from rare.components.tabs.settings.widgets.env_vars import EnvVars +from rare.components.tabs.settings import DefaultGameSettings +from rare.components.tabs.settings.widgets.pre_launch import PreLaunchSettings from rare.utils import config_helper from rare.utils.extra_widgets import PathEdit -from rare.utils.utils import WineResolver, get_raw_save_path -from rare.utils.utils import icon +from rare.utils.utils import icon, WineResolver, get_raw_save_path logger = getLogger("GameSettings") -def find_proton_wrappers(): - possible_proton_wrappers = [] - compatibilitytools_dirs = [ - os.path.expanduser("~/.steam/steam/steamapps/common"), - "/usr/share/steam/compatibilitytools.d", - os.path.expanduser("~/.steam/compatibilitytools.d"), - os.path.expanduser("~/.steam/root/compatibilitytools.d"), - ] - for c in compatibilitytools_dirs: - if os.path.exists(c): - for i in os.listdir(c): - proton = os.path.join(c, i, "proton") - compatibilitytool = os.path.join(c, i, "compatibilitytool.vdf") - toolmanifest = os.path.join(c, i, "toolmanifest.vdf") - if os.path.exists(proton) and ( - os.path.exists(compatibilitytool) or os.path.exists(toolmanifest) - ): - wrapper = f'"{proton}" run' - possible_proton_wrappers.append(wrapper) - if not possible_proton_wrappers: - logger.warning("Unable to find any Proton version") - return possible_proton_wrappers - - -class GameSettings(QWidget, Ui_GameSettings): +class GameSettings(DefaultGameSettings): game: Game igame: InstalledGame - # variable to no update when changing game - change = False - - def __init__(self, core: LegendaryCore, parent): - super(GameSettings, self).__init__(parent=parent) - self.setupUi(self) - - self.core = core - self.settings = QSettings() - - self.wrapper_settings = WrapperSettings() - + def __init__(self, parent=None): + super(GameSettings, self).__init__(False, parent) + self.pre_launch_settings = PreLaunchSettings() self.launch_settings_group.layout().addRow( - QLabel("Wrapper"), self.wrapper_settings + QLabel(self.tr("Pre launch command")), self.pre_launch_settings ) self.cloud_save_path_edit = PathEdit( @@ -103,49 +57,15 @@ class GameSettings(QWidget, Ui_GameSettings): f"{self.game.app_name}/auto_sync_cloud", self.cloud_sync.isChecked() ) ) + self.override_exe_edit.textChanged.connect( + lambda text: self.save_line_edit("override_exe", text) + ) self.launch_params.textChanged.connect( lambda x: self.save_line_edit("start_params", x) ) - if platform.system() != "Windows": - self.possible_proton_wrappers = find_proton_wrappers() - - self.proton_wrapper.addItems(self.possible_proton_wrappers) - self.proton_wrapper.currentIndexChanged.connect(self.change_proton) - - self.proton_prefix = PathEdit( - file_type=QFileDialog.DirectoryOnly, - edit_func=self.proton_prefix_edit, - save_func=self.proton_prefix_save, - placeholder=self.tr("Please select path for proton prefix") - ) - self.proton_prefix_layout.addWidget(self.proton_prefix) - - self.linux_settings = LinuxAppSettings() - # FIXME: Remove the spacerItem and margins from the linux settings - # FIXME: This should be handled differently at soem point in the future - self.linux_settings.layout().setContentsMargins(0, 0, 0, 0) - for item in [ - self.linux_settings.layout().itemAt(idx) - for idx in range(self.linux_settings.layout().count()) - ]: - if item.spacerItem(): - self.linux_settings.layout().removeItem(item) - del item - # FIXME: End of FIXME - self.linux_settings_layout.addWidget(self.linux_settings) - self.linux_settings_layout.setAlignment(Qt.AlignTop) - else: - self.linux_settings_widget.setVisible(False) self.game_settings_layout.setAlignment(Qt.AlignTop) - self.linux_settings.mangohud.set_wrapper_activated.connect( - lambda active: self.wrapper_settings.add_wrapper("mangohud") - if active else self.wrapper_settings.delete_wrapper("mangohud")) - - self.env_vars = EnvVars(self) - self.game_settings_contents_layout.addWidget(self.env_vars) - def compute_save_path(self): if ( self.core.is_installed(self.game.app_name) @@ -155,12 +75,17 @@ class GameSettings(QWidget, Ui_GameSettings): new_path = self.core.get_save_path(self.game.app_name) except Exception as e: logger.warning(str(e)) + resolver = WineResolver( + get_raw_save_path(self.game), self.game.app_name + ) + if not resolver.wine_env.get("WINEPREFIX"): + self.cloud_save_path_edit.setText("") + QMessageBox.warning(self, "Warning", "No wine prefix selected. Please set it in settings") + return self.cloud_save_path_edit.setText(self.tr("Loading")) self.cloud_save_path_edit.setDisabled(True) self.compute_save_path_button.setDisabled(True) - resolver = WineResolver( - get_raw_save_path(self.game), self.game.app_name, self.core - ) + app_name = self.game.app_name[:] resolver.signals.result_ready.connect( lambda x: self.wine_resolver_finished(x, app_name) @@ -228,61 +153,9 @@ class GameSettings(QWidget, Ui_GameSettings): config_helper.remove_option(self.game.app_name, option) config_helper.save_config() - def change_proton(self, i): - if self.change: - # First combo box entry: Don't use Proton - if i == 0: - self.wrapper_settings.delete_wrapper("proton") - config_helper.remove_option(self.game.app_name, "no_wine") - config_helper.remove_option(f"{self.game.app_name}.env", "STEAM_COMPAT_DATA_PATH") - config_helper.remove_option(f"{self.game.app_name}.env", "STEAM_COMPAT_CLIENT_INSTALL_PATH") - - self.proton_prefix.setEnabled(False) - # lk: TODO: This has to be fixed properly. - # lk: It happens because of the widget update. Mask it for now behind disabling the save button - - self.linux_settings.wine_groupbox.setEnabled(True) - else: - self.proton_prefix.setEnabled(True) - self.linux_settings.wine_groupbox.setEnabled(False) - wrapper = self.possible_proton_wrappers[i - 1] - - self.wrapper_settings.add_wrapper(wrapper) - config_helper.add_option(self.game.app_name, "no_wine", "true") - config_helper.add_option( - f"{self.game.app_name}.env", - "STEAM_COMPAT_DATA_PATH", - os.path.expanduser("~/.proton"), - ) - config_helper.add_option( - f"{self.game.app_name}.env", - "STEAM_COMPAT_CLIENT_INSTALL_PATH", - str(Path.home().joinpath(".steam", "steam")) - ) - - self.proton_prefix.setText(os.path.expanduser("~/.proton")) - - # Don't use Wine - self.linux_settings.wine_exec.setText("") - self.linux_settings.wine_prefix.setText("") - - config_helper.save_config() - - def proton_prefix_edit(self, text: str) -> Tuple[bool, str, str]: - if not text: - text = os.path.expanduser("~/.proton") - return True, text, "" - parent = os.path.dirname(text) - return os.path.exists(parent), text, PathEdit.reasons.dir_not_exist - - def proton_prefix_save(self, text: str): - config_helper.add_option( - f"{self.game.app_name}.env", "STEAM_COMPAT_DATA_PATH", text - ) - config_helper.save_config() - - def update_game(self, app_name: str): + def load_settings(self, app_name): self.change = False + super(GameSettings, self).load_settings(app_name) self.game = self.core.get_game(app_name) self.igame = self.core.get_installed_game(self.game.app_name) if self.igame: @@ -314,34 +187,12 @@ class GameSettings(QWidget, Ui_GameSettings): self.skip_update.setCurrentIndex(0) self.title.setTitle(self.game.app_title) - self.wrapper_settings.load_settings(app_name) if platform.system() != "Windows": - self.linux_settings.update_game(app_name) - if self.igame and self.igame.platform == "Mac": self.linux_settings_widget.setVisible(False) else: self.linux_settings_widget.setVisible(True) - proton = self.wrapper_settings.wrappers.get("proton", None) - if proton: - proton = proton.text.replace('"', "") - self.proton_prefix.setEnabled(True) - self.proton_wrapper.setCurrentText( - f'"{proton.replace(" run", "")}" run' - ) - proton_prefix = self.core.lgd.config.get( - f"{app_name}.env", - "STEAM_COMPAT_DATA_PATH", - fallback=Path.home().joinpath(".proton"), - ) - self.proton_prefix.setText(proton_prefix) - self.linux_settings.wine_groupbox.setEnabled(False) - else: - self.proton_wrapper.setCurrentIndex(0) - self.proton_prefix.setEnabled(False) - self.linux_settings.wine_groupbox.setEnabled(True) - if not self.game.supports_cloud_saves: self.cloud_group.setEnabled(False) self.cloud_save_path_edit.setText("") @@ -362,21 +213,7 @@ class GameSettings(QWidget, Ui_GameSettings): self.override_exe_edit.setText( self.core.lgd.config.get(self.game.app_name, "override_exe", fallback="") ) + + self.pre_launch_settings.load_settings(app_name) + self.change = True - self.env_vars.update_game(app_name) - - - - -class LinuxAppSettings(LinuxSettings): - def __init__(self): - super(LinuxAppSettings, self).__init__() - - def update_game(self, app_name): - self.name = app_name - self.wine_prefix.setText(self.load_prefix()) - self.wine_exec.setText(self.load_setting(self.name, "wine_executable")) - - self.dxvk.load_settings(self.name) - - self.mangohud.load_settings(self.name) diff --git a/rare/components/tabs/games/game_utils.py b/rare/components/tabs/games/game_utils.py index 0d6b88b1..fd8e1a4a 100644 --- a/rare/components/tabs/games/game_utils.py +++ b/rare/components/tabs/games/game_utils.py @@ -2,18 +2,18 @@ import datetime import os import platform import shutil -import webbrowser from dataclasses import dataclass from logging import getLogger -from PyQt5.QtCore import QObject, QSettings, QProcess, QProcessEnvironment, pyqtSignal +from PyQt5.QtCore import QObject, QSettings, QProcess, QProcessEnvironment, pyqtSignal, QUrl +from PyQt5.QtGui import QDesktopServices from PyQt5.QtWidgets import QMessageBox, QPushButton +from legendary.models.game import LaunchParameters, InstalledGame -from legendary.models.game import LaunchParameters -from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton, ArgumentsSingleton from rare.components.dialogs.uninstall_dialog import UninstallDialog from rare.components.extra.console import ConsoleWindow from rare.components.tabs.games import CloudSaveUtils +from rare.shared import LegendaryCoreSingleton, GlobalSignalsSingleton, ArgumentsSingleton from rare.utils import legendary_utils from rare.utils.meta import RareGameMeta @@ -97,6 +97,7 @@ class GameUtils(QObject): except ValueError: logger.info("Cancel startup") self.sync_finished(app_name) + return except AssertionError: dont_sync_after_finish = True else: @@ -167,162 +168,32 @@ class GameUtils(QObject): ) return - process = GameProcess(app_name) - process.setProcessChannelMode(GameProcess.MergedChannels) + def _launch_real(): + process = self._get_process(app_name, env) + self.console.log("\n"*2) + if game.third_party_store != "Origin": + self._launch_game(igame, process, offline, skip_update_check, ask_always_sync) + else: + self._launch_origin(app_name, process) - if game.third_party_store != "Origin": - if not offline: - if not skip_update_check and not self.core.is_noupdate_game(app_name): - # check updates - try: - latest = self.core.get_asset( - app_name, igame.platform, update=False - ) - except ValueError: - self.finished.emit(app_name, self.tr("Metadata doesn't exist")) - return - else: - if latest.build_version != igame.version: - self.finished.emit(app_name, self.tr("Please update game")) - return - - params: LaunchParameters = self.core.get_launch_parameters( - app_name=app_name, offline=offline, wine_bin=wine_bin, wine_pfx=wine_pfx - ) - - full_params = list() - - if os.environ.get("container") == "flatpak": - full_params.extend(["flatpak-spawn", "--host"]) - - full_params.extend(params.launch_command) - 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) - - process.setWorkingDirectory(params.working_directory) - environment = QProcessEnvironment() - full_env = os.environ.copy() - full_env.update(params.environment) - for env, value in full_env.items(): - environment.insert(env, value) - - if platform.system() != "Windows": - # wine prefixes - for env in ["STEAM_COMPAT_DATA_PATH", "WINEPREFIX"]: - if val := full_env.get(env): - if not os.path.exists(val): - try: - os.makedirs(val) - except PermissionError as e: - logger.error(str(e)) - QMessageBox.warning( - None, - "Error", - self.tr( - "Error while launching {}. No permission to create {} for {}" - ).format(game.app_title, val, env), - ) - process.deleteLater() - return - # check wine executable - if shutil.which(full_params[0]) is None: - # wine binary does not exist - QMessageBox.warning( - None, - "Warning", - self.tr( - "'{}' does not exist. Please change it in Settings" - ).format(full_params[0]), - ) - process.deleteLater() - return - - if shutil.which(full_params[0]) is None: - QMessageBox.warning(None, "Warning", self.tr("'{}' does not exist").format(full_params[0])) + env = self.core.get_app_environment(app_name, wine_pfx=wine_pfx) + pre_cmd, wait = self.core.get_pre_launch_command(app_name) + if pre_cmd: + pre_cmd = pre_cmd.split() + pre_proc = self._launch_pre_command(env) + self.console.log("\n"*2) + pre_proc.start(pre_cmd[0], pre_cmd[1:]) + if wait: + pre_proc.finished.connect(_launch_real) return - - process.setProcessEnvironment(environment) - process.game_finished.connect(self.game_finished) - running_game = RunningGameModel( - process=process, app_name=app_name, always_ask_sync=ask_always_sync - ) - - process.start(full_params[0], full_params[1:]) - self.game_launched.emit(app_name) - self.signals.set_discord_rpc.emit(app_name) - logger.info(f"{game.app_title} launched") - - self.running_games[game.app_name] = running_game - - else: - origin_uri = self.core.get_origin_uri(game.app_name, self.args.offline) - logger.info("Launch Origin Game: ") - if platform.system() == "Windows": - webbrowser.open(origin_uri) - self.finished.emit(app_name, "") - return - wine_pfx = self.core.lgd.config.get( - game.app_name, "wine_prefix", fallback=os.path.expanduser("~/.wine") - ) - if not wine_bin: - wine_bin = self.core.lgd.config.get( - game.app_name, "wine_executable", fallback="/usr/bin/wine" - ) - - if shutil.which(wine_bin) is None: - # wine binary does not exist - QMessageBox.warning( - None, - "Warning", - self.tr( - "Wine executable '{}' does not exist. Please change it in Settings" - ).format(wine_bin), - ) - process.deleteLater() - return - - env = self.core.get_app_environment(game.app_name, wine_pfx=wine_pfx) - - if not env.get("WINEPREFIX") and not os.path.exists("/usr/bin/wine"): - logger.error( - f"In order to launch Origin correctly you must specify the wine binary and prefix " - f"to use in the configuration file or command line. See the README for details." - ) - self.finished.emit( - app_name, - self.tr("No wine executable selected. Please set it in settings"), - ) - return - - environment = QProcessEnvironment() - for e in env: - environment.insert(e, env[e]) - process.setProcessEnvironment(environment) - process.finished.connect(lambda x: self.game_finished(x, game.app_name)) - process.start(wine_bin, [origin_uri]) - - if QSettings().value("show_console", False, bool): - self.console.show() - process.readyReadStandardOutput.connect( - lambda: self.console.log( - str(process.readAllStandardOutput().data(), "utf-8", "ignore") - ) - ) - process.readyReadStandardError.connect( - lambda: self.console.error( - str(process.readAllStandardError().data(), "utf-8", "ignore") - ) - ) + _launch_real() def game_finished(self, exit_code, app_name): logger.info(f"Game exited with exit code: {exit_code}") + self.console.log(f"Game exited with code: {exit_code}") self.signals.set_discord_rpc.emit("") is_origin = self.core.get_game(app_name).third_party_store == "Origin" - if exit_code == 53 and is_origin: + if exit_code == 1 and is_origin: msg_box = QMessageBox() msg_box.setText( self.tr( @@ -334,7 +205,8 @@ class GameUtils(QObject): resp = msg_box.exec() # click install button if resp == 0: - webbrowser.open("https://www.dm.origin.com/download") + QDesktopServices.openUrl(QUrl("https://www.dm.origin.com/download")) + return if exit_code != 0: QMessageBox.warning( None, @@ -351,16 +223,14 @@ class GameUtils(QObject): self.running_games.pop(app_name) self.finished.emit(app_name, "") - if QSettings().value("show_console", False, bool): - self.console.log(f"Game exited with code: {exit_code}") - if self.core.get_game(app_name).supports_cloud_saves: if exit_code != 0: r = QMessageBox.question( None, "Question", self.tr( - "Game exited with code {}, which is not a normal code. It could be caused by a crash. Do you want to sync cloud saves" + "Game exited with code {}, which is not a normal code. " + "It could be caused by a crash. Do you want to sync cloud saves" ).format(exit_code), buttons=QMessageBox.Yes | QMessageBox.No, defaultButton=QMessageBox.Yes, @@ -369,6 +239,145 @@ class GameUtils(QObject): return self.cloud_save_utils.game_finished(app_name, game.always_ask_sync) + def _launch_pre_command(self, env: dict): + proc = QProcess() + environment = QProcessEnvironment() + for e in env: + environment.insert(e, env[e]) + proc.setProcessEnvironment(environment) + + proc.readyReadStandardOutput.connect( + lambda: self.console.log( + str(proc.readAllStandardOutput().data(), "utf-8", "ignore") + ) + ) + proc.readyReadStandardError.connect( + lambda: self.console.error( + str(proc.readAllStandardError().data(), "utf-8", "ignore") + ) + ) + return proc + + def _get_process(self, app_name, env): + process = GameProcess(app_name) + + environment = QProcessEnvironment() + for e in env: + environment.insert(e, env[e]) + process.setProcessEnvironment(environment) + + process.readyReadStandardOutput.connect( + lambda: self.console.log( + str(process.readAllStandardOutput().data(), "utf-8", "ignore") + ) + ) + process.readyReadStandardError.connect( + lambda: self.console.error( + str(process.readAllStandardError().data(), "utf-8", "ignore") + ) + ) + process.finished.connect(lambda x: self.game_finished(x, app_name)) + process.stateChanged.connect( + lambda state: self.console.show() + if (state == QProcess.Running + and QSettings().value("show_console", False, bool)) + else None + ) + return process + + def _launch_origin(self, app_name, process: QProcess): + origin_uri = self.core.get_origin_uri(app_name, self.args.offline) + logger.info("Launch Origin Game: ") + if platform.system() == "Windows": + QDesktopServices.openUrl(QUrl(origin_uri)) + self.finished.emit(app_name, "") + return + + command = self.core.get_app_launch_command(app_name) + + if not os.path.exists(command[0]) and shutil.which(command[0]) is None: + # wine binary does not exist + QMessageBox.warning( + None, "Warning", + self.tr( + "'{}' does not exist. Please change it in Settings" + ).format(command[0]), + ) + process.deleteLater() + return + command.append(origin_uri) + process.start(command[0], command[1:]) + + def _launch_game(self, igame: InstalledGame, process: QProcess, offline: bool, + skip_update_check: bool, ask_always_sync: bool): + if not offline: # skip for update + if not skip_update_check and not self.core.is_noupdate_game(igame.app_name): + # check updates + try: + latest = self.core.get_asset( + igame.app_name, igame.platform, update=False + ) + except ValueError: + self.finished.emit(igame.app_name, self.tr("Metadata doesn't exist")) + return + else: + if latest.build_version != igame.version: + self.finished.emit(igame.app_name, self.tr("Please update game")) + return + + params: LaunchParameters = self.core.get_launch_parameters( + app_name=igame.app_name, offline=offline + ) + + full_params = list() + + if os.environ.get("container") == "flatpak": + full_params.extend(["flatpak-spawn", "--host"]) + + full_params.extend(params.launch_command) + 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) + + process.setWorkingDirectory(params.working_directory) + + if platform.system() != "Windows": + # wine prefixes + for env in ["STEAM_COMPAT_DATA_PATH", "WINEPREFIX"]: + if val := process.processEnvironment().value(env, ""): + if not os.path.exists(val): + try: + os.makedirs(val) + except PermissionError as e: + logger.error(str(e)) + QMessageBox.warning( + None, + "Error", + self.tr( + "Error while launching {}. No permission to create {} for {}" + ).format(igame.title, val, env), + ) + process.deleteLater() + return + # check wine executable + + if shutil.which(full_params[0]) is None: + QMessageBox.warning(None, "Warning", self.tr("'{}' does not exist").format(full_params[0])) + return + running_game = RunningGameModel( + process=process, app_name=igame.app_name, always_ask_sync=ask_always_sync + ) + process.start(full_params[0], full_params[1:]) + + self.game_launched.emit(igame.app_name) + self.signals.set_discord_rpc.emit(igame.app_name) + logger.info(f"{igame.title} launched") + + self.running_games[igame.app_name] = running_game + def sync_finished(self, app_name): if app_name in self.launch_queue.keys(): self.cloud_save_finished.emit(app_name) diff --git a/rare/components/tabs/games/head_bar.py b/rare/components/tabs/games/head_bar.py index f0243633..ba104333 100644 --- a/rare/components/tabs/games/head_bar.py +++ b/rare/components/tabs/games/head_bar.py @@ -28,7 +28,7 @@ class GameListHeadBar(QWidget): self.filter = QComboBox() self.filter.addItems( [ - self.tr("All"), + self.tr("All games"), self.tr("Installed only"), self.tr("Offline Games"), ]) diff --git a/rare/components/tabs/games/import_sync/egl_sync_group.py b/rare/components/tabs/games/import_sync/egl_sync_group.py index c10a5ab0..eb096f5d 100644 --- a/rare/components/tabs/games/import_sync/egl_sync_group.py +++ b/rare/components/tabs/games/import_sync/egl_sync_group.py @@ -48,7 +48,7 @@ class EGLSyncGroup(QGroupBox, Ui_EGLSyncGroup): if not self.core.egl.programdata_path: self.egl_path_info.setText(self.tr("Updating...")) wine_resolver = WineResolver( - PathSpec.egl_programdata, "default", self.core + PathSpec.egl_programdata, "default" ) wine_resolver.signals.result_ready.connect(self.wine_resolver_cb) self.thread_pool.start(wine_resolver) diff --git a/rare/components/tabs/games/import_sync/import_group.py b/rare/components/tabs/games/import_sync/import_group.py index 811a60ab..e296d6e7 100644 --- a/rare/components/tabs/games/import_sync/import_group.py +++ b/rare/components/tabs/games/import_sync/import_group.py @@ -87,7 +87,7 @@ class ImportGroup(QGroupBox, Ui_ImportGroup): self.path_edit_layout.addWidget(self.path_edit) self.app_name = IndicatorLineEdit( - ph_text=self.tr("Use in case the app name was not found automatically"), + placeholder=self.tr("Use in case the app name was not found automatically"), completer=AppNameCompleter( app_names=[ (i.app_name, i.app_title) for i in self.api_results.game_list diff --git a/rare/components/tabs/settings/__init__.py b/rare/components/tabs/settings/__init__.py index cab992c8..eeb1e101 100644 --- a/rare/components/tabs/settings/__init__.py +++ b/rare/components/tabs/settings/__init__.py @@ -3,22 +3,21 @@ import platform from rare.utils.extra_widgets import SideTabWidget from .about import About from .legendary import LegendarySettings -from .linux import LinuxSettings +from rare.components.tabs.settings.widgets.linux import LinuxSettings from .rare import RareSettings +from .default_game_settings import DefaultGameSettings class SettingsTab(SideTabWidget): def __init__(self, parent=None): super(SettingsTab, self).__init__(parent=parent) - about_tab = 2 + about_tab = 3 self.rare_settings = RareSettings() self.addTab(self.rare_settings, "Rare") self.addTab(LegendarySettings(), "Legendary") - if platform.system() != "Windows": - self.addTab(LinuxSettings(), "Linux") - about_tab = 3 + self.addTab(DefaultGameSettings(True, self), self.tr("Games"), self.tr("Default game settings")) self.about = About() self.addTab(self.about, "About", "About") diff --git a/rare/components/tabs/settings/default_game_settings.py b/rare/components/tabs/settings/default_game_settings.py new file mode 100644 index 00000000..3fbca800 --- /dev/null +++ b/rare/components/tabs/settings/default_game_settings.py @@ -0,0 +1,127 @@ +import platform +from logging import getLogger + +from PyQt5.QtCore import QSettings, Qt +from PyQt5.QtWidgets import ( + QWidget, + QLabel +) + +from rare.components.tabs.settings.widgets.env_vars import EnvVars +from rare.components.tabs.settings.widgets.linux import LinuxSettings +from rare.components.tabs.settings.widgets.proton import ProtonSettings +from rare.components.tabs.settings.widgets.wrapper import WrapperSettings +from rare.shared import LegendaryCoreSingleton +from rare.ui.components.tabs.games.game_info.game_settings import Ui_GameSettings +from rare.utils import config_helper + +logger = getLogger("GameSettings") + + +class DefaultGameSettings(QWidget, Ui_GameSettings): + # variable to no update when changing game + change = False + app_name: str + + def __init__(self, is_default, parent=None): + super(DefaultGameSettings, self).__init__(parent=parent) + self.setupUi(self) + self.core = LegendaryCoreSingleton() + self.settings = QSettings() + + self.wrapper_settings = WrapperSettings() + + self.launch_settings_group.layout().addRow( + QLabel("Wrapper"), self.wrapper_settings + ) + + if platform.system() != "Windows": + self.linux_settings = LinuxAppSettings() + self.proton_settings = ProtonSettings(self.linux_settings, self.wrapper_settings) + self.game_settings_layout.replaceWidget(self.proton_placeholder, self.proton_settings) + self.proton_placeholder.deleteLater() + + # FIXME: Remove the spacerItem and margins from the linux settings + # FIXME: This should be handled differently at soem point in the future + self.linux_settings.layout().setContentsMargins(0, 0, 0, 0) + for item in [ + self.linux_settings.layout().itemAt(idx) + for idx in range(self.linux_settings.layout().count()) + ]: + if item.spacerItem(): + self.linux_settings.layout().removeItem(item) + del item + # FIXME: End of FIXME + self.linux_settings_layout.addWidget(self.linux_settings) + self.linux_settings_layout.setAlignment(Qt.AlignTop) + + self.game_settings_layout.setAlignment(Qt.AlignTop) + + self.linux_settings.mangohud.set_wrapper_activated.connect( + lambda active: self.wrapper_settings.add_wrapper("mangohud") + if active else self.wrapper_settings.delete_wrapper("mangohud")) + + else: + self.linux_settings_widget.setVisible(False) + + self.env_vars = EnvVars(self) + self.game_settings_layout.addWidget(self.env_vars) + + if is_default: + for i in range(4): # remove some entries which are not supported by default + self.launch_settings_layout.removeRow(0) + + self.cloud_group.deleteLater() + self.load_settings("default") + + def save_line_edit(self, option, value): + if value: + config_helper.add_option(self.game.app_name, option, value) + else: + config_helper.remove_option(self.game.app_name, option) + config_helper.save_config() + + if option == "wine_prefix": + if self.game.supports_cloud_saves: + self.compute_save_path() + + def update_combobox(self, i, option): + if self.change: + # remove section + if i: + if i == 1: + config_helper.add_option(self.game.app_name, option, "true") + if i == 2: + config_helper.add_option(self.game.app_name, option, "false") + else: + config_helper.remove_option(self.game.app_name, option) + config_helper.save_config() + + def load_settings(self, app_name): + self.app_name = app_name + self.wrapper_settings.load_settings(app_name) + if platform.system() != "Windows": + self.linux_settings.update_game(app_name) + proton = self.wrapper_settings.wrappers.get("proton", "") + if proton: + proton = proton.text + self.proton_settings.load_settings(app_name, proton) + if proton: + self.linux_settings.wine_groupbox.setEnabled(False) + else: + self.linux_settings.wine_groupbox.setEnabled(True) + self.env_vars.update_game(app_name) + + +class LinuxAppSettings(LinuxSettings): + def __init__(self): + super(LinuxAppSettings, self).__init__() + + def update_game(self, app_name): + self.name = app_name + self.wine_prefix.setText(self.load_prefix()) + self.wine_exec.setText(self.load_setting(self.name, "wine_executable")) + + self.dxvk.load_settings(self.name) + + self.mangohud.load_settings(self.name) diff --git a/rare/components/tabs/settings/legendary.py b/rare/components/tabs/settings/legendary.py index 37af5c13..1f7c3435 100644 --- a/rare/components/tabs/settings/legendary.py +++ b/rare/components/tabs/settings/legendary.py @@ -1,13 +1,14 @@ +import platform import re from logging import getLogger from typing import Tuple -from PyQt5.QtCore import Qt, QRunnable, QObject, pyqtSignal, QThreadPool +from PyQt5.QtCore import Qt, QRunnable, QObject, pyqtSignal, QThreadPool, QSettings from PyQt5.QtWidgets import QSizePolicy, QWidget, QFileDialog, QMessageBox -from rare.shared import LegendaryCoreSingleton from rare.components.tabs.settings.widgets.eos import EosWidget from rare.components.tabs.settings.widgets.ubisoft_activation import UbiActivationHelper +from rare.shared import LegendaryCoreSingleton from rare.ui.components.tabs.settings.legendary import Ui_LegendarySettings from rare.utils.extra_widgets import PathEdit, IndicatorLineEdit from rare.utils.utils import get_size @@ -38,6 +39,7 @@ class LegendarySettings(QWidget, Ui_LegendarySettings): def __init__(self, parent=None): super(LegendarySettings, self).__init__(parent=parent) self.setupUi(self) + self.settings = QSettings() self.core = LegendaryCoreSingleton() @@ -89,6 +91,12 @@ class LegendarySettings(QWidget, Ui_LegendarySettings): self.eos_widget = EosWidget() self.left_layout.insertWidget(3, self.eos_widget, alignment=Qt.AlignTop) + self.win32_cb.setChecked(self.settings.value("win32_meta", False, bool)) + self.win32_cb.stateChanged.connect(lambda: self.settings.setValue("win32_meta", self.win32_cb.isChecked())) + + self.mac_cb.setChecked(self.settings.value("mac_meta", platform.system() == "Darwin", bool)) + self.mac_cb.stateChanged.connect(lambda: self.settings.setValue("mac_meta", self.mac_cb.isChecked())) + self.refresh_game_meta_btn.clicked.connect(self.refresh_game_meta) def refresh_game_meta(self): diff --git a/rare/components/tabs/settings/linux.py b/rare/components/tabs/settings/widgets/linux.py similarity index 89% rename from rare/components/tabs/settings/linux.py rename to rare/components/tabs/settings/widgets/linux.py index dcf0003a..104fcf00 100644 --- a/rare/components/tabs/settings/linux.py +++ b/rare/components/tabs/settings/widgets/linux.py @@ -1,4 +1,5 @@ import os +import shutil from logging import getLogger from PyQt5.QtWidgets import QFileDialog, QWidget @@ -37,6 +38,7 @@ class LinuxSettings(QWidget, Ui_LinuxSettings): self.load_setting(self.name, "wine_executable"), file_type=QFileDialog.ExistingFile, name_filter="Wine executable (wine wine64)", + edit_func=lambda text: (os.path.exists(text) or not text, text, PathEdit.reasons.dir_not_exist), save_func=lambda text: self.save_setting( text, section=self.name, setting="wine_executable" ), @@ -46,9 +48,15 @@ class LinuxSettings(QWidget, Ui_LinuxSettings): # dxvk self.dxvk = DxvkSettings() self.overlay_layout.addWidget(self.dxvk) + self.dxvk.load_settings(self.name) self.mangohud = MangoHudSettings() self.overlay_layout.addWidget(self.mangohud) + self.mangohud.load_settings(self.name) + + if not shutil.which("mangohud"): + self.mangohud.setDisabled(True) + self.mangohud.setToolTip(self.tr("Mangohud is not installed or not in path")) def load_prefix(self) -> str: return self.load_setting( diff --git a/rare/components/tabs/settings/widgets/pre_launch.py b/rare/components/tabs/settings/widgets/pre_launch.py new file mode 100644 index 00000000..8b016be9 --- /dev/null +++ b/rare/components/tabs/settings/widgets/pre_launch.py @@ -0,0 +1,61 @@ +import os +import shutil +from typing import Tuple + +from PyQt5.QtWidgets import QHBoxLayout, QCheckBox, QFileDialog + +from rare.shared import LegendaryCoreSingleton +from rare.utils import config_helper +from rare.utils.extra_widgets import IndicatorLineEdit, PathEdit + + +class PreLaunchSettings(QHBoxLayout): + app_name: str + + def __init__(self): + super(PreLaunchSettings, self).__init__() + self.core = LegendaryCoreSingleton() + self.edit = PathEdit( + path="", + placeholder=self.tr("Path to script"), + file_type=QFileDialog.ExistingFile, + edit_func=self.edit_command, + save_func=self.save_pre_launch_command, + ) + self.layout().addWidget(self.edit) + + self.wait_check = QCheckBox(self.tr("Wait for finish")) + self.layout().addWidget(self.wait_check) + self.wait_check.stateChanged.connect(self.save_wait_finish) + + def edit_command(self, text: str) -> Tuple[bool, str, str]: + if not text.strip(): + return True, text, "" + + if not os.path.isfile(text.split()[0]) and not shutil.which(text.split()[0]): + return False, text, IndicatorLineEdit.reasons.file_not_exist + else: + return True, text, "" + + def save_pre_launch_command(self, text): + if text: + config_helper.add_option(self.app_name, "pre_launch_command", text) + self.wait_check.setDisabled(False) + else: + config_helper.remove_option(self.app_name, "pre_launch_command") + self.wait_check.setDisabled(True) + config_helper.remove_option(self.app_name, "pre_launch_wait") + + def save_wait_finish(self): + config_helper.add_option(self.app_name, "pre_launch_wait", str(self.wait_check.isChecked()).lower()) + + def load_settings(self, app_name): + self.app_name = app_name + + command = self.core.lgd.config.get(app_name, "pre_launch_command", fallback="") + self.edit.setText(command) + + wait = self.core.lgd.config.getboolean(app_name, "pre_launch_wait", fallback=False) + self.wait_check.setChecked(wait) + + self.wait_check.setEnabled(bool(command)) diff --git a/rare/components/tabs/settings/widgets/proton.py b/rare/components/tabs/settings/widgets/proton.py new file mode 100644 index 00000000..96145c5b --- /dev/null +++ b/rare/components/tabs/settings/widgets/proton.py @@ -0,0 +1,141 @@ +import os +from logging import getLogger +from pathlib import Path +from typing import Tuple + +from PyQt5.QtWidgets import QGroupBox, QFileDialog + +from rare.components.tabs.settings import LinuxSettings +from .wrapper import WrapperSettings +from rare.ui.components.tabs.settings.proton import Ui_ProtonSettings +from rare.utils import config_helper +from rare.utils.extra_widgets import PathEdit +from rare.shared import LegendaryCoreSingleton + +logger = getLogger("Proton") + +def find_proton_combos(): + possible_proton_combos = [] + compatibilitytools_dirs = [ + os.path.expanduser("~/.steam/steam/steamapps/common"), + "/usr/share/steam/compatibilitytools.d", + os.path.expanduser("~/.steam/compatibilitytools.d"), + os.path.expanduser("~/.steam/root/compatibilitytools.d"), + ] + for c in compatibilitytools_dirs: + if os.path.exists(c): + for i in os.listdir(c): + proton = os.path.join(c, i, "proton") + compatibilitytool = os.path.join(c, i, "compatibilitytool.vdf") + toolmanifest = os.path.join(c, i, "toolmanifest.vdf") + if os.path.exists(proton) and ( + os.path.exists(compatibilitytool) or os.path.exists(toolmanifest) + ): + wrapper = f'"{proton}" run' + possible_proton_combos.append(wrapper) + if not possible_proton_combos: + logger.warning("Unable to find any Proton version") + return possible_proton_combos + + +class ProtonSettings(QGroupBox, Ui_ProtonSettings): + + app_name: str + changeable = True + + def __init__(self, linux_settings: LinuxSettings, wrapper_settings: WrapperSettings): + super(ProtonSettings, self).__init__() + self.setupUi(self) + self._linux_settings = linux_settings + self._wrapper_settings = wrapper_settings + self.core = LegendaryCoreSingleton() + self.possible_proton_combos = find_proton_combos() + + self.proton_combo.addItems(self.possible_proton_combos) + self.proton_combo.currentIndexChanged.connect(self.change_proton) + + self.proton_prefix = PathEdit( + file_type=QFileDialog.DirectoryOnly, + edit_func=self.proton_prefix_edit, + save_func=self.proton_prefix_save, + placeholder=self.tr("Please select path for proton prefix") + ) + self.layout().replaceWidget(self.placeholder_prefix_edit, self.proton_prefix) + self.placeholder_prefix_edit.deleteLater() + + def change_proton(self, i): + if not self.changeable: + return + # First combo box entry: Don't use Proton + if i == 0: + self._wrapper_settings.delete_wrapper("proton") + config_helper.remove_option(self.app_name, "no_wine") + config_helper.remove_option(f"{self.app_name}.env", "STEAM_COMPAT_DATA_PATH") + config_helper.remove_option(f"{self.app_name}.env", "STEAM_COMPAT_CLIENT_INSTALL_PATH") + + self.proton_prefix.setEnabled(False) + # lk: TODO: This has to be fixed properly. + # lk: It happens because of the widget update. Mask it for now behind disabling the save button + + self._linux_settings.wine_groupbox.setEnabled(True) + else: + self.proton_prefix.setEnabled(True) + self._linux_settings.wine_groupbox.setEnabled(False) + wrapper = self.possible_proton_combos[i - 1] + self._wrapper_settings.add_wrapper(wrapper) + config_helper.add_option(self.app_name, "no_wine", "true") + config_helper.add_option( + f"{self.app_name}.env", + "STEAM_COMPAT_DATA_PATH", + os.path.expanduser("~/.proton"), + ) + config_helper.add_option( + f"{self.app_name}.env", + "STEAM_COMPAT_CLIENT_INSTALL_PATH", + str(Path.home().joinpath(".steam", "steam")) + ) + + self.proton_prefix.setText(os.path.expanduser("~/.proton")) + + # Don't use Wine + self._linux_settings.wine_exec.setText("") + self._linux_settings.wine_prefix.setText("") + + config_helper.save_config() + + def proton_prefix_edit(self, text: str) -> Tuple[bool, str, str]: + if not text: + text = os.path.expanduser("~/.proton") + return True, text, "" + parent_dir = os.path.dirname(text) + return os.path.exists(parent_dir), text, PathEdit.reasons.dir_not_exist + + def proton_prefix_save(self, text: str): + if not self.changeable: + return + config_helper.add_option( + f"{self.app_name}.env", "STEAM_COMPAT_DATA_PATH", text + ) + config_helper.save_config() + + def load_settings(self, app_name: str, proton: str): + self.changeable = False + self.app_name = app_name + proton = proton.replace('"', "") + self.proton_prefix.setEnabled(bool(proton)) + if proton: + print(proton) + self.proton_combo.setCurrentText( + f'"{proton.replace(" run", "")}" run' + ) + + else: + self.proton_combo.setCurrentIndex(0) + + proton_prefix = self.core.lgd.config.get( + f"{app_name}.env", + "STEAM_COMPAT_DATA_PATH", + fallback=str(Path.home().joinpath(".proton")), + ) + self.proton_prefix.setText(proton_prefix) + self.changeable = True diff --git a/rare/components/tabs/settings/widgets/wrapper.py b/rare/components/tabs/settings/widgets/wrapper.py index ab3e0e42..819f6753 100644 --- a/rare/components/tabs/settings/widgets/wrapper.py +++ b/rare/components/tabs/settings/widgets/wrapper.py @@ -166,6 +166,9 @@ class WrapperSettings(QWidget, Ui_WrapperSettings): self.widget_stack.setCurrentIndex(0) + if widget := self.wrappers.get(show_text, None): + widget.deleteLater() + widget = WrapperWidget(text, show_text, self.scroll_content) self.scroll_content.layout().addWidget(widget) self.adjust_scrollarea( @@ -173,7 +176,6 @@ class WrapperSettings(QWidget, Ui_WrapperSettings): self.wrapper_scroll.horizontalScrollBar().maximum() ) widget.delete_wrapper.connect(self.delete_wrapper) - self.wrappers[show_text] = widget if not from_load: diff --git a/rare/ui/components/tabs/games/game_info/game_settings.py b/rare/ui/components/tabs/games/game_info/game_settings.py index b3a8bcb8..8d15aa57 100644 --- a/rare/ui/components/tabs/games/game_info/game_settings.py +++ b/rare/ui/components/tabs/games/game_info/game_settings.py @@ -14,7 +14,7 @@ from PyQt5 import QtCore, QtGui, QtWidgets class Ui_GameSettings(object): def setupUi(self, GameSettings): GameSettings.setObjectName("GameSettings") - GameSettings.resize(545, 348) + GameSettings.resize(558, 357) self.game_settings_layout = QtWidgets.QVBoxLayout(GameSettings) self.game_settings_layout.setObjectName("game_settings_layout") self.launch_settings_group = QtWidgets.QGroupBox(GameSettings) @@ -82,30 +82,12 @@ class Ui_GameSettings(object): self.cloud_sync.setObjectName("cloud_sync") self.cloud_layout.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.cloud_sync) self.game_settings_layout.addWidget(self.cloud_group) - self.proton_group = QtWidgets.QGroupBox(GameSettings) - self.proton_group.setObjectName("proton_group") - self.proton_layout = QtWidgets.QFormLayout(self.proton_group) + self.proton_placeholder = QtWidgets.QWidget(GameSettings) + self.proton_placeholder.setObjectName("proton_placeholder") + self.proton_layout = QtWidgets.QFormLayout(self.proton_placeholder) self.proton_layout.setLabelAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter) self.proton_layout.setObjectName("proton_layout") - self.proton_wrapper_label = QtWidgets.QLabel(self.proton_group) - self.proton_wrapper_label.setObjectName("proton_wrapper_label") - self.proton_layout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.proton_wrapper_label) - self.proton_wrapper = QtWidgets.QComboBox(self.proton_group) - sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Fixed) - sizePolicy.setHorizontalStretch(0) - sizePolicy.setVerticalStretch(0) - sizePolicy.setHeightForWidth(self.proton_wrapper.sizePolicy().hasHeightForWidth()) - self.proton_wrapper.setSizePolicy(sizePolicy) - self.proton_wrapper.setObjectName("proton_wrapper") - self.proton_wrapper.addItem("") - self.proton_layout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.proton_wrapper) - self.proton_prefix_label = QtWidgets.QLabel(self.proton_group) - self.proton_prefix_label.setObjectName("proton_prefix_label") - self.proton_layout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.proton_prefix_label) - self.proton_prefix_layout = QtWidgets.QVBoxLayout() - self.proton_prefix_layout.setObjectName("proton_prefix_layout") - self.proton_layout.setLayout(2, QtWidgets.QFormLayout.FieldRole, self.proton_prefix_layout) - self.game_settings_layout.addWidget(self.proton_group) + self.game_settings_layout.addWidget(self.proton_placeholder) self.linux_settings_widget = QtWidgets.QWidget(GameSettings) self.linux_settings_widget.setObjectName("linux_settings_widget") self.linux_settings_layout = QtWidgets.QVBoxLayout(self.linux_settings_widget) @@ -134,10 +116,6 @@ class Ui_GameSettings(object): self.override_exe_edit.setPlaceholderText(_translate("GameSettings", "Relative path to launch executable")) self.cloud_group.setTitle(_translate("GameSettings", "Cloud Saves")) self.cloud_sync_label.setText(_translate("GameSettings", "Sync with cloud")) - self.proton_group.setTitle(_translate("GameSettings", "Proton Settings")) - self.proton_wrapper_label.setText(_translate("GameSettings", "Proton")) - self.proton_wrapper.setItemText(0, _translate("GameSettings", "Don\'t use Proton")) - self.proton_prefix_label.setText(_translate("GameSettings", "Prefix")) if __name__ == "__main__": diff --git a/rare/ui/components/tabs/games/game_info/game_settings.ui b/rare/ui/components/tabs/games/game_info/game_settings.ui index 6e114e79..9e28ab37 100644 --- a/rare/ui/components/tabs/games/game_info/game_settings.ui +++ b/rare/ui/components/tabs/games/game_info/game_settings.ui @@ -6,8 +6,8 @@