def __init__(self): super().__init__( application_id="net.lutris.Lutris", flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, ) init_lutris() gettext.bindtextdomain("lutris", "/usr/share/locale") gettext.textdomain("lutris") GLib.set_application_name(_("Lutris")) self.running_games = Gio.ListStore.new(Game) self.window = None self.tray = None self.css_provider = Gtk.CssProvider.new() self.run_in_background = False if os.geteuid() == 0: ErrorDialog( "Running Lutris as root is not recommended and may cause unexpected issues" ) try: self.css_provider.load_from_path( os.path.join(datapath.get(), "ui", "lutris.css")) except GLib.Error as e: logger.exception(e) if hasattr(self, "add_main_option"): self.add_arguments() else: ErrorDialog( "Your Linux distribution is too old. Lutris won't function properly." )
def __init__(self): super().__init__( application_id="net.lutris.Lutris", flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, ) GObject.add_emission_hook(Game, "game-launch", self.on_game_launch) GObject.add_emission_hook(Game, "game-start", self.on_game_start) GObject.add_emission_hook(Game, "game-stop", self.on_game_stop) GObject.add_emission_hook(Game, "game-install", self.on_game_install) GLib.set_application_name(_("Lutris")) self.window = None self.running_games = Gio.ListStore.new(Game) self.app_windows = {} self.tray = None self.css_provider = Gtk.CssProvider.new() self.run_in_background = False if os.geteuid() == 0: ErrorDialog(_("Running Lutris as root is not recommended and may cause unexpected issues")) try: self.css_provider.load_from_path(os.path.join(datapath.get(), "ui", "lutris.css")) except GLib.Error as e: logger.exception(e) if hasattr(self, "add_main_option"): self.add_arguments() else: ErrorDialog(_("Your Linux distribution is too old. Lutris won't function properly."))
def is_valid(self): if not self.runner_name: ErrorDialog(_("Runner not provided")) return False if not self.name_entry.get_text(): ErrorDialog(_("Please fill in the name")) return False if (self.runner_name in ("steam", "winesteam") and self.lutris_config.game_config.get("appid") is None): ErrorDialog(_("Steam AppId not provided")) return False invalid_fields = [] runner_class = import_runner(self.runner_name) runner_instance = runner_class() for config in ["game", "runner"]: for k, v in getattr(self.lutris_config, config + "_config").items(): option = runner_instance.find_option(config + "_options", k) if option is None: continue validator = option.get("validator") if validator is not None: try: res = validator(v) logger.debug("%s validated successfully: %s", k, res) except Exception: invalid_fields.append(option.get("label")) if invalid_fields: ErrorDialog(_("The following fields have invalid values: ") + ", ".join(invalid_fields)) return False return True
def __init__(self): Gtk.Application.__init__( self, application_id='net.lutris.Lutris', flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE) gettext.bindtextdomain("lutris", "/usr/share/locale") gettext.textdomain("lutris") check_config() migrate() update_platforms() GLib.set_application_name(_('Lutris')) self.window = None self.css_provider = Gtk.CssProvider.new() if os.geteuid() == 0: ErrorDialog( "Running Lutris as root is not recommended and may cause unexpected issues" ) try: self.css_provider.load_from_path( os.path.join(datapath.get(), 'ui', 'lutris.css')) except GLib.Error as e: logger.exception(e) if hasattr(self, 'add_main_option'): self.add_arguments() else: ErrorDialog( "Your Linux distribution is too old, Lutris won't function properly" )
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 esync_limit_callback(config): if not is_esync_limit_set(): ErrorDialog("Your limits are not set correctly." " Please increase them as described here:" " <a href='https://github.com/lutris/lutris/wiki/How-to:-Esync'>" "https://github.com/lutris/lutris/wiki/How-to:-Esync</a>") return False if is_version_esync(config['version']): ErrorDialog("Your wine version may not support esync, if you are unsure please check.") return True
def is_valid(self): if not self.runner_name: ErrorDialog("Runner not provided") return False if not self.name_entry.get_text(): ErrorDialog("Please fill in the name") return False if (self.runner_name in ("steam", "winesteam") and self.lutris_config.game_config.get("appid") is None): ErrorDialog("Steam AppId not provided") return False return True
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 if self.runner_name in ('steam', 'winesteam') and self.lutris_config.game_config.get('appid') is None: ErrorDialog("Steam AppId not provided") return False return True
def on_game_install(self, game): """Request installation of a game""" if game.service and game.service != "lutris": service = get_enabled_services()[game.service]() db_game = ServiceGameCollection.get_game(service.id, game.appid) try: game_id = service.install(db_game) except ValueError as e: logger.debug(e) game_id = None if game_id: game = Game(game_id) game.launch() return True if not game.slug: raise ValueError("Invalid game passed: %s" % game) # return True installers = get_installers(game_slug=game.slug) if installers: self.show_installer_window(installers) else: ErrorDialog(_("There is no installer available for %s.") % game.name, parent=self.window) return True
def update_search_results_cb(self, api_games, error): if error: ErrorDialog(error) return self.search_spinner.stop() self.search_spinner.hide() total_count = api_games.get("count", 0) count = len(api_games.get('results', [])) if not count: self.result_label.set_markup(_("No results")) elif count == total_count: self.result_label.set_markup(_(f"Showing <b>{count}</b> results")) else: self.result_label.set_markup( _(f"<b>{total_count}</b> results, only displaying first {count}" )) for row in self.listbox.get_children(): row.destroy() for game in api_games.get("results", []): platforms = ",".join( gtk_safe(platform["name"]) for platform in game["platforms"]) year = game['year'] or "" if platforms and year: platforms = ", " + platforms row = self.build_row("", gtk_safe(game['name']), f"{year}{platforms}") row.api_info = game self.listbox.add(row) self.listbox.show()
def _on_folder_scanned(self, result, error): if error: ErrorDialog(error) self.destroy() return for child in self.vbox.get_children(): child.destroy() installed, missing = result installed_label = self._get_label("Installed games") self.vbox.add(installed_label) installed_listbox = Gtk.ListBox(visible=True) installed_scroll = Gtk.ScrolledWindow(visible=True) installed_scroll.set_vexpand(True) installed_scroll.add(installed_listbox) self.vbox.add(installed_scroll) for folder in installed: installed_listbox.add(self.build_row("", gtk_safe(folder), "")) missing_label = self._get_label("No match found") self.vbox.add(missing_label) missing_listbox = Gtk.ListBox(visible=True) missing_scroll = Gtk.ScrolledWindow(visible=True) missing_scroll.set_vexpand(True) missing_scroll.add(missing_listbox) self.vbox.add(missing_scroll) for folder in missing: missing_listbox.add(self.build_row("", gtk_safe(folder), ""))
def esync_display_limit_warning(): ErrorDialog( _("Your limits are not set correctly." " Please increase them as described here:" " <a href='https://github.com/lutris/lutris/wiki/How-to:-Esync'>" "How-to:-Esync (https://github.com/lutris/lutris/wiki/How-to:-Esync)</a>" ))
def __init__(self, title, parent, runner): super(RunnerInstallDialog, self).__init__(title, parent, 0, ('_OK', Gtk.ResponseType.OK)) width, height = (460, 380) self.dialog_size = (width, height) self.set_default_size(width, height) self.runner = runner self.runner_info = api.get_runners(self.runner) if not self.runner_info: ErrorDialog( 'Unable to get runner versions, check your internet connection', parent=parent) return label = Gtk.Label("%s version management" % self.runner_info['name']) self.vbox.add(label) self.runner_store = self.get_store() scrolled_window = Gtk.ScrolledWindow() self.treeview = self.get_treeview(self.runner_store) self.installing = {} self.connect('response', self.on_response) scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_OUT) scrolled_window.add(self.treeview) self.vbox.pack_start(scrolled_window, True, True, 14) self.show_all()
def display_all_versions(self, runner_info, error): """Clear the box and display versions from runner_info""" if error: logger.error(error) self.runner_info = runner_info if not self.runner_info: ErrorDialog( "Unable to get runner versions. Check your internet connection." ) return for child_widget in self.vbox.get_children(): if child_widget.get_name() not in "GtkBox": child_widget.destroy() self.populate_store() label = Gtk.Label.new("%s version management" % self.runner_info["name"]) self.vbox.add(label) scrolled_window = Gtk.ScrolledWindow() treeview = self.get_treeview(self.runner_store) self.installing = {} self.connect("response", self.on_destroy) scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_OUT) scrolled_window.add(treeview) self.vbox.pack_start(scrolled_window, True, True, 14) self.show_all()
def install_dialog(self): """Ask the user if she wants to install the runner. Return success of runner installation. """ dialog = dialogs.QuestionDialog({ "question": ("The required runner is not installed.\n" "Do you wish to install it now?"), "title": "Required runner unavailable", }) if Gtk.ResponseType.YES == dialog.result: from lutris.gui.dialogs.runners import simple_downloader from lutris.gui.dialogs import ErrorDialog try: if hasattr(self, "get_version"): self.install(downloader=simple_downloader, version=self.get_version(use_default=False)) else: self.install(downloader=simple_downloader) except RunnerInstallationError as ex: ErrorDialog(ex.message) return self.is_installed() return False
def on_game_install(self, game): """Request installation of a game""" if game.service and game.service != "lutris": service = get_enabled_services()[game.service]() db_game = ServiceGameCollection.get_game(service.id, game.appid) try: game_id = service.install(db_game) except ValueError as e: logger.debug(e) game_id = None if game_id: game = Game(game_id) game.launch() else: ErrorDialog(message=_("Could not retrieve game installer."), parent=self.window) return True if not game.slug: raise ValueError("Invalid game passed: %s" % game) # return True installers = get_installers(game_slug=game.slug) if installers: self.show_installer_window(installers) else: logger.debug("Should generate automagical installer here but....") logger.debug("Wait? how did you get here?") return True
def service_load_cb(self, _result, error): if error: if isinstance(error, AuthTokenExpired): self.service.logout() self.service.login() else: ErrorDialog(str(error)) GLib.timeout_add(2000, self.enable_refresh_button)
def runner_fetch_cb(self, runner_info, error): """Clear the box and display versions from runner_info""" if error: logger.error(error) ErrorDialog(_("Unable to get runner versions: %s") % error) return self.runner_info = runner_info remote_versions = {(v["version"], v["architecture"]) for v in self.runner_info["versions"]} local_versions = self.get_installed_versions() for local_version in local_versions - remote_versions: self.runner_info["versions"].append({ "version": local_version[0], "architecture": local_version[1], "url": "", }) if not self.runner_info: ErrorDialog(_("Unable to get runner versions from lutris.net")) return for child_widget in self.vbox.get_children(): if child_widget.get_name() not in "GtkBox": child_widget.destroy() self.populate_store() label = Gtk.Label.new( _("%s version management") % self.runner_info["name"]) self.vbox.add(label) scrolled_window = Gtk.ScrolledWindow() treeview = self.get_treeview(self.runner_store) self.installing = {} self.connect("response", self.on_destroy) scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_OUT) scrolled_window.add(treeview) self.vbox.pack_start(scrolled_window, True, True, 14) self.show_all()
def service_load_cb(self, games, error): if not error and not games: error = _( "Failed to load games. Check that your profile is set to public during the sync." ) if error: ErrorDialog(error) GLib.timeout_add(5000, self.enable_refresh_button)
def error_handler(error_type, value, traceback): if error_type == ScriptingError: message = value.message if value.faulty_data: message += "\n<b>" + str(value.faulty_data) + "</b>" ErrorDialog(message) else: _excepthook(error_type, value, traceback)
def service_load_cb(self, games, error): if games is None: logger.warning("No game returned from the service") if not error and not games and self.service.id == "steam": # This should not be handled here, the steam service should raise an error error = _("Failed to load games. Check that your profile is set to public during the sync.") if error: ErrorDialog(str(error)) GLib.timeout_add(5000, self.enable_refresh_button)
def on_game_install_dlc(self, game): service = get_enabled_services()[game.service]() db_game = games_db.get_game_by_field(game.id, "id") installers = service.get_dlc_installers(db_game) if installers: self.show_installer_window(installers, service, game.appid) else: ErrorDialog(_("No DLC found")) return True
def error_handler(error_type, value, traceback): """Intercept all possible exceptions and raise them as ScriptingErrors""" if error_type == ScriptingError: message = value.message if value.faulty_data: message += "\n<b>%s</b>" % gtk_safe(value.faulty_data) ErrorDialog(message) else: _excepthook(error_type, value, traceback)
def __init__(self): super().__init__( application_id="net.lutris.Lutris", flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, ) logger.info("Running Lutris %s", settings.VERSION) set_child_subreaper() gettext.bindtextdomain("lutris", "/usr/share/locale") gettext.textdomain("lutris") check_config() migrate() update_platforms() check_driver() check_libs() check_vulkan() GLib.set_application_name(_("Lutris")) self.running_games = [] self.window = None self.help_overlay = None self.tray = None self.css_provider = Gtk.CssProvider.new() if os.geteuid() == 0: ErrorDialog( "Running Lutris as root is not recommended and may cause unexpected issues" ) try: self.css_provider.load_from_path( os.path.join(datapath.get(), "ui", "lutris.css") ) except GLib.Error as e: logger.exception(e) if hasattr(self, "add_main_option"): self.add_arguments() else: ErrorDialog( "Your Linux distribution is too old, Lutris won't function properly" )
def install_runner(self, row): """Download and install a runner version""" dest_path = self.get_dest_path(row) url = row[self.COL_URL] if not url: ErrorDialog("Version %s is not longer available" % row[self.COL_VER]) return downloader = Downloader(row[self.COL_URL], dest_path, overwrite=True) GLib.timeout_add(100, self.get_progress, downloader, row) self.installing[row[self.COL_VER]] = downloader downloader.start()
def on_install_clicked(self, widget): """Install a runner.""" try: self.runner.install(downloader=simple_downloader) except ( runners.RunnerInstallationError, runners.NonInstallableRunnerError, ) as ex: ErrorDialog(ex.message) return if self.runner.is_installed(): self.emit("runner-installed")
def start(self): """Start downloading a file.""" try: self.downloader = Downloader(self.url, self.dest) except RuntimeError as ex: from lutris.gui.dialogs import ErrorDialog ErrorDialog(ex.message) self.emit('cancelrequested', {}) return timer_id = GLib.timeout_add(100, self.progress) self.cancel_button.set_sensitive(True) self.downloader.start() return timer_id
def on_install_clicked(self, widget, runner, runner_label): """Install a runner.""" if runner.depends_on is not None: dependency = runner.depends_on() dependency.install() try: runner.install() except (runners.RunnerInstallationError, runners.NonInstallableRunnerError) as ex: ErrorDialog(ex.message, parent=self) if runner.is_installed(): self.emit('runner-installed') self.refresh_button.emit('clicked')
def install_runner(self, row): """Download and install a runner version""" runner = row.runner row.install_progress.set_fraction(0.0) dest_path = self.get_dest_path(runner) url = runner[self.COL_URL] if not url: ErrorDialog(_("Version %s is not longer available") % runner[self.COL_VER]) return downloader = Downloader(runner[self.COL_URL], dest_path, overwrite=True) GLib.timeout_add(100, self.get_progress, downloader, row) self.installing[runner[self.COL_VER]] = downloader downloader.start() self.update_listboxrow(row)
def on_install_clicked(self, widget, runner, runner_label): """Install a runner.""" if runner.depends_on is not None: dependency = runner.depends_on() dependency.install() try: runner.install() except (runners.RunnerInstallationError, runners.NonInstallableRunnerError) as ex: ErrorDialog(ex.message) if runner.is_installed(): self.emit('runner-installed') widget.hide() runner_label.set_sensitive(True)