class EditGameConfigDialog(Gtk.Dialog, GameDialogCommon): """ Game config edit dialog """ def __init__(self, parent, game): super(EditGameConfigDialog, self).__init__() self.parent_window = parent self.game = game self.lutris_config = LutrisConfig(game=game) self.runner_name = self.lutris_config.runner game_name = self.lutris_config.config.get("realname", game) self.set_title("Edit game configuration for %s" % game_name) self.set_size_request(500, 500) self.build_notebook() self.build_game_tab() self.build_runner_tab() self.build_system_tab() self.build_action_area(Gtk.STOCK_EDIT, self.edit_game) self.show_all() self.run() def edit_game(self, _widget=None): """Save the changes""" self.lutris_config.save(config_type="game") self.destroy()
def install(self): success = super(hatari, self).install() if not success: return False config_path = os.path.expanduser('~/.hatari') if not os.path.exists(config_path): os.makedirs(config_path) bios_path = os.path.expanduser('~/.hatari/bios') if not os.path.exists(bios_path): os.makedirs(bios_path) dlg = QuestionDialog({ 'question': "Do you want to select an Atari ST BIOS file?", 'title': "Use BIOS file?", }) if dlg.result == dlg.YES: bios_dlg = FileDialog("Select a BIOS file") bios_filename = bios_dlg.filename if not bios_filename: return shutil.copy(bios_filename, bios_path) bios_path = os.path.join(bios_path, os.path.basename(bios_filename)) config = LutrisConfig(runner_slug='hatari') config.raw_runner_config.update({'bios_file': bios_path}) config.save() return True
def mark_as_installed(appid, runner_name, game_info): for key in ['name', 'slug']: assert game_info[key] logger.info("Setting %s as installed", game_info['name']) config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug'])) game_id = pga.add_or_update( name=game_info['name'], runner=runner_name, slug=game_info['slug'], installed=1, configpath=config_id, installer_slug=game_info['installer_slug'] ) config = LutrisConfig( runner_slug=runner_name, game_config_id=config_id, ) config.raw_game_config.update({ 'appid': appid, 'exe': game_info['exe'], 'args': game_info['args'] }) config.raw_system_config.update({ 'disable_runtime': True }) config.save() return game_id
def mark_as_installed(appid, runner_name, game_info): for key in ['name', 'slug']: assert game_info[key] logger.info("Setting %s as installed" % game_info['name']) config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug'])) game_id = pga.add_or_update( name=game_info['name'], runner=runner_name, slug=game_info['slug'], installed=1, configpath=config_id, installer_slug=game_info['installer_slug'] ) config = LutrisConfig( runner_slug=runner_name, game_config_id=config_id, ) config.raw_game_config.update({ 'appid': appid, 'exe': game_info['exe'], 'args': game_info['args'] }) config.raw_system_config.update({ 'disable_runtime': True }) config.save() return game_id
def create_config(self): """Create the game configuration for a Steam game""" game_config = LutrisConfig( runner_slug=self.runner, game_config_id=self.config_id ) game_config.raw_game_config.update({"appid": self.appid}) game_config.save()
def install(self): success = super(hatari, self).install() if not success: return False config_path = os.path.expanduser('~/.hatari') if not os.path.exists(config_path): os.makedirs(config_path) bios_path = os.path.expanduser('~/.hatari/bios') if not os.path.exists(bios_path): os.makedirs(bios_path) dlg = QuestionDialog({ 'question': "Do you want to select an Atari ST BIOS file?", 'title': "Use BIOS file?", }) if dlg.result == dlg.YES: bios_dlg = FileDialog("Select a BIOS file") bios_filename = bios_dlg.filename shutil.copy(bios_filename, bios_path) bios_path = os.path.join(bios_path, os.path.basename(bios_filename)) runner_config = LutrisConfig(runner='hatari') runner_config.config_type = 'runner' runner_config.runner_config = {'hatari': {'bios_file': bios_path}} runner_config.save() return True
def on_runner_installed(*args): bios_path = system.create_folder('~/.pcsxr/bios') dlg = QuestionDialog({ 'question': ("Do you want to select a Playstation BIOS file?\n\n" "The BIOS is the core code running the machine.\n" "PCSX-Reloaded includes an emulated BIOS, but it is " "still incomplete. \n" "Using an original BIOS avoids some bugs and reduced " "compatibility \n" "with some games."), 'title': "Use BIOS file?", }) if dlg.result == dlg.YES: bios_dlg = FileDialog("Select a BIOS file") bios_src = bios_dlg.filename shutil.copy(bios_src, bios_path) # Save bios in config bios_path = os.path.join(bios_path, os.path.basename(bios_src)) config = LutrisConfig(runner_slug='pcsxr') config.raw_runner_config.update({'bios': bios_path}) config.save() if callback: callback()
def install(self): success = super(pcsxr, self).install() if not success: return False config_path = os.path.expanduser('~/.pcsxr') if not os.path.exists(config_path): os.makedirs(config_path) # Bios bios_path = os.path.expanduser('~/.pcsxr/bios') if not os.path.exists(bios_path): os.makedirs(bios_path) dlg = QuestionDialog({ 'question': ("Do you want to select a Playstation BIOS file?\n\n" "The BIOS is the core code running the machine.\n" "PCSX-Reloaded includes an emulated BIOS, but it is " "still incomplete. \n" "Using an original BIOS avoids some bugs and reduced " "compatibility \n" "with some games."), 'title': "Use BIOS file?", }) if dlg.result == dlg.YES: bios_dlg = FileDialog("Select a BIOS file") bios_src = bios_dlg.filename shutil.copy(bios_src, bios_path) # Save bios in config bios_path = os.path.join(bios_path, os.path.basename(bios_src)) runner_config = LutrisConfig(runner='pcsxr') runner_config.config_type = 'runner' runner_config.runner_config = {'pcsxr': {'bios': bios_path}} runner_config.save() return True
def create_config(self, db_game, config_id): details = json.loads(db_game["details"]) config = LutrisConfig(runner_slug="linux", game_config_id=config_id) config.raw_game_config.update({ "exe": details["exe"], "args": details["args"], }) config.raw_system_config.update({"disable_runtime": True}) config.save()
def create_config(self): """Create a Lutris config for the current game""" config = LutrisConfig(runner_slug=self.runner, game_config_id=self.config_id) config.raw_game_config.update({ "appid": self.appid, "exe": self.details["exe"], "args": self.details["args"] }) config.raw_system_config.update({"disable_runtime": True}) config.save()
def install(self, installer_path=None): if installer_path: self.msi_exec(installer_path, quiet=True) Gdk.threads_enter() dlg = DirectoryDialog('Where is Steam.exe installed?') self.game_path = dlg.folder Gdk.threads_leave() config = LutrisConfig(runner='winesteam') config.runner_config = {'system': {'game_path': self.game_path}} config.save()
class RunnerConfigDialog(Gtk.Dialog): """Runners management dialog.""" def __init__(self, runner): Gtk.Dialog.__init__(self) runner_name = runner.__class__.__name__ self.set_title("Configure %s" % runner_name) self.set_size_request(570, 500) self.runner_name = runner_name self.lutris_config = LutrisConfig(runner=runner_name) # Notebook for choosing between runner and system configuration self.notebook = Gtk.Notebook() self.vbox.pack_start(self.notebook, True, True, 0) # Runner configuration self.runner_config_vbox = RunnerBox(self.lutris_config, "runner", self.runner_name) runner_scrollwindow = Gtk.ScrolledWindow() runner_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) runner_scrollwindow.add_with_viewport(self.runner_config_vbox) self.notebook.append_page(runner_scrollwindow, Gtk.Label(label="Runner configuration")) # System configuration self.system_config_vbox = SystemBox(self.lutris_config, "runner") system_scrollwindow = Gtk.ScrolledWindow() system_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) system_scrollwindow.add_with_viewport(self.system_config_vbox) self.notebook.append_page(system_scrollwindow, Gtk.Label(label="System configuration")) # Action buttons cancel_button = Gtk.Button("Cancel") ok_button = Gtk.Button("Ok") self.action_area.pack_start(cancel_button, True, True, 0) self.action_area.pack_start(ok_button, True, True, 0) cancel_button.connect("clicked", self.close) ok_button.connect("clicked", self.ok_clicked) self.show_all() self.run() def close(self, _widget): self.destroy() def ok_clicked(self, _wigdet): self.lutris_config.config_type = "runner" self.lutris_config.save() self.destroy()
class RunnerConfigDialog(Gtk.Dialog): """Runners management dialog""" def __init__(self, runner): Gtk.Dialog.__init__(self) runner_name = runner.__class__.__name__ self.set_title("Configure %s" % runner_name) self.set_size_request(570, 500) self.runner = runner_name self.lutris_config = LutrisConfig(runner=runner_name) #Notebook for choosing between runner and system configuration self.notebook = Gtk.Notebook() self.vbox.pack_start(self.notebook, True, True, 0) #Runner configuration self.runner_config_vbox = RunnerBox(self.lutris_config, "runner") runner_scrollwindow = Gtk.ScrolledWindow() runner_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) runner_scrollwindow.add_with_viewport(self.runner_config_vbox) self.notebook.append_page(runner_scrollwindow, Gtk.Label(label="Runner configuration")) #System configuration self.system_config_vbox = SystemBox(self.lutris_config, "runner") system_scrollwindow = Gtk.ScrolledWindow() system_scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) system_scrollwindow.add_with_viewport(self.system_config_vbox) self.notebook.append_page(system_scrollwindow, Gtk.Label(label="System configuration")) #Action buttons cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL) ok_button = Gtk.Button(None, Gtk.STOCK_OK) self.action_area.pack_start(cancel_button, True, True, 0) self.action_area.pack_start(ok_button, True, True, 0) cancel_button.connect("clicked", self.close) ok_button.connect("clicked", self.ok_clicked) self.show_all() self.run() def close(self, _widget): self.destroy() def ok_clicked(self, _wigdet): assert self.lutris_config.config_type == 'runner' self.lutris_config.config_type = "runner" self.lutris_config.save() self.destroy()
class SystemConfigDialog(Dialog, GameDialogCommon): def __init__(self): super(SystemConfigDialog, self).__init__("System preferences") self.set_size_request(500, 500) self.lutris_config = LutrisConfig() self.system_config_vbox = SystemBox(self.lutris_config, 'system') self.vbox.pack_start(self.system_config_vbox, True, True, 0) self.build_action_area("Save", self.save_config) self.show_all() def save_config(self, widget): self.lutris_config.save() self.destroy()
class RunnerConfigDialog(GameDialogCommon): """Runner config edit dialog.""" def __init__(self, runner, parent=None): self.runner_name = runner.__class__.__name__ super().__init__(_("Configure %s") % runner.human_name, parent=parent) self.saved = False self.lutris_config = LutrisConfig(runner_slug=self.runner_name) self.build_notebook() self.build_tabs("runner") self.build_action_area(self.on_save) self.show_all() def on_save(self, wigdet, data=None): self.lutris_config.save() self.destroy()
def on_runner_installed(*args): config_path = system.create_folder("~/.atari800") bios_archive = os.path.join(config_path, "atari800-bioses.zip") dlg = DownloadDialog(self.bios_url, bios_archive) dlg.run() if not system.path_exists(bios_archive): ErrorDialog("Could not download Atari800 BIOS archive") return extract.extract_archive(bios_archive, config_path) os.remove(bios_archive) config = LutrisConfig(runner_slug="atari800") config.raw_runner_config.update({"bios_path": config_path}) config.save() if callback: callback()
def on_runner_installed(*args): # pylint: disable=unused-argument config_path = system.create_folder("~/.atari800") bios_archive = os.path.join(config_path, "atari800-bioses.zip") dlg = DownloadDialog(self.bios_url, bios_archive) dlg.run() if not system.path_exists(bios_archive): ErrorDialog(_("Could not download Atari 800 BIOS archive")) return extract.extract_archive(bios_archive, config_path) os.remove(bios_archive) config = LutrisConfig(runner_slug="atari800") config.raw_runner_config.update({"bios_path": config_path}) config.save() if callback: callback()
def on_runner_installed(*args): config_path = system.create_folder("~/.atari800") bios_archive = os.path.join(config_path, 'atari800-bioses.zip') dlg = DownloadDialog(self.bios_url, bios_archive) dlg.run() if not system.path_exists(bios_archive): ErrorDialog("Could not download Atari800 BIOS archive") return extract.extract_archive(bios_archive, config_path) os.remove(bios_archive) config = LutrisConfig(runner_slug='atari800') config.raw_runner_config.update({'bios_path': config_path}) config.save() if callback: callback()
def mark_as_installed(scummvm_id, name, path): """Add scummvm from the auto-import""" logger.info("Setting %s as installed" % name) slug = slugify(name) config_id = make_game_config_id(slug) game_id = pga.add_or_update(name=name, runner='scummvm', installer_slug=INSTALLER_SLUG, slug=slug, installed=1, configpath=config_id, directory=path) config = LutrisConfig(runner_slug='scummvm', game_config_id=config_id) config.raw_game_config.update({'game_id': scummvm_id, 'path': path}) config.save() return game_id
def on_runner_installed(*args): bios_path = system.create_folder('~/.hatari/bios') dlg = QuestionDialog({ 'question': "Do you want to select an Atari ST BIOS file?", 'title': "Use BIOS file?", }) if dlg.result == dlg.YES: bios_dlg = FileDialog("Select a BIOS file") bios_filename = bios_dlg.filename if not bios_filename: return shutil.copy(bios_filename, bios_path) bios_path = os.path.join(bios_path, os.path.basename(bios_filename)) config = LutrisConfig(runner_slug='hatari') config.raw_runner_config.update({'bios_file': bios_path}) config.save() if callback: callback()
class SystemConfigDialog(Dialog, GameDialogCommon): def __init__(self, parent=None): super().__init__("System preferences", parent=parent) self.game = None self.runner_name = None self.lutris_config = LutrisConfig() self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.build_notebook() self.build_tabs("system") self.build_action_area(self.on_save) self.show_all() def on_save(self, _widget): self.lutris_config.save() self.destroy()
def install(self): success = super(atari800, self).install() if not success: return False config_path = os.path.expanduser("~/.atari800") if not os.path.exists(config_path): os.makedirs(config_path) bios_archive = os.path.join(config_path, 'atari800-bioses.zip') dlg = DownloadDialog(self.bios_url, bios_archive) dlg.run() if not os.path.exists(bios_archive): ErrorDialog("Could not download Atari800 BIOS archive") return extract.extract_archive(bios_archive, config_path) os.remove(bios_archive) config = LutrisConfig(runner_slug='atari800') config.raw_runner_config.update({'bios_path': config_path}) config.save()
def mark_as_installed(scummvm_id, name, path): """Add scummvm from the auto-import""" logger.info("Setting %s as installed", name) slug = slugify(name) config_id = make_game_config_id(slug) game_id = pga.add_or_update( name=name, runner="scummvm", installer_slug=INSTALLER_SLUG, slug=slug, installed=1, configpath=config_id, directory=path, ) config = LutrisConfig(runner_slug="scummvm", game_config_id=config_id) config.raw_game_config.update({"game_id": scummvm_id, "path": path}) config.save() return game_id
def write_config(self, _id, name, fullpath): """Write game configuration to settings directory.""" system = self.__class__.__name__ index = fullpath.rindex("/") exe = fullpath[index + 1:] path = fullpath[:index] if path.startswith("file://"): path = path[7:] config = LutrisConfig() config.config = { "main": { "path": path, "exe": exe, "realname": name, "runner": system } } config.save(config_type="game")
class SystemConfigDialog(Gtk.Dialog, GameDialogCommon): title = "System preferences" dialog_height = 500 def __init__(self): super(SystemConfigDialog, self).__init__() self.set_title(self.title) self.set_size_request(500, self.dialog_height) self.lutris_config = LutrisConfig() self.system_config_vbox = SystemBox(self.lutris_config, 'system') self.vbox.pack_start(self.system_config_vbox, True, True, 0) self.build_action_area("Save", self.save_config) self.show_all() def save_config(self, widget): assert self.lutris_config.config_type == 'system' self.lutris_config.save() self.destroy()
class SystemConfigDialog(Dialog, GameDialogCommon): def __init__(self, parent=None): super().__init__("System preferences", parent=parent) self.game = None self.runner_name = None self.lutris_config = LutrisConfig() self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.system_box = SystemBox(self.lutris_config) self.system_sw = self.build_scrolled_window(self.system_box) self.vbox.pack_start(self.system_sw, True, True, 0) self.build_action_area(self.on_save) self.show_all() def on_save(self, widget): self.lutris_config.save() self.destroy()
def install(self): success = super(atari800, self).install() if not success: return False config_path = os.path.expanduser("~/.atari800") if not os.path.exists(config_path): os.makedirs(config_path) bios_archive = os.path.join(config_path, 'atari800-bioses.zip') dlg = DownloadDialog(self.bios_url, bios_archive) dlg.run() if not os.path.exists(bios_archive): ErrorDialog("Could not download Atari800 BIOS archive") return extract_archive(bios_archive, config_path) os.remove(bios_archive) runner_config = LutrisConfig(runner='atari800') runner_config.config_type = 'runner' runner_config.runner_config = {'atari800': {'bios_path': config_path}} runner_config.save()
class SystemConfigDialog(Dialog, GameDialogCommon): def __init__(self): super(SystemConfigDialog, self).__init__("System preferences") self.game = None self.runner_name = None self.lutris_config = LutrisConfig() self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.system_box = SystemBox(self.lutris_config) self.system_sw = self.build_scrolled_window(self.system_box) self.vbox.pack_start(self.system_sw, True, True, 0) self.build_action_area("Save", self.save_config) self.show_all() def save_config(self, widget): self.lutris_config.save() self.destroy()
def migrate(): games = pga.get_games(filter_installed=True) for game_info in games: if game_info["runner"] != "steam" or game_info["configpath"]: continue slug = game_info["slug"] config_id = make_game_config_id(slug) # Add configpath to db pga.add_or_update(name=game_info["name"], runner="steam", slug=slug, configpath=config_id) # Add appid to config game_config = LutrisConfig(runner_slug="steam", game_config_id=config_id) game_config.raw_game_config.update( {"appid": str(game_info["steamid"])}) game_config.save()
def mark_as_installed(steamid, runner_name, game_info): for key in ['name', 'slug']: assert game_info[key] logger.info("Setting %s as installed" % game_info['name']) config_id = (game_info.get('config_path') or make_game_config_id(game_info['slug'])) game_id = pga.add_or_update( steamid=int(steamid), name=game_info['name'], runner=runner_name, slug=game_info['slug'], installed=1, configpath=config_id, ) game_config = LutrisConfig( runner_slug=runner_name, game_config_id=config_id, ) game_config.raw_game_config.update({'appid': steamid}) game_config.save() return game_id
class RunnerConfigDialog(Dialog, GameDialogCommon): """Runner config edit dialog.""" def __init__(self, runner, parent=None): self.runner_name = runner.__class__.__name__ super().__init__("Configure %s" % runner.human_name, parent=parent) self.game = None self.saved = False self.lutris_config = LutrisConfig(runner_slug=self.runner_name) self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.build_notebook() self.build_tabs("runner") self.build_action_area(self.on_save) self.show_all() def on_save(self, wigdet, data=None): self.lutris_config.save() self.destroy()
class RunnerConfigDialog(Dialog, GameDialogCommon): """Runner config edit dialog.""" def __init__(self, runner, parent=None): self.runner_name = runner.__class__.__name__ super(RunnerConfigDialog, self).__init__("Configure %s" % self.runner_name, parent=parent) self.game = None self.saved = False self.lutris_config = LutrisConfig(runner_slug=self.runner_name) self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.build_notebook() self.build_tabs('runner') self.build_action_area(self.on_save) self.show_all() def on_save(self, wigdet, data=None): self.lutris_config.save() self.destroy()
class RunnerConfigDialog(Dialog, GameDialogCommon): """Runners management dialog.""" def __init__(self, runner): self.runner_name = runner.__class__.__name__ super(RunnerConfigDialog, self).__init__( "Configure %s" % self.runner_name ) self.game = None self.saved = False self.lutris_config = LutrisConfig(runner_slug=self.runner_name) self.set_default_size(DIALOG_WIDTH, DIALOG_HEIGHT) self.build_notebook() self.build_tabs('runner') self.build_action_area("Edit", self.ok_clicked) self.show_all() def ok_clicked(self, _wigdet): self.lutris_config.save() self.destroy()
class AddGameDialog(Gtk.Dialog, GameDialogCommon): """ Add game dialog class""" def __init__(self, parent, game=None): super(AddGameDialog, self).__init__() self.parent_window = parent self.lutris_config = LutrisConfig() self.runner_name = None self.set_title("Add a new game") self.set_size_request(600, 500) if game: name = game.name self.slug = game.slug else: name = None self.slug = None self.build_name_entry(name) self.build_runner_dropdown() self.build_notebook() self.build_game_tab() self.build_runner_tab() self.build_system_tab() self.build_action_area(Gtk.STOCK_ADD, self.save_game) self.show_all() self.run() def save_game(self, _button): """ OK button pressed in the Add Game Dialog """ name = self.name_entry.get_text() self.lutris_config.config["realname"] = name self.lutris_config.config["runner"] = self.runner_name if self.runner_name and name: self.slug = self.lutris_config.save(config_type="game") runner_class = lutris.runners.import_runner(self.runner_name) runner = runner_class(self.lutris_config) pga.add_or_update(name, self.runner_name, slug=self.slug, directory=runner.get_game_path(), installed=1) self.destroy() def on_runner_changed(self, widget): """Action called when runner drop down is changed""" runner_index = widget.get_active() current_page = self.notebook.get_current_page() self.clear_tabs() if runner_index == 0: self.runner_name = None self.lutris_config = LutrisConfig() else: self.runner_name = widget.get_model()[runner_index][1] self.lutris_config = LutrisConfig(self.runner_name) self.build_game_tab() self.build_runner_tab() self.build_system_tab() self.notebook.set_current_page(current_page)
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_game_by_field(self.slug, 'slug', all=True) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() shortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def save(self): self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return sdl_video_fullscreen = system_config.get('sdl_video_fullscreen') or '' env['SDL_VIDEO_FULLSCREEN_DISPLAY'] = sdl_video_fullscreen restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(xephyr_command) xephyr_thread.start() time.sleep(3) env['DISPLAY'] = ':2' if system_config.get('use_us_layout'): setxkbmap_command = ['setxkbmap', '-model', 'pc101', 'us', '-print'] xkbcomp_command = ['xkbcomp', '-', os.environ.get('DISPLAY', ':0')] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) single_cpu = system_config.get('single_cpu') or False if single_cpu: logger.info('The game will run on a single CPU core') launch_arguments.insert(0, '0') launch_arguments.insert(0, '-c') launch_arguments.insert(0, 'taskset') terminal = system_config.get('terminal') if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) self.state = self.STATE_STOPPED return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): self.state = self.STATE_STOPPED if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.state = self.STATE_STOPPED os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv') \ and self.xboxdrv_thread.is_running: self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>")
class Game(GObject.Object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = "idle" STATE_STOPPED = "stopped" STATE_RUNNING = "running" __gsignals__ = { "game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )), "game-start": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-started": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stopped": (GObject.SIGNAL_RUN_FIRST, None, (int, )), "game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()), } def __init__(self, game_id=None): super().__init__() self.id = game_id # pylint: disable=invalid-name self.runner = None self.config = None # Load attributes from database game_data = pga.get_game_by_field(game_id, "id") self.slug = game_data.get("slug") or "" self.runner_name = game_data.get("runner") or "" self.directory = game_data.get("directory") or "" self.name = game_data.get("name") or "" self.game_config_id = game_data.get("configpath") or "" self.is_installed = bool( game_data.get("installed") and self.game_config_id) self.platform = game_data.get("platform") or "" self.year = game_data.get("year") or "" self.lastplayed = game_data.get("lastplayed") or 0 self.steamid = game_data.get("steamid") or "" self.has_custom_banner = bool(game_data.get("has_custom_banner")) self.has_custom_icon = bool(game_data.get("has_custom_icon")) self.discord_presence = DiscordPresence() try: self.playtime = float(game_data.get("playtime") or 0.0) except ValueError: logger.error("Invalid playtime value %s", game_data.get("playtime")) self.playtime = 0.0 if self.game_config_id: self.load_config() self.game_thread = None self.prelaunch_executor = None self.heartbeat = None self.killswitch = None self.state = self.STATE_IDLE self.game_runtime_config = {} self.resolution_changed = False self.compositor_disabled = False self.original_outputs = None self._log_buffer = None self.timer = Timer() self.screen_saver_inhibitor_cookie = None def __repr__(self): return self.__str__() def __str__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value @property def log_buffer(self): """Access the log buffer object, creating it if necessary""" if self._log_buffer is None: self._log_buffer = Gtk.TextBuffer() self._log_buffer.create_tag("warning", foreground="red") if self.game_thread: self.game_thread.set_log_buffer(self._log_buffer) self._log_buffer.set_text(self.game_thread.stdout) return self._log_buffer @property def formatted_playtime(self): """Return a human readable formatted play time""" return strings.get_formatted_playtime(self.playtime) @property def is_search_result(self): """Return whether or not the game is a remote game from search results. This is bad, find another way to do this. """ return self.id < 0 @staticmethod def show_error_message(message): """Display an error message based on the runner's output.""" if message["error"] == "CUSTOM": message_text = message["text"].replace("&", "&") dialogs.ErrorDialog(message_text) elif message["error"] == "RUNNER_NOT_INSTALLED": dialogs.ErrorDialog(_("Error the runner is not installed")) elif message["error"] == "NO_BIOS": dialogs.ErrorDialog(_("A bios file is required to run this game")) elif message["error"] == "FILE_NOT_FOUND": filename = message["file"] if filename: message_text = _("The file {} could not be found").format( filename.replace("&", "&")) else: message_text = _("No file provided") dialogs.ErrorDialog(message_text) elif message["error"] == "NOT_EXECUTABLE": message_text = message["file"].replace("&", "&") dialogs.ErrorDialog( _("The file %s is not executable") % message_text) elif message["error"] == "PATH_NOT_SET": message_text = _( "The path '%s' is not set. please set it in the options." ) % message["path"] dialogs.ErrorDialog(message_text) else: dialogs.ErrorDialog(_("Unhandled error: %s") % message["error"]) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.game_path def _get_runner(self): """Return the runner instance for this game's configuration""" try: runner_class = import_runner(self.runner_name) return runner_class(self.config) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) def load_config(self): """Load the game's configuration.""" if not self.is_installed: return self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) self.runner = self._get_runner() if self.discord_presence.available: self.discord_presence.client_id = ( self.config.system_config.get("discord_client_id") or DEFAULT_DISCORD_CLIENT_ID) self.discord_presence.game_name = ( self.config.system_config.get("discord_custom_game_name") or self.name) self.discord_presence.show_runner = self.config.system_config.get( "discord_show_runner", True) self.discord_presence.runner_name = ( self.config.system_config.get("discord_custom_runner_name") or self.runner_name) self.discord_presence.rpc_enabled = self.config.system_config.get( "discord_rpc_enabled", True) def set_desktop_compositing(self, enable): """Enables or disables compositing""" if enable: if self.compositor_disabled: enable_compositing() self.compositor_disabled = False else: if not self.compositor_disabled: disable_compositing() self.compositor_disabled = True def remove(self, from_library=False, from_disk=False): """Uninstall a game Params: from_library (bool): Completely remove the game from library, do not set it as uninstalled from_disk (bool): Delete the game files Return: bool: Updated value for from_library """ if from_disk and self.runner: logger.debug("Removing game %s from disk", self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library", self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) if self.config: self.config.remove() xdgshortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) self.is_installed = False self.emit("game-removed") return from_library def set_platform_from_runner(self): """Set the game's platform from the runner""" if not self.runner: logger.warning("Game has no runner, can't set platform") return self.platform = self.runner.get_platform() if not self.platform: logger.warning("Can't get platform for runner %s", self.runner.human_name) def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ logger.debug("Saving %s", self) if not metadata_only: self.config.save() self.set_platform_from_runner() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id, playtime=self.playtime, ) self.emit("game-updated") def is_launchable(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: %s", runtime_updater.current_updates) dialogs.ErrorDialog(_("Runtime currently updating"), _("Game might not work as expected")) if ("wine" in self.runner_name and not wine.get_system_wine_version() and not LINUX_SYSTEM.is_flatpak): # TODO find a reference to the root window or better yet a way not # to have Gtk dependent code in this class. root_window = None dialogs.WineNotInstalledWarning(parent=root_window) return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog( _("Invalid game configuration: Missing runner")) self.state = self.STATE_STOPPED self.emit("game-stop") return if not self.is_launchable(): self.state = self.STATE_STOPPED self.emit("game-stop") return self.emit("game-start") jobs.AsyncCall(self.runner.prelaunch, self.configure_game) def restrict_to_display(self, display): outputs = DISPLAY_MANAGER.get_config() if display == "primary": display = None for output in outputs: if output.primary: display = output.name break if not display: logger.warning("No primary display set") else: found = False for output in outputs: if output.name == display: found = True break if not found: logger.warning("Selected display %s not found", display) display = None if display: turn_off_except(display) time.sleep(3) return True return False def get_launch_parameters(self, gameplay_info): system_config = self.runner.system_config launch_arguments = gameplay_info["command"] optimus = system_config.get("optimus") if optimus == "primusrun" and system.find_executable("primusrun"): launch_arguments.insert(0, "primusrun") elif optimus == "optirun" and system.find_executable("optirun"): launch_arguments.insert(0, "virtualgl") launch_arguments.insert(0, "-b") launch_arguments.insert(0, "optirun") elif optimus == "pvkrun" and system.find_executable("pvkrun"): launch_arguments.insert(0, "pvkrun") # Mangohud activation mangohud = system_config.get("mangohud") or "" if mangohud and system.find_executable("mangohud"): # This is probably not the way to go. This only work with a few # Wine games. It will probably crash it, or do nothing at all. # I have never got mangohud to work on anything other than a Wine # game. dialogs.NoticeDialog( "MangoHud support is experimental. Expect the " "game to crash or the framerate counter not to " "appear at all.") launch_arguments = ["mangohud"] + launch_arguments fps_limit = system_config.get("fps_limit") or "" if fps_limit: strangle_cmd = system.find_executable("strangle") if strangle_cmd: launch_arguments = [strangle_cmd, fps_limit] + launch_arguments else: logger.warning( "libstrangle is not available on this system, FPS limiter disabled" ) prefix_command = system_config.get("prefix_command") or "" if prefix_command: launch_arguments = ( shlex.split(os.path.expandvars(prefix_command)) + launch_arguments) single_cpu = system_config.get("single_cpu") or False if single_cpu: logger.info("The game will run on a single CPU core") launch_arguments.insert(0, "0") launch_arguments.insert(0, "-c") launch_arguments.insert(0, "taskset") env = {} env.update(self.runner.get_env()) env.update(gameplay_info.get("env") or {}) env["game_name"] = self.name # Set environment variables dependent on gameplay info # LD_PRELOAD ld_preload = gameplay_info.get("ld_preload") if ld_preload: env["LD_PRELOAD"] = ld_preload # LD_LIBRARY_PATH game_ld_libary_path = gameplay_info.get("ld_library_path") if game_ld_libary_path: ld_library_path = env.get("LD_LIBRARY_PATH") if not ld_library_path: ld_library_path = "$LD_LIBRARY_PATH" env["LD_LIBRARY_PATH"] = ":".join( [game_ld_libary_path, ld_library_path]) # Feral gamemode gamemode = system_config.get( "gamemode") and LINUX_SYSTEM.gamemode_available() if gamemode: if system.find_executable("gamemoderun"): launch_arguments.insert(0, "gamemoderun") else: env["LD_PRELOAD"] = ":".join([ path for path in [ env.get("LD_PRELOAD"), "libgamemodeauto.so", ] if path ]) return launch_arguments, env def start_xephyr(self, display=":2"): """Start a monitored Xephyr instance""" if not system.find_executable("Xephyr"): raise GameConfigError( "Unable to find Xephyr, install it or disable the Xephyr option" ) xephyr_depth = "8" if self.runner.system_config.get( "xephyr") == "8bpp" else "16" xephyr_resolution = self.runner.system_config.get( "xephyr_resolution") or "640x480" xephyr_command = [ "Xephyr", display, "-ac", "-screen", xephyr_resolution + "x" + xephyr_depth, "-glamor", "-reset", "-terminate", ] if self.runner.system_config.get("xephyr_fullscreen"): xephyr_command.append("-fullscreen") xephyr_thread = MonitoredCommand(xephyr_command) xephyr_thread.start() time.sleep(3) return display @staticmethod def set_keyboard_layout(layout): setxkbmap_command = ["setxkbmap", "-model", "pc101", layout, "-print"] xkbcomp_command = ["xkbcomp", "-", os.environ.get("DISPLAY", ":0")] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() def start_prelaunch_command(self): """Start the prelaunch command specified in the system options""" prelaunch_command = self.runner.system_config.get("prelaunch_command") command_array = shlex.split(prelaunch_command) if not system.path_exists(command_array[0]): logger.warning("Command %s not found", command_array[0]) return self.prelaunch_executor = MonitoredCommand( command_array, include_processes=[os.path.basename(command_array[0])], env=self.game_runtime_config["env"], cwd=self.directory, ) self.prelaunch_executor.start() logger.info("Running %s in the background", prelaunch_command) def get_terminal(self): """Return the terminal used to run the game into or None if the game is not run from a terminal. Remember that only games using text mode should use the terminal. """ if self.runner.system_config.get("terminal"): terminal = self.runner.system_config.get( "terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): raise GameConfigError( _("The selected terminal application could not be launched:\n%s" ) % terminal) return terminal def get_killswitch(self): """Return the path to a file that is monitored during game execution. If the file stops existing, the game is stopped. """ killswitch = self.runner.system_config.get("killswitch") # Prevent setting a killswitch to a file that doesn't exists if killswitch and system.path_exists(self.killswitch): return killswitch def get_gameplay_info(self): """Return the information provided by a runner's play method. Checks for possible errors. """ gameplay_info = self.runner.play() if "error" in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED self.emit("game-stop") return return gameplay_info @watch_lutris_errors def configure_game(self, prelaunched, error=None): # noqa: C901 """Get the game ready to start, applying all the options This methods sets the game_runtime_config attribute. """ if error: logger.error(error) dialogs.ErrorDialog(str(error)) if not prelaunched: logger.error("Game prelaunch unsuccessful") dialogs.ErrorDialog(_("An error prevented the game from running")) self.state = self.STATE_STOPPED self.emit("game-stop") return gameplay_info = self.get_gameplay_info() if not gameplay_info: return command, env = self.get_launch_parameters(gameplay_info) self.game_runtime_config = { "args": command, "env": env, "terminal": self.get_terminal(), "include_processes": shlex.split(self.runner.system_config.get("include_processes", "")), "exclude_processes": shlex.split(self.runner.system_config.get("exclude_processes", "")), } # Audio control if self.runner.system_config.get("reset_pulse"): audio.reset_pulse() # Input control if self.runner.system_config.get("use_us_layout"): self.set_keyboard_layout("us") # Display control self.original_outputs = DISPLAY_MANAGER.get_config() if self.runner.system_config.get("disable_compositor"): self.set_desktop_compositing(False) if self.runner.system_config.get("disable_screen_saver"): self.screen_saver_inhibitor_cookie = SCREEN_SAVER_INHIBITOR.inhibit( self.name) if self.runner.system_config.get("display") != "off": self.resolution_changed = self.restrict_to_display( self.runner.system_config.get("display")) resolution = self.runner.system_config.get("resolution") if resolution != "off": DISPLAY_MANAGER.set_resolution(resolution) time.sleep(3) self.resolution_changed = True xephyr = self.runner.system_config.get("xephyr") or "off" if xephyr != "off": env["DISPLAY"] = self.start_xephyr() # Execution control self.killswitch = self.get_killswitch() if self.runner.system_config.get("prelaunch_command"): self.start_prelaunch_command() if self.runner.system_config.get("prelaunch_wait"): # Monitor the prelaunch command and wait until it has finished self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.prelaunch_beat) else: self.start_game() def start_game(self): """Run a background command to lauch the game""" self.game_thread = MonitoredCommand( self.game_runtime_config["args"], title=self.name, runner=self.runner, env=self.game_runtime_config["env"], term=self.game_runtime_config["terminal"], log_buffer=self._log_buffer, include_processes=self.game_runtime_config["include_processes"], exclude_processes=self.game_runtime_config["exclude_processes"], ) if hasattr(self.runner, "stop"): self.game_thread.stop_func = self.runner.stop self.game_thread.start() self.timer.start() self.emit("game-started") self.state = self.STATE_RUNNING self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def stop_game(self): """Cleanup after a game as stopped""" self.state = self.STATE_STOPPED self.emit("game-stop") if not self.timer.finished: self.timer.end() self.playtime += self.timer.duration / 3600 def prelaunch_beat(self): """Watch the prelaunch command""" if self.prelaunch_executor and self.prelaunch_executor.is_running: return True self.start_game() return False def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog( _("<b>Error lauching the game:</b>\n") + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = self.killswitch and not system.path_exists( self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False if self.discord_presence.available: self.discord_presence.update_discord_rich_presence() return True def stop(self): """Stops the game""" if self.state == self.STATE_STOPPED: logger.debug("Game already stopped") return logger.info("Stopping %s", self) if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None) self.stop_game() def on_game_quit(self): """Restore some settings and cleanup after game quit.""" if self.prelaunch_executor and self.prelaunch_executor.is_running: logger.info("Stopping prelaunch script") self.prelaunch_executor.stop() self.heartbeat = None if self.state != self.STATE_STOPPED: logger.warning("Game still running (state: %s)", self.state) self.stop() # Check for post game script postexit_command = self.runner.system_config.get("postexit_command") if postexit_command: command_array = shlex.split(postexit_command) if system.path_exists(command_array[0]): logger.info("Running post-exit command: %s", postexit_command) postexit_thread = MonitoredCommand( command_array, include_processes=[os.path.basename(postexit_command)], env=self.game_runtime_config["env"], cwd=self.directory, ) postexit_thread.start() if self.discord_presence.available: self.discord_presence.clear_discord_rich_presence() quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.lastplayed = int(time.time()) self.save(metadata_only=True) os.chdir(os.path.expanduser("~")) if self.resolution_changed or self.runner.system_config.get( "reset_desktop"): DISPLAY_MANAGER.set_resolution(self.original_outputs) if self.compositor_disabled: self.set_desktop_compositing(True) if self.screen_saver_inhibitor_cookie is not None: SCREEN_SAVER_INHIBITOR.uninhibit( self.screen_saver_inhibitor_cookie) self.screen_saver_inhibitor_cookie = None if self.runner.system_config.get("use_us_layout"): subprocess.Popen(["setxkbmap"], env=os.environ).communicate() if self.runner.system_config.get("restore_gamma"): restore_gamma() self.process_return_codes() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog( _("<b>Error: Missing shared library.</b>\n\n%s") % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog( _("<b>Error: A different Wine version is already using the same Wine prefix.</b>" )) def notify_steam_game_changed(self, appmanifest): """Receive updates from Steam games and set the thread's ready state accordingly""" if not self.game_thread: return if "Fully Installed" in appmanifest.states and not self.game_thread.ready_state: logger.info("Steam game %s is fully installed", appmanifest.steamid) self.game_thread.ready_state = True elif "Update Required" in appmanifest.states and self.game_thread.ready_state: logger.info( "Steam game %s updating, setting game thread as not ready", appmanifest.steamid, ) self.game_thread.ready_state = False def write_script(self, script_path): """Output the launch argument in a bash script""" gameplay_info = self.get_gameplay_info() if not gameplay_info: return command, env = self.get_launch_parameters(gameplay_info) # Override TERM otherwise the script might not run env["TERM"] = "xterm" script_content = "#!/bin/bash\n\n\n" script_content += "# Environment variables\n\n" for env_var in env: script_content += "export %s=\"%s\"\n" % (env_var, env[env_var]) script_content += "\n\n# Command\n\n" script_content += shlex.join(command) with open(script_path, "w") as script_file: script_file.write(script_content) os.chmod(script_path, os.stat(script_path).st_mode | stat.S_IEXEC)
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.lastplayed = game_data.get('lastplayed') or 0 self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None self.log_buffer = Gtk.TextBuffer() self.log_buffer.create_tag("warning", foreground="red") def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() xdg.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def set_platform_from_runner(self): if not self.runner: return self.platform = self.runner.get_platform() def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ if not metadata_only: self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = sorted( display.get_outputs(), key=lambda e: e[0] == system_config.get('display') ) gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return sdl_gamecontrollerconfig = system_config.get('sdl_gamecontrollerconfig') if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if os.path.exists(path): with open(path, "r") as f: sdl_gamecontrollerconfig = f.read() env['SDL_GAMECONTROLLERCONFIG'] = sdl_gamecontrollerconfig sdl_video_fullscreen = system_config.get('sdl_video_fullscreen') or '' env['SDL_VIDEO_FULLSCREEN_DISPLAY'] = sdl_video_fullscreen restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(xephyr_command) xephyr_thread.start() time.sleep(3) env['DISPLAY'] = ':2' if system_config.get('use_us_layout'): setxkbmap_command = ['setxkbmap', '-model', 'pc101', 'us', '-print'] xkbcomp_command = ['xkbcomp', '-', os.environ.get('DISPLAY', ':0')] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command: launch_arguments = shlex.split(os.path.expandvars(prefix_command)) + launch_arguments single_cpu = system_config.get('single_cpu') or False if single_cpu: logger.info('The game will run on a single CPU core') launch_arguments.insert(0, '0') launch_arguments.insert(0, '-c') launch_arguments.insert(0, 'taskset') terminal = system_config.get('terminal') if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) self.state = self.STATE_STOPPED return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if (ld_preload): env["LD_PRELOAD"] = ld_preload game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path = env.get("LD_LIBRARY_PATH") if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars include_processes = shlex.split(system_config.get('include_processes', '')) exclude_processes = shlex.split(system_config.get('exclude_processes', '')) monitoring_disabled = system_config.get('disable_monitoring') process_watch = not monitoring_disabled self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), watch=process_watch, term=terminal, log_buffer=self.log_buffer, include_processes=include_processes, exclude_processes=exclude_processes) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING # xboxdrv setup xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if monitoring_disabled: logger.info("Process monitoring disabled") else: self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command, include_processes=['xboxdrv']) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = ( self.killswitch and not os.path.exists(self.killswitch) ) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): if self.runner.system_config.get('xboxdrv'): logger.debug("Stopping xboxdrv") self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=self.runner.killall_on_exit()) self.state = self.STATE_STOPPED def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None if self.state != self.STATE_STOPPED: logger.debug("Game thread still running, stopping it (state: %s)", self.state) self.stop() quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.lastplayed = int(time.time()) self.save(metadata_only=True) os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>") def notify_steam_game_changed(self, appmanifest): logger.debug("Steam game %s state has changed, new states: %s", appmanifest.steamid, ', '.join(appmanifest.states)) if 'Fully Installed' in appmanifest.states: self.game_thread.ready_state = True elif 'Update Required' in appmanifest.states: self.game_thread.ready_state = False
class EditGameConfigDialog(Gtk.Dialog): """Game config edit dialog""" def __init__(self, parent, game): super(EditGameConfigDialog, self).__init__() self.parent_window = parent self.game = game self.lutris_config = LutrisConfig(game=game) game_name = self.lutris_config.config["realname"] self.set_title("Edit game configuration for %s" % game_name) self.set_size_request(500, 500) #Notebook config_notebook = Gtk.Notebook() self.vbox.pack_start(config_notebook, True, True, 0) #Game configuration tab self.game_config_vbox = GameConfigVBox(self.lutris_config, "game") game_config_scrolled_window = Gtk.ScrolledWindow() game_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) game_config_scrolled_window.add_with_viewport(self.game_config_vbox) config_notebook.append_page(game_config_scrolled_window, Gtk.Label(label="Game Configuration")) #Runner configuration tab self.runner_config_box = RunnerConfigVBox(self.lutris_config, "game") runner_config_scrolled_window = Gtk.ScrolledWindow() runner_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) runner_config_scrolled_window.add_with_viewport(self.runner_config_box) config_notebook.append_page(runner_config_scrolled_window, Gtk.Label(label="Runner Configuration")) #System configuration tab self.system_config_box = SystemConfigVBox(self.lutris_config, "game") system_config_scrolled_window = Gtk.ScrolledWindow() system_config_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) system_config_scrolled_window.add_with_viewport(self.system_config_box) config_notebook.append_page(system_config_scrolled_window, Gtk.Label(label="System Configuration")) #Action Area cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL) add_button = Gtk.Button(None, Gtk.STOCK_EDIT) self.action_area.pack_start(cancel_button, True, True, 0) self.action_area.pack_start(add_button, True, True, 0) cancel_button.connect("clicked", self.close) add_button.connect("clicked", self.edit_game) self.show_all() self.run() def edit_game(self, _widget=None): """Save the changes""" logger.debug(self.lutris_config.config) self.lutris_config.save(config_type="game") self.destroy() def close(self, _widget=None): """Dialog destroy callback""" self.destroy()
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.platform = game_data.get('platform') or '' self.year = game_data.get('year') or '' self.lastplayed = game_data.get('lastplayed') or 0 self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.compositor_disabled = False self.stop_compositor = self.start_compositor = "" self.original_outputs = None self.log_buffer = Gtk.TextBuffer() self.log_buffer.create_tag("warning", foreground="red") def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def show_error_message(self, message): """Display an error message based on the runner's output.""" if "CUSTOM" == message['error']: message_text = message['text'].replace('&', '&') dialogs.ErrorDialog(message_text) elif "RUNNER_NOT_INSTALLED" == message['error']: dialogs.ErrorDialog('Error the runner is not installed') elif "NO_BIOS" == message['error']: dialogs.ErrorDialog("A bios file is required to run this game") elif "FILE_NOT_FOUND" == message['error']: filename = message['file'] if filename: message_text = "The file {} could not be found".format( filename.replace('&', '&') ) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif "NOT_EXECUTABLE" == message['error']: message_text = message['file'].replace('&', '&') dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def desktop_effects(self, enable): if enable: system.execute(self.start_compositor, shell=True) else: if os.environ.get('DESKTOP_SESSION') == "plasma": self.stop_compositor = "qdbus org.kde.KWin /Compositor org.kde.kwin.Compositing.suspend" self.start_compositor = "qdbus org.kde.KWin /Compositor org.kde.kwin.Compositing.resume" elif os.environ.get('DESKTOP_SESSION') == "mate" and system.execute("gsettings get org.mate.Marco.general compositing-manager", shell=True) == 'true': self.stop_compositor = "gsettings set org.mate.Marco.general compositing-manager false" self.start_compositor = "gsettings set org.mate.Marco.general compositing-manager true" elif os.environ.get('DESKTOP_SESSION') == "xfce" and system.execute("xfconf-query --channel=xfwm4 --property=/general/use_compositing", shell=True) == 'true': self.stop_compositor = "xfconf-query --channel=xfwm4 --property=/general/use_compositing --set=false" self.start_compositor = "xfconf-query --channel=xfwm4 --property=/general/use_compositing --set=true" if not (self.compositor_disabled or self.stop_compositor == ""): system.execute(self.stop_compositor, shell=True) self.compositor_disabled = True; def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() xdg.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def set_platform_from_runner(self): if not self.runner: return self.platform = self.runner.get_platform() def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ if not metadata_only: self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = sorted( display.get_outputs(), key=lambda e: e[0] == system_config.get('display') ) gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED return env = {} sdl_gamecontrollerconfig = system_config.get('sdl_gamecontrollerconfig') if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if os.path.exists(path): with open(path, "r") as f: sdl_gamecontrollerconfig = f.read() env['SDL_GAMECONTROLLERCONFIG'] = sdl_gamecontrollerconfig sdl_video_fullscreen = system_config.get('sdl_video_fullscreen') or '' env['SDL_VIDEO_FULLSCREEN_DISPLAY'] = sdl_video_fullscreen restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] optimus = system_config.get('optimus') if optimus == 'primusrun' and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') elif optimus == 'optirun' and system.find_executable('optirun'): launch_arguments.insert(0, 'virtualgl') launch_arguments.insert(0, '-b') launch_arguments.insert(0, 'optirun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(xephyr_command) xephyr_thread.start() time.sleep(3) env['DISPLAY'] = ':2' if system_config.get('use_us_layout'): setxkbmap_command = ['setxkbmap', '-model', 'pc101', 'us', '-print'] xkbcomp_command = ['xkbcomp', '-', os.environ.get('DISPLAY', ':0')] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command: launch_arguments = shlex.split(os.path.expandvars(prefix_command)) + launch_arguments single_cpu = system_config.get('single_cpu') or False if single_cpu: logger.info('The game will run on a single CPU core') launch_arguments.insert(0, '0') launch_arguments.insert(0, '-c') launch_arguments.insert(0, 'taskset') terminal = system_config.get('terminal') if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) self.state = self.STATE_STOPPED return # Env vars game_env = gameplay_info.get('env') or self.runner.get_env() env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path = env.get("LD_LIBRARY_PATH") if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join([game_ld_libary_path, ld_library_path]) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars include_processes = shlex.split(system_config.get('include_processes', '')) exclude_processes = shlex.split(system_config.get('exclude_processes', '')) monitoring_disabled = system_config.get('disable_monitoring') if monitoring_disabled: show_obnoxious_process_monitor_message() process_watch = not monitoring_disabled if self.runner.system_config.get('disable_compositor'): self.desktop_effects(False) self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), watch=process_watch, term=terminal, log_buffer=self.log_buffer, include_processes=include_processes, exclude_processes=exclude_processes) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING # xboxdrv setup xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if monitoring_disabled: logger.info("Process monitoring disabled") else: self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command, include_processes=['xboxdrv']) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = ( self.killswitch and not os.path.exists(self.killswitch) ) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): if self.runner.system_config.get('xboxdrv'): logger.debug("Stopping xboxdrv") self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=self.runner.killall_on_exit()) self.state = self.STATE_STOPPED def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None if self.state != self.STATE_STOPPED: logger.debug("Game thread still running, stopping it (state: %s)", self.state) self.stop() quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.lastplayed = int(time.time()) self.save(metadata_only=True) os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.compositor_disabled: self.desktop_effects(True) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>") def notify_steam_game_changed(self, appmanifest): """Receive updates from Steam games and set the thread's ready state accordingly""" if 'Fully Installed' in appmanifest.states and not self.game_thread.ready_state: logger.info("Steam game %s is fully installed", appmanifest.steamid) self.game_thread.ready_state = True elif 'Update Required' in appmanifest.states and self.game_thread.ready_state: logger.info("Steam game %s updating, setting game thread as not ready", appmanifest.steamid) self.game_thread.ready_state = False
class Game(object): """This class takes cares about loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, slug): self.slug = slug self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' game_data = pga.get_game_by_slug(slug) self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_slug=self.slug) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk: self.runner.remove_game_data(game_path=self.directory) if from_library: pga.delete_game(self.slug) self.config.remove() else: pga.set_uninstalled(self.slug) def save(self): self.config.save() pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, directory=self.directory, installed=self.is_installed ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if hasattr(self.runner, 'prelaunch'): return self.runner.prelaunch() return True def use_runtime(self, system_config): disable_runtime = system_config.get('disable_runtime') env_runtime = os.getenv('LUTRIS_RUNTIME') if env_runtime and env_runtime.lower() in ('0', 'off'): disable_runtime = True return not disable_runtime def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) terminal = system_config.get('terminal') if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) return False # Env vars env = {} game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.use_runtime(system_config): env['STEAM_RUNTIME'] = os.path.join(settings.RUNTIME_DIR, 'steam') ld_library_path += runtime.get_runtime_paths() game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) self.state = self.STATE_RUNNING if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") def beat(self): """Watch game's process.""" self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: self.on_game_quit() return False return True def stop(self): self.game_thread.stop(killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) self.state = self.STATE_STOPPED if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop()
def create_config(self): """Create the game configuration for a Steam game""" game_config = LutrisConfig(runner_slug=self.runner, game_config_id=self.config_id) game_config.raw_game_config.update({"appid": self.appid}) game_config.save()
class GameDialogCommon(object): no_runner_label = "Select a runner from the list" @staticmethod def get_runner_liststore(): """Build a ListStore with available runners.""" runner_liststore = Gtk.ListStore(str, str) runner_liststore.append(("Select a runner from the list", "")) for runner_name in runners.__all__: runner_class = runners.import_runner(runner_name) runner = runner_class() if runner.is_installed(): description = runner.description runner_liststore.append( ("%s (%s)" % (runner_name, description), runner_name) ) return runner_liststore def build_entry_box(self, entry, label_text=None): box = Gtk.HBox() if label_text: label = Gtk.Label(label=label_text) box.pack_start(label, False, False, 20) box.pack_start(entry, True, True, 20) return box def get_runner_dropdown(self): runner_liststore = self.get_runner_liststore() self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore) runner_index = 0 if self.game: for runner in runner_liststore: if self.runner_name == str(runner[1]): break runner_index += 1 self.runner_dropdown.set_active(runner_index) self.runner_dropdown.connect("changed", self.on_runner_changed) cell = Gtk.CellRendererText() cell.props.ellipsize = Pango.EllipsizeMode.END self.runner_dropdown.pack_start(cell, True) self.runner_dropdown.add_attribute(cell, 'text', 0) return self.runner_dropdown @staticmethod def build_scrolled_window(widget): scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.add_with_viewport(widget) return scrolled_window def build_notebook(self): self.notebook = Gtk.Notebook() self.vbox.pack_start(self.notebook, True, True, 10) def add_notebook_tab(self, widget, label): self.notebook.append_page(widget, Gtk.Label(label=label)) def build_info_tab(self): info_box = VBox() self.name_entry = Gtk.Entry() if self.game: self.name_entry.set_text(self.game.name) name_box = self.build_entry_box(self.name_entry, "Name") info_box.pack_start(name_box, False, False, 5) if self.game: self.slug_entry = Gtk.Entry() self.slug_entry.set_text(self.game.slug) self.slug_entry.set_sensitive(False) slug_box = self.build_entry_box(self.slug_entry, "Identifier") info_box.pack_start(slug_box, False, False, 5) runner_box = Gtk.HBox() label = Gtk.Label("Runner") label.set_alignment(0.5, 0.5) runner_dropdown = self.get_runner_dropdown() runner_box.pack_start(label, False, False, 20) runner_box.pack_start(runner_dropdown, False, False, 20) info_box.pack_start(runner_box, False, False, 5) info_sw = self.build_scrolled_window(info_box) self.add_notebook_tab(info_sw, "Game info") def build_game_tab(self): if self.game and self.runner_name: self.game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, self.game) game_sw = self.build_scrolled_window(self.game_box) elif self.runner_name: game = Game(None) game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, game) game_sw = self.build_scrolled_window(self.game_box) else: game_sw = Gtk.Label(label=self.no_runner_label) self.add_notebook_tab(game_sw, "Game options") def build_runner_tab(self, config_level): if self.runner_name: self.runner_box = RunnerBox(self.lutris_config) runner_sw = self.build_scrolled_window(self.runner_box) else: runner_sw = Gtk.Label(label=self.no_runner_label) self.add_notebook_tab(runner_sw, "Runner options") def build_system_tab(self, config_level): self.system_box = SystemBox(self.lutris_config) self.system_sw = self.build_scrolled_window(self.system_box) self.add_notebook_tab(self.system_sw, "System options") def build_tabs(self, config_level): if config_level == 'game': self.build_info_tab() self.build_game_tab() self.build_runner_tab(config_level) self.build_system_tab(config_level) def rebuild_tabs(self): for i in range(self.notebook.get_n_pages(), 1, -1): self.notebook.remove_page(i - 1) self.build_game_tab() self.build_runner_tab('game') self.build_system_tab('game') self.show_all() def build_action_area(self, label, button_callback): self.action_area.set_layout(Gtk.ButtonBoxStyle.EDGE) # Advanced settings checkbox checkbox = Gtk.CheckButton(label="Show advanced options") value = settings.read_setting('show_advanced_options') if value == 'True': checkbox.set_active(value) checkbox.connect("toggled", self.on_show_advanced_options_toggled) self.action_area.pack_start(checkbox, False, False, 5) # Buttons hbox = Gtk.HBox() cancel_button = Gtk.Button(label="Cancel") cancel_button.connect("clicked", self.on_cancel_clicked) hbox.pack_start(cancel_button, True, True, 10) button = Gtk.Button(label=label) button.connect("clicked", button_callback) hbox.pack_start(button, True, True, 0) self.action_area.pack_start(hbox, True, True, 0) def set_advanced_options_visible(self, value): """Change visibility of advanced options across all config tabs.""" widgets = self.system_box.get_children() if self.runner_name: widgets += self.runner_box.get_children() if self.game: widgets += self.game_box.get_children() for widget in widgets: if widget.get_style_context().has_class('advanced'): widget.set_visible(value) if value: widget.set_no_show_all(not value) widget.show_all() def on_show_advanced_options_toggled(self, checkbox): value = True if checkbox.get_active() else False settings.write_setting('show_advanced_options', value) self.set_advanced_options_visible(value) def on_runner_changed(self, widget): """Action called when runner drop down is changed.""" runner_index = widget.get_active() current_page = self.notebook.get_current_page() if runner_index == 0: self.runner_name = None self.lutris_config = LutrisConfig() else: self.runner_name = widget.get_model()[runner_index][1] # XXX DANGER ZONE self.lutris_config = LutrisConfig(runner_slug=self.runner_name, level='game') self.rebuild_tabs() self.notebook.set_current_page(current_page) def on_cancel_clicked(self, widget=None): """Dialog destroy callback.""" self.destroy() def is_valid(self): name = self.name_entry.get_text() if not self.runner_name: ErrorDialog("Runner not provided") return False if not name: ErrorDialog("Please fill in the name") return False return True def on_save(self, _button): """Save game info and destroy widget. Return True if success.""" if not self.is_valid(): return False name = self.name_entry.get_text() # Do not modify slug if not self.slug: self.slug = slugify(name) if not self.game: self.game = Game(self.slug) self.game.config = self.lutris_config if not self.lutris_config.game_slug: self.lutris_config.game_slug = self.slug self.lutris_config.save() runner_class = runners.import_runner(self.runner_name) runner = runner_class(self.lutris_config) self.game.name = name self.game.slug = self.slug self.game.runner_name = self.runner_name self.game.directory = runner.game_path self.game.is_installed = True self.game.save() self.destroy() logger.debug("Saved %s", name) self.saved = True
def install(self): """Install NullDC""" dlg = DirectoryDialog('Where is NullDC located ?') config = LutrisConfig(runner=self.__class__.__name__) config.runner_config = {'system': {'game_path': dlg.folder}} config.save()
def create_config(self, db_game, config_id): """Create the game configuration for a Steam game""" game_config = LutrisConfig(runner_slug="steam", game_config_id=config_id) game_config.raw_game_config.update({"appid": db_game["appid"]}) game_config.save()
class Game(object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, id=None): self.id = id self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' self.exit_main_loop = False game_data = pga.get_game_by_field(id, 'id') self.slug = game_data.get('slug') or '' self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.game_config_id = game_data.get('configpath') or '' self.steamid = game_data.get('steamid') or '' self.has_custom_banner = bool(game_data.get('has_custom_banner')) or False self.has_custom_icon = bool(game_data.get('has_custom_icon')) or False self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) else: self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk and self.runner: logger.debug("Removing game %s from disk" % self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_game_by_field(self.slug, 'slug', all=True) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library" % self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) self.config.remove() shortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) return from_library def save(self): self.config.save() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id ) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: {}".format( runtime_updater.current_updates) ) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED return if not self.prelaunch(): self.state = self.STATE_STOPPED return if hasattr(self.runner, 'prelaunch'): jobs.AsyncCall(self.runner.prelaunch, self.do_play) else: self.do_play(True) def do_play(self, prelaunched, _error=None): if not prelaunched: self.state = self.STATE_STOPPED return system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() env = {} logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) self.state = self.STATE_STOPPED return sdl_video_fullscreen = system_config.get('sdl_video_fullscreen') or '' env['SDL_VIDEO_FULLSCREEN_DISPLAY'] = sdl_video_fullscreen restrict_to_display = system_config.get('display') if restrict_to_display != 'off': display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution != 'off': display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info['command'] primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') xephyr = system_config.get('xephyr') or 'off' if xephyr != 'off': if xephyr == '8bpp': xephyr_depth = '8' else: xephyr_depth = '16' xephyr_resolution = system_config.get('xephyr_resolution') or '640x480' xephyr_command = ['Xephyr', ':2', '-ac', '-screen', xephyr_resolution + 'x' + xephyr_depth, '-glamor', '-reset', '-terminate', '-fullscreen'] xephyr_thread = LutrisThread(xephyr_command) xephyr_thread.start() time.sleep(3) env['DISPLAY'] = ':2' if system_config.get('use_us_layout'): setxkbmap_command = ['setxkbmap', '-model', 'pc101', 'us', '-print'] xkbcomp_command = ['xkbcomp', '-', os.environ.get('DISPLAY', ':0')] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() pulse_latency = system_config.get('pulse_latency') if pulse_latency: env['PULSE_LATENCY_MSEC'] = '60' prefix_command = system_config.get("prefix_command") or '' if prefix_command.strip(): launch_arguments.insert(0, prefix_command) single_cpu = system_config.get('single_cpu') or False if single_cpu: logger.info('The game will run on a single CPU core') launch_arguments.insert(0, '0') launch_arguments.insert(0, '-c') launch_arguments.insert(0, 'taskset') terminal = system_config.get('terminal') if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) self.state = self.STATE_STOPPED return # Env vars game_env = gameplay_info.get('env') or {} env.update(game_env) system_env = system_config.get('env') or {} env.update(system_env) ld_preload = gameplay_info.get('ld_preload') or '' env["LD_PRELOAD"] = ld_preload # Runtime management ld_library_path = "" if self.runner.use_runtime(): runtime_env = runtime.get_env() if 'STEAM_RUNTIME' in runtime_env and 'STEAM_RUNTIME' not in env: env['STEAM_RUNTIME'] = runtime_env['STEAM_RUNTIME'] if 'LD_LIBRARY_PATH' in runtime_env: ld_library_path = runtime_env['LD_LIBRARY_PATH'] game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: if not ld_library_path: ld_library_path = '$LD_LIBRARY_PATH' ld_library_path = ":".join(game_ld_libary_path, ld_library_path) env["LD_LIBRARY_PATH"] = ld_library_path # /Env vars self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid'), term=terminal) if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() self.state = self.STATE_RUNNING if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis ) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = [ "pkexec", "xboxdrv", "--daemon", "--detach-kernel-driver", "--dbus", "session", "--silent" ] + config.split() logger.debug("[xboxdrv] %s", ' '.join(command)) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") if os.path.exists("/usr/share/lutris/bin/resetxpad"): os.system("pkexec /usr/share/lutris/bin/resetxpad") def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False self.game_log = self.game_thread.stdout killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False return True def stop(self): self.state = self.STATE_STOPPED if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None, killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.state = self.STATE_STOPPED os.chdir(os.path.expanduser('~')) if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('use_us_layout'): subprocess.Popen(['setxkbmap'], env=os.environ).communicate() if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv') \ and self.xboxdrv_thread.is_running: self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop() self.process_return_codes() if self.exit_main_loop: exit() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>")
class Game(GObject.Object): """This class takes cares of loading the configuration for a game and running it. """ STATE_STOPPED = "stopped" STATE_LAUNCHING = "launching" STATE_RUNNING = "running" __gsignals__ = { "game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )), "game-launch": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-start": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-started": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stopped": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-install": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()), } def __init__(self, game_id=None): super().__init__() self.id = game_id # pylint: disable=invalid-name self.runner = None self.config = None # Load attributes from database game_data = games_db.get_game_by_field(game_id, "id") self.slug = game_data.get("slug") or "" self.runner_name = game_data.get("runner") or "" self.directory = game_data.get("directory") or "" self.name = game_data.get("name") or "" self.game_config_id = game_data.get("configpath") or "" self.is_installed = bool(game_data.get("installed") and self.game_config_id) self.is_hidden = bool(game_data.get("hidden")) self.platform = game_data.get("platform") or "" self.year = game_data.get("year") or "" self.lastplayed = game_data.get("lastplayed") or 0 self.has_custom_banner = bool(game_data.get("has_custom_banner")) self.has_custom_icon = bool(game_data.get("has_custom_icon")) self.service = game_data.get("service") self.appid = game_data.get("service_id") self.discord_presence = DiscordPresence() self.playtime = game_data.get("playtime") or 0.0 if self.game_config_id: self.load_config() self.game_thread = None self.prelaunch_executor = None self.heartbeat = None self.killswitch = None self.state = self.STATE_STOPPED self.game_runtime_config = {} self.resolution_changed = False self.compositor_disabled = False self.original_outputs = None self._log_buffer = None self.timer = Timer() self.screen_saver_inhibitor_cookie = None def __repr__(self): return self.__str__() def __str__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value @property def is_favorite(self): """Return whether the game is in the user's favorites""" categories = categories_db.get_categories_in_game(self.id) for category in categories: if category == "favorite": return True return False def add_to_favorites(self): """Add the game to the 'favorite' category""" favorite = categories_db.get_category("favorite") if not favorite: favorite = categories_db.add_category("favorite") categories_db.add_game_to_category(self.id, favorite["id"]) self.emit("game-updated") def remove_from_favorites(self): """Remove game from favorites""" favorite = categories_db.get_category("favorite") categories_db.remove_category_from_game(self.id, favorite["id"]) self.emit("game-updated") def hide(self): """Do not show this game in the UI""" self.is_hidden = True self.save() def unhide(self): """Remove the game from hidden games""" self.is_hidden = False self.save() @property def log_buffer(self): """Access the log buffer object, creating it if necessary""" _log_buffer = LOG_BUFFERS.get(self.id) if _log_buffer: return _log_buffer _log_buffer = Gtk.TextBuffer() _log_buffer.create_tag("warning", foreground="red") if self.game_thread: self.game_thread.set_log_buffer(self._log_buffer) _log_buffer.set_text(self.game_thread.stdout) LOG_BUFFERS[self.id] = _log_buffer return _log_buffer @property def formatted_playtime(self): """Return a human readable formatted play time""" return strings.get_formatted_playtime(self.playtime) @staticmethod def show_error_message(message): """Display an error message based on the runner's output.""" if message["error"] == "CUSTOM": message_text = message["text"].replace("&", "&") dialogs.ErrorDialog(message_text) elif message["error"] == "RUNNER_NOT_INSTALLED": dialogs.ErrorDialog(_("Error the runner is not installed")) elif message["error"] == "NO_BIOS": dialogs.ErrorDialog(_("A bios file is required to run this game")) elif message["error"] == "FILE_NOT_FOUND": filename = message["file"] if filename: message_text = _("The file {} could not be found").format(filename.replace("&", "&")) else: message_text = _("No file provided") dialogs.ErrorDialog(message_text) elif message["error"] == "NOT_EXECUTABLE": message_text = message["file"].replace("&", "&") dialogs.ErrorDialog(_("The file %s is not executable") % message_text) elif message["error"] == "PATH_NOT_SET": message_text = _("The path '%s' is not set. please set it in the options.") % message["path"] dialogs.ErrorDialog(message_text) else: dialogs.ErrorDialog(_("Unhandled error: %s") % message["error"]) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.game_path def _get_runner(self): """Return the runner instance for this game's configuration""" try: runner_class = import_runner(self.runner_name) return runner_class(self.config) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) def load_config(self): """Load the game's configuration.""" if not self.is_installed: return self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) self.runner = self._get_runner() if self.discord_presence.available: self.discord_presence.client_id = ( self.config.system_config.get("discord_client_id") or DEFAULT_DISCORD_CLIENT_ID ) self.discord_presence.game_name = (self.config.system_config.get("discord_custom_game_name") or self.name) self.discord_presence.show_runner = self.config.system_config.get("discord_show_runner", True) self.discord_presence.runner_name = ( self.config.system_config.get("discord_custom_runner_name") or self.runner_name ) self.discord_presence.rpc_enabled = self.config.system_config.get("discord_rpc_enabled", True) def set_desktop_compositing(self, enable): """Enables or disables compositing""" if enable: if self.compositor_disabled: enable_compositing() self.compositor_disabled = False else: if not self.compositor_disabled: disable_compositing() self.compositor_disabled = True def remove(self, delete_files=False): """Uninstall a game Params: delete_files (bool): Delete the game files """ if delete_files and self.runner: self.runner.remove_game_data(game_path=self.directory) games_db.set_uninstalled(self.id) if self.config: self.config.remove() xdgshortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) self.is_installed = False self.emit("game-removed") def set_platform_from_runner(self): """Set the game's platform from the runner""" if not self.runner: logger.warning("Game has no runner, can't set platform") return self.platform = self.runner.get_platform() if not self.platform: logger.warning("Can't get platform for runner %s", self.runner.human_name) def save(self, save_config=False): """ Save the game's config and metadata, if `save_config` is set to False, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ if self.config: logger.debug("Saving %s with config ID %s", self, self.config.game_config_id) configpath = self.config.game_config_id if save_config: self.config.save() else: logger.warning("Saving %s without a configuration", self) configpath = "" self.set_platform_from_runner() self.id = games_db.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, directory=self.directory, installed=self.is_installed, year=self.year, lastplayed=self.lastplayed, configpath=configpath, id=self.id, playtime=self.playtime, hidden=self.is_hidden, service=self.service, service_id=self.appid, ) self.emit("game-updated") def is_launchable(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: %s", runtime_updater.current_updates) dialogs.ErrorDialog(_("Runtime currently updating"), _("Game might not work as expected")) if ("wine" in self.runner_name and not wine.get_system_wine_version() and not LINUX_SYSTEM.is_flatpak): # TODO find a reference to the root window or better yet a way not # to have Gtk dependent code in this class. root_window = None dialogs.WineNotInstalledWarning(parent=root_window) return True def restrict_to_display(self, display): outputs = DISPLAY_MANAGER.get_config() if display == "primary": display = None for output in outputs: if output.primary: display = output.name break if not display: logger.warning("No primary display set") else: found = False for output in outputs: if output.name == display: found = True break if not found: logger.warning("Selected display %s not found", display) display = None if display: turn_off_except(display) time.sleep(3) return True return False def start_xephyr(self, display=":2"): """Start a monitored Xephyr instance""" if not system.find_executable("Xephyr"): raise GameConfigError("Unable to find Xephyr, install it or disable the Xephyr option") xephyr_command = get_xephyr_command(display, self.runner.system_config) xephyr_thread = MonitoredCommand(xephyr_command) xephyr_thread.start() time.sleep(3) return display @staticmethod def set_keyboard_layout(layout): setxkbmap_command = ["setxkbmap", "-model", "pc101", layout, "-print"] xkbcomp_command = ["xkbcomp", "-", os.environ.get("DISPLAY", ":0")] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() def start_prelaunch_command(self): """Start the prelaunch command specified in the system options""" prelaunch_command = self.runner.system_config.get("prelaunch_command") command_array = shlex.split(prelaunch_command) if not system.path_exists(command_array[0]): logger.warning("Command %s not found", command_array[0]) return self.prelaunch_executor = MonitoredCommand( command_array, include_processes=[os.path.basename(command_array[0])], env=self.game_runtime_config["env"], cwd=self.directory, ) self.prelaunch_executor.start() logger.info("Running %s in the background", prelaunch_command) def get_terminal(self): """Return the terminal used to run the game into or None if the game is not run from a terminal. Remember that only games using text mode should use the terminal. """ if self.runner.system_config.get("terminal"): terminal = self.runner.system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): raise GameConfigError(_("The selected terminal application could not be launched:\n%s") % terminal) return terminal def get_killswitch(self): """Return the path to a file that is monitored during game execution. If the file stops existing, the game is stopped. """ killswitch = self.runner.system_config.get("killswitch") # Prevent setting a killswitch to a file that doesn't exists if killswitch and system.path_exists(self.killswitch): return killswitch def get_gameplay_info(self): """Return the information provided by a runner's play method. Checks for possible errors. """ gameplay_info = self.runner.play() if "error" in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED self.emit("game-stop") return return gameplay_info @watch_lutris_errors def configure_game(self, prelaunched, error=None): # noqa: C901 """Get the game ready to start, applying all the options This methods sets the game_runtime_config attribute. """ if error: logger.error(error) dialogs.ErrorDialog(str(error)) if not prelaunched: logger.error("Game prelaunch unsuccessful") dialogs.ErrorDialog(_("An error prevented the game from running")) self.state = self.STATE_STOPPED self.emit("game-stop") return gameplay_info = self.get_gameplay_info() if not gameplay_info: return command, env = get_launch_parameters(self.runner, gameplay_info) env["game_name"] = self.name # What is this used for?? self.game_runtime_config = { "args": command, "env": env, "terminal": self.get_terminal(), "include_processes": shlex.split(self.runner.system_config.get("include_processes", "")), "exclude_processes": shlex.split(self.runner.system_config.get("exclude_processes", "")), } # Audio control if self.runner.system_config.get("reset_pulse"): audio.reset_pulse() # Input control if self.runner.system_config.get("use_us_layout"): self.set_keyboard_layout("us") # Display control self.original_outputs = DISPLAY_MANAGER.get_config() if self.runner.system_config.get("disable_compositor"): self.set_desktop_compositing(False) if self.runner.system_config.get("disable_screen_saver"): self.screen_saver_inhibitor_cookie = SCREEN_SAVER_INHIBITOR.inhibit(self.name) if self.runner.system_config.get("display") != "off": self.resolution_changed = self.restrict_to_display(self.runner.system_config.get("display")) resolution = self.runner.system_config.get("resolution") if resolution != "off": DISPLAY_MANAGER.set_resolution(resolution) time.sleep(3) self.resolution_changed = True xephyr = self.runner.system_config.get("xephyr") or "off" if xephyr != "off": env["DISPLAY"] = self.start_xephyr() # Execution control self.killswitch = self.get_killswitch() if self.runner.system_config.get("prelaunch_command"): self.start_prelaunch_command() if self.runner.system_config.get("prelaunch_wait"): # Monitor the prelaunch command and wait until it has finished self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.prelaunch_beat) else: self.start_game() def launch(self): """Request launching a game. The game may not be installed yet.""" if not self.is_installed: self.emit("game-install") return wait_for_dxvk_init() self.load_config() # Reload the config before launching it. if not self.runner: dialogs.ErrorDialog(_("Invalid game configuration: Missing runner")) return if not self.is_launchable(): logger.error("Game is not launchable") return self.state = self.STATE_LAUNCHING self.emit("game-start") jobs.AsyncCall(self.runner.prelaunch, self.configure_game) def start_game(self): """Run a background command to lauch the game""" self.game_thread = MonitoredCommand( self.game_runtime_config["args"], title=self.name, runner=self.runner, env=self.game_runtime_config["env"], term=self.game_runtime_config["terminal"], log_buffer=self.log_buffer, include_processes=self.game_runtime_config["include_processes"], exclude_processes=self.game_runtime_config["exclude_processes"], ) if hasattr(self.runner, "stop"): self.game_thread.stop_func = self.runner.stop self.game_thread.start() self.timer.start() self.state = self.STATE_RUNNING self.emit("game-started") self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def stop_game(self): """Cleanup after a game as stopped""" self.state = self.STATE_STOPPED self.emit("game-stop") if not self.timer.finished: self.timer.end() self.playtime += self.timer.duration / 3600 def prelaunch_beat(self): """Watch the prelaunch command""" if self.prelaunch_executor and self.prelaunch_executor.is_running: return True self.start_game() return False def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog(_("<b>Error lauching the game:</b>\n") + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = self.killswitch and not system.path_exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False if self.discord_presence.available: self.discord_presence.update_discord_rich_presence() return True def stop(self): """Stops the game""" if self.state == self.STATE_STOPPED: logger.debug("Game already stopped") return logger.info("Stopping %s", self) if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None) self.stop_game() def on_game_quit(self): """Restore some settings and cleanup after game quit.""" if self.prelaunch_executor and self.prelaunch_executor.is_running: logger.info("Stopping prelaunch script") self.prelaunch_executor.stop() self.heartbeat = None if self.state != self.STATE_STOPPED: logger.warning("Game still running (state: %s)", self.state) self.stop() # Check for post game script postexit_command = self.runner.system_config.get("postexit_command") if postexit_command: command_array = shlex.split(postexit_command) if system.path_exists(command_array[0]): logger.info("Running post-exit command: %s", postexit_command) postexit_thread = MonitoredCommand( command_array, include_processes=[os.path.basename(postexit_command)], env=self.game_runtime_config["env"], cwd=self.directory, ) postexit_thread.start() if self.discord_presence.available: self.discord_presence.clear_discord_rich_presence() quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.lastplayed = int(time.time()) self.save(save_config=False) os.chdir(os.path.expanduser("~")) if self.resolution_changed or self.runner.system_config.get("reset_desktop"): DISPLAY_MANAGER.set_resolution(self.original_outputs) if self.compositor_disabled: self.set_desktop_compositing(True) if self.screen_saver_inhibitor_cookie is not None: SCREEN_SAVER_INHIBITOR.uninhibit(self.screen_saver_inhibitor_cookie) self.screen_saver_inhibitor_cookie = None if self.runner.system_config.get("use_us_layout"): subprocess.Popen(["setxkbmap"], env=os.environ).communicate() if self.runner.system_config.get("restore_gamma"): restore_gamma() self.process_return_codes() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog(_("<b>Error: Missing shared library.</b>\n\n%s") % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog(_("<b>Error: A different Wine version is already using the same Wine prefix.</b>")) def write_script(self, script_path): """Output the launch argument in a bash script""" gameplay_info = self.get_gameplay_info() if not gameplay_info: return export_bash_script(self.runner, gameplay_info, script_path) def move(self, new_location): logger.info("Moving %s to %s", self, new_location) new_config = "" old_location = self.directory if old_location: game_directory = os.path.basename(old_location) target_directory = os.path.join(new_location, game_directory) else: target_directory = new_location self.directory = target_directory self.save() if not old_location: logger.info("Previous location wasn't set. Cannot continue moving") return target_directory with open(self.config.game_config_path) as config_file: for line in config_file.readlines(): if target_directory in line: new_config += line else: new_config += line.replace(old_location, target_directory) with open(self.config.game_config_path, "w") as config_file: config_file.write(new_config) if not system.path_exists(old_location): logger.warning("Location %s doesn't exist, files already moved?", old_location) return if new_location.startswith(old_location): logger.warning("Can't move %s to one of its children %s", old_location, new_location) return target_directory try: shutil.move(old_location, new_location) except OSError as ex: logger.error( "Failed to move %s to %s, you may have to move files manually (Exception: %s)", old_location, new_location, ex ) return target_directory
class Game(object): """This class takes cares about loading the configuration for a game and running it. """ STATE_IDLE = 'idle' STATE_STOPPED = 'stopped' STATE_RUNNING = 'running' def __init__(self, slug): self.slug = slug self.runner = None self.game_thread = None self.heartbeat = None self.config = None self.killswitch = None self.state = self.STATE_IDLE self.game_log = '' game_data = pga.get_game_by_slug(slug) self.runner_name = game_data.get('runner') or '' self.directory = game_data.get('directory') or '' self.name = game_data.get('name') or '' self.is_installed = bool(game_data.get('installed')) or False self.year = game_data.get('year') or '' self.load_config() self.resolution_changed = False self.original_outputs = None def __repr__(self): return self.__unicode__() def __unicode__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def load_config(self): """Load the game's configuration.""" self.config = LutrisConfig(game=self.slug) if not self.is_installed: return if not self.runner_name: logger.error('Incomplete data for %s', self.slug) return try: runner_class = import_runner(self.runner_name) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) self.runner = runner_class(self.config) def remove(self, from_library=False, from_disk=False): if from_disk: self.runner.remove_game_data(game_path=self.directory) if from_library: pga.delete_game(self.slug) self.config.remove() else: pga.set_uninstalled(self.slug) def save(self): self.config.save() pga.add_or_update(name=self.name, runner=self.runner_name, slug=self.slug, directory=self.directory, installed=self.is_installed) def prelaunch(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if hasattr(self.runner, 'prelaunch'): return self.runner.prelaunch() return True def use_runtime(self, system_config): disable_runtime = system_config.get('disable_runtime') env_runtime = os.getenv('LUTRIS_RUNTIME') if env_runtime and env_runtime.lower() in ('0', 'off'): disable_runtime = True return not disable_runtime def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") return False if not self.prelaunch(): return False system_config = self.runner.system_config self.original_outputs = display.get_outputs() gameplay_info = self.runner.play() logger.debug("Launching %s: %s" % (self.name, gameplay_info)) if 'error' in gameplay_info: show_error_message(gameplay_info) return False launch_arguments = gameplay_info['command'] restrict_to_display = system_config.get('display') if restrict_to_display: display.turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get('resolution') if resolution: display.change_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get('reset_pulse'): audio.reset_pulse() primusrun = system_config.get('primusrun') if primusrun and system.find_executable('primusrun'): launch_arguments.insert(0, 'primusrun') prefix_command = system_config.get("prefix_command", '').strip() if prefix_command: launch_arguments.insert(0, prefix_command) env = os.environ.copy() game_env = gameplay_info.get('env') or {} env.update(game_env) ld_preload = gameplay_info.get('ld_preload') if ld_preload: env["LD_PRELOAD"] = ld_preload ld_library_path = [] if self.use_runtime(system_config): runtime64_path = os.path.join(settings.RUNTIME_DIR, "lib64") if os.path.exists(runtime64_path): ld_library_path.append(runtime64_path) runtime32_path = os.path.join(settings.RUNTIME_DIR, "lib32") if os.path.exists(runtime32_path): ld_library_path.append(runtime32_path) game_ld_libary_path = gameplay_info.get('ld_library_path') if game_ld_libary_path: ld_library_path.append(game_ld_libary_path) if ld_library_path: ld_full = ':'.join(ld_library_path) env["LD_LIBRARY_PATH"] = "{}:$LD_LIBRARY_PATH".format(ld_full) self.killswitch = system_config.get('killswitch') if self.killswitch and not os.path.exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None self.game_thread = LutrisThread(launch_arguments, runner=self.runner, env=env, rootpid=gameplay_info.get('rootpid')) self.state = self.STATE_RUNNING if hasattr(self.runner, 'stop'): self.game_thread.set_stop_command(self.runner.stop) self.game_thread.start() if 'joy2key' in gameplay_info: self.joy2key(gameplay_info['joy2key']) xboxdrv_config = system_config.get('xboxdrv') if xboxdrv_config: self.xboxdrv_start(xboxdrv_config) if self.runner.is_watchable: # Create heartbeat every self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def joy2key(self, config): """Run a joy2key thread.""" if not system.find_executable('joy2key'): logger.error("joy2key is not installed") return win = "grep %s" % config['window'] if 'notwindow' in config: win += ' | grep -v %s' % config['notwindow'] wid = "xwininfo -root -tree | %s | awk '{print $1}'" % win buttons = config['buttons'] axis = "Left Right Up Down" rcfile = os.path.expanduser("~/.joy2keyrc") rc_option = '-rcfile %s' % rcfile if os.path.exists(rcfile) else '' command = "sleep 5 " command += "&& joy2key $(%s) -X %s -buttons %s -axis %s" % ( wid, rc_option, buttons, axis) joy2key_thread = LutrisThread(command) self.game_thread.attach_thread(joy2key_thread) joy2key_thread.start() def xboxdrv_start(self, config): command = ("pkexec xboxdrv --daemon --detach-kernel-driver " "--dbus session --silent %s" % config) logger.debug("xboxdrv command: %s", command) self.xboxdrv_thread = LutrisThread(command) self.xboxdrv_thread.set_stop_command(self.xboxdrv_stop) self.xboxdrv_thread.start() def xboxdrv_stop(self): os.system("pkexec xboxdrvctl --shutdown") def beat(self): """Watch game's process.""" killswitch_engage = self.killswitch and \ not os.path.exists(self.killswitch) if not self.game_thread.is_running or killswitch_engage: self.on_game_quit() return False return True def stop(self): self.game_thread.stop(killall=True) def on_game_quit(self): """Restore some settings and cleanup after game quit.""" self.heartbeat = None quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("game has quit at %s" % quit_time) self.state = self.STATE_STOPPED self.game_log = self.game_thread.stdout if self.resolution_changed\ or self.runner.system_config.get('reset_desktop'): display.change_resolution(self.original_outputs) if self.runner.system_config.get('restore_gamma'): display.restore_gamma() if self.runner.system_config.get('xboxdrv'): self.xboxdrv_thread.stop() if self.game_thread: self.game_thread.stop()
class GameDialogCommon(object): no_runner_label = "Select a runner from the list" @staticmethod def get_runner_liststore(): """Build a ListStore with available runners.""" runner_liststore = Gtk.ListStore(str, str) runner_liststore.append(("Select a runner from the list", "")) for runner_name in lutris.runners.__all__: runner_class = lutris.runners.import_runner(runner_name) runner = runner_class() if runner.is_installed(): description = runner.description runner_liststore.append( ("%s (%s)" % (runner_name, description), runner_name) ) return runner_liststore def build_entry_box(self, entry, label_text=None): box = Gtk.HBox() if label_text: label = Gtk.Label(label=label_text) box.pack_start(label, False, False, 20) box.pack_start(entry, True, True, 20) return box def get_runner_dropdown(self): runner_liststore = self.get_runner_liststore() self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore) runner_index = 0 if self.game: for runner in runner_liststore: if self.runner_name == str(runner[1]): break runner_index += 1 self.runner_dropdown.set_active(runner_index) self.runner_dropdown.connect("changed", self.on_runner_changed) cell = Gtk.CellRendererText() cell.props.ellipsize = Pango.EllipsizeMode.END self.runner_dropdown.pack_start(cell, True) self.runner_dropdown.add_attribute(cell, 'text', 0) return self.runner_dropdown @staticmethod def build_scrolled_window(widget): scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.add_with_viewport(widget) scrolled_window.show_all() return scrolled_window def build_notebook(self): self.notebook = Gtk.Notebook() self.vbox.pack_start(self.notebook, True, True, 10) def add_notebook_tab(self, widget, label): self.notebook.append_page(widget, Gtk.Label(label=label)) def build_info_tab(self): info_box = VBox() self.name_entry = Gtk.Entry() if self.game: self.name_entry.set_text(self.game.name) name_box = self.build_entry_box(self.name_entry, "Name") info_box.pack_start(name_box, False, False, 5) if self.game: self.slug_entry = Gtk.Entry() self.slug_entry.set_text(self.game.slug) self.slug_entry.set_sensitive(False) slug_box = self.build_entry_box(self.slug_entry, "Identifier") info_box.pack_start(slug_box, False, False, 5) runner_box = Gtk.HBox() label = Gtk.Label("Runner") label.set_alignment(0.5, 0.5) runner_dropdown = self.get_runner_dropdown() runner_box.pack_start(label, False, False, 20) runner_box.pack_start(runner_dropdown, False, False, 20) info_box.pack_start(runner_box, False, False, 5) info_sw = self.build_scrolled_window(info_box) self.add_notebook_tab(info_sw, "Game info") def build_game_tab(self): if self.game and self.runner_name: self.game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, "game", self.game) game_sw = self.build_scrolled_window(self.game_box) elif self.runner_name: game = Game(None) game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, "game", game) game_sw = self.build_scrolled_window(self.game_box) else: game_sw = Gtk.Label(label=self.no_runner_label) game_sw.show() self.add_notebook_tab(game_sw, "Game configuration") def build_runner_tab(self): if self.runner_name: self.runner_box = RunnerBox(self.lutris_config, "game", self.runner_name) runner_sw = self.build_scrolled_window(self.runner_box) else: runner_sw = Gtk.Label(label=self.no_runner_label) runner_sw.show() self.add_notebook_tab(runner_sw, "Runner configuration") def build_system_tab(self): self.system_box = SystemBox(self.lutris_config, "game") self.system_sw = self.build_scrolled_window(self.system_box) self.add_notebook_tab(self.system_sw, "System configuration") def build_tabs(self): self.build_info_tab() self.build_game_tab() self.build_runner_tab() self.build_system_tab() def rebuild_tabs(self): for i in range(self.notebook.get_n_pages(), 1, -1): self.notebook.remove_page(i - 1) self.build_game_tab() self.build_runner_tab() self.build_system_tab() def build_action_area(self, label, button_callback): cancel_button = Gtk.Button(label="Cancel") cancel_button.connect("clicked", self.on_cancel_clicked) self.action_area.pack_start(cancel_button, True, True, 0) button = Gtk.Button(label=label) button.connect("clicked", button_callback) self.action_area.pack_start(button, True, True, 0) def on_runner_changed(self, widget): """Action called when runner drop down is changed.""" runner_index = widget.get_active() current_page = self.notebook.get_current_page() if runner_index == 0: self.runner_name = None self.lutris_config = LutrisConfig() else: self.runner_name = widget.get_model()[runner_index][1] # XXX DANGER ZONE self.lutris_config = LutrisConfig(runner=self.runner_name) self.rebuild_tabs() self.notebook.set_current_page(current_page) def on_cancel_clicked(self, widget=None): """Dialog destroy callback.""" self.destroy() def is_valid(self): name = self.name_entry.get_text() if not self.runner_name: ErrorDialog("Runner not provided") return False if not name: ErrorDialog("Please fill in the name") return False return True def on_save(self, _button): """Save game info and destroy widget. Return True if success.""" if not self.is_valid(): return False name = self.name_entry.get_text() if not self.lutris_config.game: self.lutris_config.game = slugify(name) self.lutris_config.save() self.slug = self.lutris_config.game runner_class = lutris.runners.import_runner(self.runner_name) runner = runner_class(self.lutris_config) pga.add_or_update(name, self.runner_name, slug=self.slug, directory=runner.game_path, installed=1) self.destroy() logger.debug("Saved %s", name) return True
class Game(GObject.Object): """This class takes cares of loading the configuration for a game and running it. """ STATE_IDLE = "idle" STATE_STOPPED = "stopped" STATE_RUNNING = "running" __gsignals__ = { "game-error": (GObject.SIGNAL_RUN_FIRST, None, (str, )), "game-start": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-started": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stop": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-stopped": (GObject.SIGNAL_RUN_FIRST, None, (int, )), "game-removed": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-updated": (GObject.SIGNAL_RUN_FIRST, None, ()), "game-installed": (GObject.SIGNAL_RUN_FIRST, None, ()), } def __init__(self, game_id=None): super().__init__() self.id = game_id # pylint: disable=invalid-name self.runner = None self.config = None # Load attributes from database game_data = pga.get_game_by_field(game_id, "id") self.slug = game_data.get("slug") or "" self.runner_name = game_data.get("runner") or "" self.directory = game_data.get("directory") or "" self.name = game_data.get("name") or "" self.game_config_id = game_data.get("configpath") or "" self.is_installed = bool( game_data.get("installed") and self.game_config_id) self.platform = game_data.get("platform") or "" self.year = game_data.get("year") or "" self.lastplayed = game_data.get("lastplayed") or 0 self.steamid = game_data.get("steamid") or "" self.has_custom_banner = bool(game_data.get("has_custom_banner")) self.has_custom_icon = bool(game_data.get("has_custom_icon")) self.discord_presence = DiscordPresence() try: self.playtime = float(game_data.get("playtime") or 0.0) except ValueError: logger.error("Invalid playtime value %s", game_data.get("playtime")) self.playtime = 0.0 if self.game_config_id: self.load_config() self.game_thread = None self.prelaunch_executor = None self.heartbeat = None self.killswitch = None self.state = self.STATE_IDLE self.game_runtime_config = {} self.resolution_changed = False self.compositor_disabled = False self.stop_compositor = self.start_compositor = "" self.original_outputs = None self._log_buffer = None self.timer = Timer() def __repr__(self): return self.__str__() def __str__(self): value = self.name if self.runner_name: value += " (%s)" % self.runner_name return value @property def log_buffer(self): """Access the log buffer object, creating it if necessary""" if self._log_buffer is None: self._log_buffer = Gtk.TextBuffer() self._log_buffer.create_tag("warning", foreground="red") if self.game_thread: self.game_thread.set_log_buffer(self._log_buffer) self._log_buffer.set_text(self.game_thread.stdout) return self._log_buffer @property def formatted_playtime(self): """Return a human readable formatted play time""" return strings.get_formatted_playtime(self.playtime) @property def is_search_result(self): """Return whether or not the game is a remote game from search results. This is bad, find another way to do this. """ return self.id < 0 @staticmethod def show_error_message(message): """Display an error message based on the runner's output.""" if message["error"] == "CUSTOM": message_text = message["text"].replace("&", "&") dialogs.ErrorDialog(message_text) elif message["error"] == "RUNNER_NOT_INSTALLED": dialogs.ErrorDialog("Error the runner is not installed") elif message["error"] == "NO_BIOS": dialogs.ErrorDialog("A bios file is required to run this game") elif message["error"] == "FILE_NOT_FOUND": filename = message["file"] if filename: message_text = "The file {} could not be found".format( filename.replace("&", "&")) else: message_text = "No file provided" dialogs.ErrorDialog(message_text) elif message["error"] == "NOT_EXECUTABLE": message_text = message["file"].replace("&", "&") dialogs.ErrorDialog("The file %s is not executable" % message_text) def get_browse_dir(self): """Return the path to open with the Browse Files action.""" return self.runner.browse_dir def _get_runner(self): """Return the runner instance for this game's configuration""" try: runner_class = import_runner(self.runner_name) return runner_class(self.config) except InvalidRunner: logger.error("Unable to import runner %s for %s", self.runner_name, self.slug) def load_config(self): """Load the game's configuration.""" if not self.is_installed: return self.config = LutrisConfig(runner_slug=self.runner_name, game_config_id=self.game_config_id) self.runner = self._get_runner() if self.discord_presence.available: self.discord_presence.client_id = ( self.config.system_config.get("discord_client_id") or DEFAULT_DISCORD_CLIENT_ID) self.discord_presence.game_name = ( self.config.system_config.get("discord_custom_game_name") or self.name) self.discord_presence.show_runner = self.config.system_config.get( "discord_show_runner", True) self.discord_presence.runner_name = ( self.config.system_config.get("discord_custom_runner_name") or self.runner_name) self.discord_presence.rpc_enabled = self.config.system_config.get( "discord_rpc_enabled", True) def set_desktop_compositing(self, enable): """Enables or disables compositing""" if enable: system.execute(self.start_compositor, shell=True) else: ( self.start_compositor, self.stop_compositor, ) = get_compositor_commands() if not (self.compositor_disabled or not self.stop_compositor): system.execute(self.stop_compositor, shell=True) self.compositor_disabled = True def remove(self, from_library=False, from_disk=False): """Uninstall a game Params: from_library (bool): Completely remove the game from library, do not set it as uninstalled from_disk (bool): Delete the game files Return: bool: Updated value for from_library """ if from_disk and self.runner: logger.debug("Removing game %s from disk", self.id) self.runner.remove_game_data(game_path=self.directory) # Do not keep multiple copies of the same game existing_games = pga.get_games_where(slug=self.slug) if len(existing_games) > 1: from_library = True if from_library: logger.debug("Removing game %s from library", self.id) pga.delete_game(self.id) else: pga.set_uninstalled(self.id) if self.config: self.config.remove() xdgshortcuts.remove_launcher(self.slug, self.id, desktop=True, menu=True) self.is_installed = False self.emit("game-removed") return from_library def set_platform_from_runner(self): """Set the game's platform from the runner""" if not self.runner: logger.warning("Game has no runner, can't set platform") return self.platform = self.runner.get_platform() if not self.platform: logger.warning("Can't get platform for runner %s", self.runner.human_name) def save(self, metadata_only=False): """ Save the game's config and metadata, if `metadata_only` is set to True, do not save the config. This is useful when exiting the game since the config might have changed and we don't want to override the changes. """ logger.debug("Saving %s", self) if not metadata_only: self.config.save() self.set_platform_from_runner() self.id = pga.add_or_update( name=self.name, runner=self.runner_name, slug=self.slug, platform=self.platform, year=self.year, lastplayed=self.lastplayed, directory=self.directory, installed=self.is_installed, configpath=self.config.game_config_id, steamid=self.steamid, id=self.id, playtime=self.playtime, ) self.emit("game-updated") def is_launchable(self): """Verify that the current game can be launched.""" if not self.runner.is_installed(): installed = self.runner.install_dialog() if not installed: return False if self.runner.use_runtime(): runtime_updater = runtime.RuntimeUpdater() if runtime_updater.is_updating(): logger.warning("Runtime updates: %s", runtime_updater.current_updates) dialogs.ErrorDialog("Runtime currently updating", "Game might not work as expected") if ("wine" in self.runner_name and not wine.get_system_wine_version() and not LINUX_SYSTEM.is_flatpak): # TODO find a reference to the root window or better yet a way not # to have Gtk dependent code in this class. root_window = None dialogs.WineNotInstalledWarning(parent=root_window) return True def play(self): """Launch the game.""" if not self.runner: dialogs.ErrorDialog("Invalid game configuration: Missing runner") self.state = self.STATE_STOPPED self.emit("game-stop") return if not self.is_launchable(): self.state = self.STATE_STOPPED self.emit("game-stop") return self.emit("game-start") jobs.AsyncCall(self.runner.prelaunch, self.configure_game) @watch_lutris_errors def configure_game(self, prelaunched, error=None): """Get the game ready to start, applying all the options This methods sets the game_runtime_config attribute. """ if error: logger.error(error) dialogs.ErrorDialog(str(error)) if not prelaunched: logger.error("Game prelaunch unsuccessful") dialogs.ErrorDialog("An error prevented the game from running") self.state = self.STATE_STOPPED self.emit("game-stop") return system_config = self.runner.system_config self.original_outputs = DISPLAY_MANAGER.get_config() gameplay_info = self.runner.play() if "error" in gameplay_info: self.show_error_message(gameplay_info) self.state = self.STATE_STOPPED self.emit("game-stop") return logger.debug("Launching %s: %s", self.name, gameplay_info) logger.debug("Game info: %s", json.dumps(gameplay_info, indent=2)) env = {} sdl_gamecontrollerconfig = system_config.get( "sdl_gamecontrollerconfig") if sdl_gamecontrollerconfig: path = os.path.expanduser(sdl_gamecontrollerconfig) if system.path_exists(path): with open(path, "r") as controllerdb_file: sdl_gamecontrollerconfig = controllerdb_file.read() env["SDL_GAMECONTROLLERCONFIG"] = sdl_gamecontrollerconfig sdl_video_fullscreen = system_config.get("sdl_video_fullscreen") or "" env["SDL_VIDEO_FULLSCREEN_DISPLAY"] = sdl_video_fullscreen restrict_to_display = system_config.get("display") if restrict_to_display != "off": if restrict_to_display == "primary": restrict_to_display = None for output in self.original_outputs: if output.primary: restrict_to_display = output.name break if not restrict_to_display: logger.warning("No primary display set") else: found = False for output in self.original_outputs: if output.name == restrict_to_display: found = True break if not found: logger.warning("Selected display %s not found", restrict_to_display) restrict_to_display = None if restrict_to_display: turn_off_except(restrict_to_display) time.sleep(3) self.resolution_changed = True resolution = system_config.get("resolution") if resolution != "off": DISPLAY_MANAGER.set_resolution(resolution) time.sleep(3) self.resolution_changed = True if system_config.get("reset_pulse"): audio.reset_pulse() self.killswitch = system_config.get("killswitch") if self.killswitch and not system.path_exists(self.killswitch): # Prevent setting a killswitch to a file that doesn't exists self.killswitch = None # Command launch_arguments = gameplay_info["command"] optimus = system_config.get("optimus") if optimus == "primusrun" and system.find_executable("primusrun"): launch_arguments.insert(0, "primusrun") elif optimus == "optirun" and system.find_executable("optirun"): launch_arguments.insert(0, "virtualgl") launch_arguments.insert(0, "-b") launch_arguments.insert(0, "optirun") elif optimus == "pvkrun" and system.find_executable("pvkrun"): launch_arguments.insert(0, "pvkrun") xephyr = system_config.get("xephyr") or "off" if xephyr != "off": if not system.find_executable("Xephyr"): raise GameConfigError( "Unable to find Xephyr, install it or disable the Xephyr option" ) xephyr_depth = "8" if xephyr == "8bpp" else "16" xephyr_resolution = system_config.get( "xephyr_resolution") or "640x480" xephyr_command = [ "Xephyr", ":2", "-ac", "-screen", xephyr_resolution + "x" + xephyr_depth, "-glamor", "-reset", "-terminate", ] if system_config.get("xephyr_fullscreen"): xephyr_command.append("-fullscreen") xephyr_thread = MonitoredCommand(xephyr_command) xephyr_thread.start() time.sleep(3) env["DISPLAY"] = ":2" if system_config.get("use_us_layout"): setxkbmap_command = [ "setxkbmap", "-model", "pc101", "us", "-print" ] xkbcomp_command = ["xkbcomp", "-", os.environ.get("DISPLAY", ":0")] xkbcomp = subprocess.Popen(xkbcomp_command, stdin=subprocess.PIPE) subprocess.Popen(setxkbmap_command, env=os.environ, stdout=xkbcomp.stdin).communicate() xkbcomp.communicate() if system_config.get("aco"): env["RADV_PERFTEST"] = "aco" pulse_latency = system_config.get("pulse_latency") if pulse_latency: env["PULSE_LATENCY_MSEC"] = "60" vk_icd = system_config.get("vk_icd") if vk_icd and vk_icd != "off" and system.path_exists(vk_icd): env["VK_ICD_FILENAMES"] = vk_icd fps_limit = system_config.get("fps_limit") or "" if fps_limit: strangle_cmd = system.find_executable("strangle") if strangle_cmd: launch_arguments = [strangle_cmd, fps_limit] + launch_arguments else: logger.warning( "libstrangle is not available on this system, FPS limiter disabled" ) prefix_command = system_config.get("prefix_command") or "" if prefix_command: launch_arguments = ( shlex.split(os.path.expandvars(prefix_command)) + launch_arguments) single_cpu = system_config.get("single_cpu") or False if single_cpu: logger.info("The game will run on a single CPU core") launch_arguments.insert(0, "0") launch_arguments.insert(0, "-c") launch_arguments.insert(0, "taskset") terminal = system_config.get("terminal") if terminal: terminal = system_config.get("terminal_app", system.get_default_terminal()) if terminal and not system.find_executable(terminal): dialogs.ErrorDialog("The selected terminal application " "could not be launched:\n" "%s" % terminal) self.state = self.STATE_STOPPED self.emit("game-stop") return # Env vars game_env = gameplay_info.get("env") or self.runner.get_env() env.update(game_env) env["game_name"] = self.name # Prime vars prime = system_config.get("prime") if prime: env["__NV_PRIME_RENDER_OFFLOAD"] = "1" env["__GLX_VENDOR_LIBRARY_NAME"] = "nvidia" env["__VK_LAYER_NV_optimus"] = "NVIDIA_only" # LD_PRELOAD ld_preload = gameplay_info.get("ld_preload") if ld_preload: env["LD_PRELOAD"] = ld_preload # Feral gamemode gamemode = system_config.get("gamemode") if gamemode: env["LD_PRELOAD"] = ":".join([ path for path in [ env.get("LD_PRELOAD"), "libgamemodeauto.so", ] if path ]) # LD_LIBRARY_PATH game_ld_libary_path = gameplay_info.get("ld_library_path") if game_ld_libary_path: ld_library_path = env.get("LD_LIBRARY_PATH") if not ld_library_path: ld_library_path = "$LD_LIBRARY_PATH" env["LD_LIBRARY_PATH"] = ":".join( [game_ld_libary_path, ld_library_path]) include_processes = shlex.split( system_config.get("include_processes", "")) exclude_processes = shlex.split( system_config.get("exclude_processes", "")) self.game_runtime_config = { "args": launch_arguments, "env": env, "terminal": terminal, "include_processes": include_processes, "exclude_processes": exclude_processes, } if system_config.get("disable_compositor"): self.set_desktop_compositing(False) prelaunch_command = system_config.get("prelaunch_command") if system.path_exists(prelaunch_command): self.prelaunch_executor = MonitoredCommand( [prelaunch_command], include_processes=[os.path.basename(prelaunch_command)], env=self.game_runtime_config["env"], cwd=self.directory, ) self.prelaunch_executor.start() logger.info("Running %s in the background", prelaunch_command) if system_config.get("prelaunch_wait"): self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.prelaunch_beat) else: self.start_game() def start_game(self): """Run a background command to lauch the game""" self.game_thread = MonitoredCommand( self.game_runtime_config["args"], title=self.name, runner=self.runner, env=self.game_runtime_config["env"], term=self.game_runtime_config["terminal"], log_buffer=self._log_buffer, include_processes=self.game_runtime_config["include_processes"], exclude_processes=self.game_runtime_config["exclude_processes"], ) if hasattr(self.runner, "stop"): self.game_thread.stop_func = self.runner.stop self.game_thread.start() self.timer.start() self.emit("game-started") self.state = self.STATE_RUNNING self.heartbeat = GLib.timeout_add(HEARTBEAT_DELAY, self.beat) def stop_game(self): """Cleanup after a game as stopped""" self.state = self.STATE_STOPPED self.emit("game-stop") if not self.timer.finished: self.timer.end() self.playtime += self.timer.duration / 3600 def prelaunch_beat(self): """Watch the prelaunch command""" if self.prelaunch_executor and self.prelaunch_executor.is_running: return True self.start_game() return False def beat(self): """Watch the game's process(es).""" if self.game_thread.error: dialogs.ErrorDialog("<b>Error lauching the game:</b>\n" + self.game_thread.error) self.on_game_quit() return False # The killswitch file should be set to a device (ie. /dev/input/js0) # When that device is unplugged, the game is forced to quit. killswitch_engage = self.killswitch and not system.path_exists( self.killswitch) if not self.game_thread.is_running or killswitch_engage: logger.debug("Game thread stopped") self.on_game_quit() return False if self.discord_presence.available: self.discord_presence.update_discord_rich_presence() return True def stop(self): """Stops the game""" if self.state == self.STATE_STOPPED: logger.debug("Game already stopped") return logger.info("Stopping %s", self) if self.game_thread: jobs.AsyncCall(self.game_thread.stop, None) self.stop_game() def on_game_quit(self): """Restore some settings and cleanup after game quit.""" if self.prelaunch_executor and self.prelaunch_executor.is_running: logger.info("Stopping prelaunch script") self.prelaunch_executor.stop() self.heartbeat = None if self.state != self.STATE_STOPPED: logger.warning("Game still running (state: %s)", self.state) self.stop() # Check for post game script postexit_command = self.runner.system_config.get("postexit_command") if system.path_exists(postexit_command): logger.info("Running post-exit command: %s", postexit_command) postexit_thread = MonitoredCommand( [postexit_command], include_processes=[os.path.basename(postexit_command)], env=self.game_runtime_config["env"], cwd=self.directory, ) postexit_thread.start() if self.discord_presence.available: self.discord_presence.clear_discord_rich_presence() quit_time = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()) logger.debug("%s stopped at %s", self.name, quit_time) self.lastplayed = int(time.time()) self.save(metadata_only=True) os.chdir(os.path.expanduser("~")) if self.resolution_changed or self.runner.system_config.get( "reset_desktop"): DISPLAY_MANAGER.set_resolution(self.original_outputs) if self.compositor_disabled: self.set_desktop_compositing(True) if self.runner.system_config.get("use_us_layout"): subprocess.Popen(["setxkbmap"], env=os.environ).communicate() if self.runner.system_config.get("restore_gamma"): restore_gamma() self.process_return_codes() def process_return_codes(self): """Do things depending on how the game quitted.""" if self.game_thread.return_code == 127: # Error missing shared lib error = "error while loading shared lib" error_line = strings.lookup_string_in_text(error, self.game_thread.stdout) if error_line: dialogs.ErrorDialog("<b>Error: Missing shared library.</b>" "\n\n%s" % error_line) if self.game_thread.return_code == 1: # Error Wine version conflict error = "maybe the wrong wineserver" if strings.lookup_string_in_text(error, self.game_thread.stdout): dialogs.ErrorDialog("<b>Error: A different Wine version is " "already using the same Wine prefix.</b>") def notify_steam_game_changed(self, appmanifest): """Receive updates from Steam games and set the thread's ready state accordingly""" if not self.game_thread: return if "Fully Installed" in appmanifest.states and not self.game_thread.ready_state: logger.info("Steam game %s is fully installed", appmanifest.steamid) self.game_thread.ready_state = True elif "Update Required" in appmanifest.states and self.game_thread.ready_state: logger.info( "Steam game %s updating, setting game thread as not ready", appmanifest.steamid, ) self.game_thread.ready_state = False
class AddGameDialog(Gtk.Dialog): """ Add game dialog class""" def __init__(self, parent): super(AddGameDialog, self).__init__() self.parent_window = parent #Real name realname_hbox = Gtk.HBox() realname_label = Gtk.Label(label="Name") realname_hbox.pack_start(realname_label, False, False, 5) self.realname_entry = Gtk.Entry() realname_hbox.add(self.realname_entry) self.vbox.pack_start(realname_hbox, False, False, 5) self.lutris_config = LutrisConfig() self.set_title("Add a new game") self.set_size_request(600, 500) #Runners: get a list of available runners runner_liststore = Gtk.ListStore(str, str) runner_liststore.append(("Select a runner from the list", "")) for runner_name in lutris.runners.__all__: runner_class = import_runner(runner_name) runner = runner_class() description = runner.description if runner.is_installed(): runner_liststore.append( ("%s (%s)" % (runner_name, description), runner_name) ) runner_combobox = Gtk.ComboBox.new_with_model(runner_liststore) runner_combobox.connect("changed", self.on_runner_changed) cell = Gtk.CellRendererText() runner_combobox.pack_start(cell, True) runner_combobox.add_attribute(cell, 'text', 0) self.vbox.pack_start(runner_combobox, False, True, 5) notebook = Gtk.Notebook() self.vbox.pack_start(notebook, True, True, 0) default_label = "Select a runner from the list" #Game configuration self.game_config_vbox = Gtk.Label(label=default_label) self.conf_scroll_window = Gtk.ScrolledWindow() self.conf_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.conf_scroll_window.add_with_viewport(self.game_config_vbox) notebook.append_page(self.conf_scroll_window, Gtk.Label(label="Game configuration")) #Runner configuration self.runner_config_vbox = Gtk.Label(label=default_label) self.runner_scroll_window = Gtk.ScrolledWindow() self.runner_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.runner_scroll_window.add_with_viewport(self.runner_config_vbox) notebook.append_page(self.runner_scroll_window, Gtk.Label(label="Runner configuration")) #System configuration self.system_config_vbox = SystemConfigVBox(self.lutris_config, "game") self.system_scroll_window = Gtk.ScrolledWindow() self.system_scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.system_scroll_window.add_with_viewport(self.system_config_vbox) notebook.append_page(self.system_scroll_window, Gtk.Label(label="System configuration")) cancel_button = Gtk.Button(None, Gtk.STOCK_CANCEL) add_button = Gtk.Button(None, Gtk.STOCK_ADD) self.action_area.add(cancel_button) self.action_area.add(add_button) cancel_button.connect("clicked", self.close) add_button.connect("clicked", self.add_game) self.show_all() self.run() def add_game(self, _button): """OK button pressed in the Add Game Dialog""" name = self.realname_entry.get_text() self.lutris_config.config["realname"] = name self.lutris_config.config["runner"] = self.runner_class if self.runner_class and name: game_identifier = self.lutris_config.save(config_type="game") self.game_info = {"name": name, "runner": self.runner_class, "slug": game_identifier} runner = import_runner(self.runner_class)(self.lutris_config) self.game_info['directory'] = runner.get_game_path() pga.add_game(**self.game_info) self.destroy() def on_runner_changed(self, widget): """Action called when runner drop down is changed""" selected_runner = widget.get_active() scroll_windows_children = [self.conf_scroll_window.get_children(), self.runner_scroll_window.get_children(), self.system_scroll_window.get_children()] for scroll_window_children in scroll_windows_children: for child in scroll_window_children: child.destroy() if selected_runner == 0: no_runner_label = Gtk.Label(label="Choose a runner from the list") no_runner_label.show() self.runner_scroll_window.add_with_viewport(no_runner_label) return self.runner_class = widget.get_model()[selected_runner][1] self.lutris_config = LutrisConfig(self.runner_class) self.game_config_vbox = GameConfigVBox(self.lutris_config, "game") self.conf_scroll_window.add_with_viewport(self.game_config_vbox) self.conf_scroll_window.show_all() #Load runner box self.runner_options_vbox = RunnerConfigVBox(self.lutris_config, "game") self.runner_scroll_window.add_with_viewport(self.runner_options_vbox) self.runner_scroll_window.show_all() #Load system box self.system_config_vbox = SystemConfigVBox(self.lutris_config, "game") self.system_scroll_window.add_with_viewport(self.system_config_vbox) self.system_scroll_window.show_all() def close(self, _widget=None, _other=None): """Action received on dialog close""" self.destroy()
class PreferencesDialog(GameDialogCommon): def __init__(self, parent=None): super().__init__(_("Lutris settings"), parent=parent) self.set_border_width(0) self.set_default_size(1010, 600) self.lutris_config = LutrisConfig() hbox = Gtk.HBox(visible=True) sidebar = Gtk.ListBox(visible=True) sidebar.connect("row-selected", self.on_sidebar_activated) sidebar.add( self.get_sidebar_button("prefs-stack", _("Interface"), "view-grid-symbolic")) sidebar.add( self.get_sidebar_button("runners-stack", _("Runners"), "applications-utilities-symbolic")) sidebar.add( self.get_sidebar_button("services-stack", _("Sources"), "application-x-addon-symbolic")) sidebar.add( self.get_sidebar_button("sysinfo-stack", _("Hardware information"), "computer-symbolic")) sidebar.add( self.get_sidebar_button("system-stack", _("Global options"), "emblem-system-symbolic")) hbox.pack_start(sidebar, False, False, 0) self.stack = Gtk.Stack(visible=True) self.stack.set_vhomogeneous(False) self.stack.set_interpolate_size(True) hbox.add(self.stack) self.vbox.pack_start(hbox, True, True, 0) self.stack.add_named(self.build_scrolled_window(PreferencesBox()), "prefs-stack") self.stack.add_named(self.build_scrolled_window(RunnersBox()), "runners-stack") self.stack.add_named(self.build_scrolled_window(ServicesBox()), "services-stack") self.stack.add_named(self.build_scrolled_window(SysInfoBox()), "sysinfo-stack") self.system_box = SystemBox(self.lutris_config) self.system_box.show_all() self.stack.add_named(self.build_scrolled_window(self.system_box), "system-stack") self.build_action_area(self.on_save) self.action_area.set_margin_bottom(12) self.action_area.set_margin_right(12) self.action_area.set_margin_left(12) self.action_area.set_margin_top(12) def on_sidebar_activated(self, _listbox, row): if row.get_children()[0].stack_id == "system-stack": self.action_area.show_all() else: self.action_area.hide() self.stack.set_visible_child_name(row.get_children()[0].stack_id) def get_sidebar_button(self, stack_id, text, icon_name): hbox = Gtk.HBox(visible=True) hbox.stack_id = stack_id hbox.set_margin_top(12) hbox.set_margin_bottom(12) hbox.set_margin_right(40) icon = Gtk.Image.new_from_icon_name(icon_name, Gtk.IconSize.MENU) icon.show() hbox.pack_start(icon, False, False, 6) label = Gtk.Label(text, visible=True) label.set_alignment(0, 0.5) hbox.pack_start(label, False, False, 6) return hbox def on_save(self, _widget): self.lutris_config.save() self.destroy()
class GameDialogCommon(object): no_runner_label = "Select a runner from the list" @staticmethod def get_runner_liststore(): """Build a ListStore with available runners.""" runner_liststore = Gtk.ListStore(str, str) runner_liststore.append(("Select a runner from the list", "")) for runner_name in lutris.runners.__all__: runner_class = lutris.runners.import_runner(runner_name) runner = runner_class() if runner.is_installed(): description = runner.description runner_liststore.append( ("%s (%s)" % (runner_name, description), runner_name)) return runner_liststore def build_entry_box(self, entry, label_text=None): box = Gtk.HBox() if label_text: label = Gtk.Label(label=label_text) box.pack_start(label, False, False, 20) box.pack_start(entry, True, True, 20) return box def get_runner_dropdown(self): runner_liststore = self.get_runner_liststore() self.runner_dropdown = Gtk.ComboBox.new_with_model(runner_liststore) runner_index = 0 if self.game: for runner in runner_liststore: if self.runner_name == str(runner[1]): break runner_index += 1 self.runner_dropdown.set_active(runner_index) self.runner_dropdown.connect("changed", self.on_runner_changed) cell = Gtk.CellRendererText() cell.props.ellipsize = Pango.EllipsizeMode.END self.runner_dropdown.pack_start(cell, True) self.runner_dropdown.add_attribute(cell, 'text', 0) return self.runner_dropdown @staticmethod def build_scrolled_window(widget): scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.add_with_viewport(widget) scrolled_window.show_all() return scrolled_window def build_notebook(self): self.notebook = Gtk.Notebook() self.vbox.pack_start(self.notebook, True, True, 10) def add_notebook_tab(self, widget, label): self.notebook.append_page(widget, Gtk.Label(label=label)) def build_info_tab(self): info_box = VBox() self.name_entry = Gtk.Entry() if self.game: self.name_entry.set_text(self.game.name) name_box = self.build_entry_box(self.name_entry, "Name") info_box.pack_start(name_box, False, False, 5) if self.game: self.slug_entry = Gtk.Entry() self.slug_entry.set_text(self.game.slug) self.slug_entry.set_sensitive(False) slug_box = self.build_entry_box(self.slug_entry, "Identifier") info_box.pack_start(slug_box, False, False, 5) runner_box = Gtk.HBox() label = Gtk.Label("Runner") label.set_alignment(0.5, 0.5) runner_dropdown = self.get_runner_dropdown() runner_box.pack_start(label, False, False, 20) runner_box.pack_start(runner_dropdown, False, False, 20) info_box.pack_start(runner_box, False, False, 5) info_sw = self.build_scrolled_window(info_box) self.add_notebook_tab(info_sw, "Game info") def build_game_tab(self): if self.game and self.runner_name: self.game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, "game", self.game) game_sw = self.build_scrolled_window(self.game_box) elif self.runner_name: game = Game(None) game.runner_name = self.runner_name self.game_box = GameBox(self.lutris_config, "game", game) game_sw = self.build_scrolled_window(self.game_box) else: game_sw = Gtk.Label(label=self.no_runner_label) game_sw.show() self.add_notebook_tab(game_sw, "Game configuration") def build_runner_tab(self): if self.runner_name: self.runner_box = RunnerBox(self.lutris_config, "game", self.runner_name) runner_sw = self.build_scrolled_window(self.runner_box) else: runner_sw = Gtk.Label(label=self.no_runner_label) runner_sw.show() self.add_notebook_tab(runner_sw, "Runner configuration") def build_system_tab(self): self.system_box = SystemBox(self.lutris_config, "game") self.system_sw = self.build_scrolled_window(self.system_box) self.add_notebook_tab(self.system_sw, "System configuration") def build_tabs(self): self.build_info_tab() self.build_game_tab() self.build_runner_tab() self.build_system_tab() def rebuild_tabs(self): for i in range(self.notebook.get_n_pages(), 1, -1): self.notebook.remove_page(i - 1) self.build_game_tab() self.build_runner_tab() self.build_system_tab() def build_action_area(self, label, button_callback): cancel_button = Gtk.Button(label="Cancel") cancel_button.connect("clicked", self.on_cancel_clicked) self.action_area.pack_start(cancel_button, True, True, 0) button = Gtk.Button(label=label) button.connect("clicked", button_callback) self.action_area.pack_start(button, True, True, 0) def on_runner_changed(self, widget): """Action called when runner drop down is changed.""" runner_index = widget.get_active() current_page = self.notebook.get_current_page() if runner_index == 0: self.runner_name = None self.lutris_config = LutrisConfig() else: self.runner_name = widget.get_model()[runner_index][1] # XXX DANGER ZONE self.lutris_config = LutrisConfig(runner=self.runner_name) self.rebuild_tabs() self.notebook.set_current_page(current_page) def on_cancel_clicked(self, widget=None): """Dialog destroy callback.""" self.destroy() def is_valid(self): name = self.name_entry.get_text() if not self.runner_name: ErrorDialog("Runner not provided") return False if not name: ErrorDialog("Please fill in the name") return False return True def on_save(self, _button): """Save game info and destroy widget. Return True if success.""" if not self.is_valid(): return False name = self.name_entry.get_text() if not self.lutris_config.game: self.lutris_config.game = slugify(name) self.lutris_config.save() self.slug = self.lutris_config.game runner_class = lutris.runners.import_runner(self.runner_name) runner = runner_class(self.lutris_config) pga.add_or_update(name, self.runner_name, slug=self.slug, directory=runner.game_path, installed=1) self.destroy() logger.debug("Saved %s", name) return True