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 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 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 on_game_install(self, game):
"""Request installation of a game"""
if game.service:
service = get_enabled_services()[game.service]()
db_game = ServiceGameCollection.get_game(service.id, game.appid)
game_id = service.install(db_game)
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:
logger.debug("Should generate automagical installer here but....")
logger.debug("Wait? how did you get here?")
return True
def do_command_line(self, command_line): # noqa: C901 # pylint: disable=arguments-differ
# pylint: disable=too-many-locals,too-many-return-statements,too-many-branches
# pylint: disable=too-many-statements
# TODO: split into multiple methods to reduce complexity (35)
options = command_line.get_options_dict()
# Use stdout to output logs, only if no command line argument is
# provided
argc = len(sys.argv) - 1
if "-d" in sys.argv or "--debug" in sys.argv:
argc -= 1
if not argc:
# Switch back the log output to stderr (the default in Python)
# to avoid messing with any output from command line options.
# Use when targetting Python 3.7 minimum
# console_handler.setStream(sys.stderr)
# Until then...
logger.removeHandler(log.console_handler)
log.console_handler = logging.StreamHandler(stream=sys.stdout)
log.console_handler.setFormatter(log.SIMPLE_FORMATTER)
logger.addHandler(log.console_handler)
# Set up logger
if options.contains("debug"):
log.console_handler.setFormatter(log.DEBUG_FORMATTER)
logger.setLevel(logging.DEBUG)
# Text only commands
# Print Lutris version and exit
if options.contains("version"):
executable_name = os.path.basename(sys.argv[0])
print(executable_name + "-" + settings.VERSION)
logger.setLevel(logging.NOTSET)
return 0
init_lutris()
migrate()
run_all_checks()
# List game
if options.contains("list-games"):
game_list = games_db.get_games()
if options.contains("installed"):
game_list = [game for game in game_list if game["installed"]]
if options.contains("json"):
self.print_game_json(command_line, game_list)
else:
self.print_game_list(command_line, game_list)
return 0
# List Steam games
if options.contains("list-steam-games"):
self.print_steam_list(command_line)
return 0
# List Steam folders
if options.contains("list-steam-folders"):
self.print_steam_folders(command_line)
return 0
# Execute command in Lutris context
if options.contains("exec"):
command = options.lookup_value("exec").get_string()
self.execute_command(command)
return 0
if options.contains("submit-issue"):
IssueReportWindow(application=self)
return 0
try:
url = options.lookup_value(GLib.OPTION_REMAINING)
installer_info = self.get_lutris_action(url)
except ValueError:
self._print(command_line,
_("%s is not a valid URI") % url.get_strv())
return 1
game_slug = installer_info["game_slug"]
action = installer_info["action"]
service = installer_info["service"]
appid = installer_info["appid"]
if options.contains("output-script"):
action = "write-script"
revision = installer_info["revision"]
installer_file = None
if options.contains("install"):
installer_file = options.lookup_value("install").get_string()
if installer_file.startswith(("http:", "https:")):
try:
request = Request(installer_file).get()
except HTTPError:
self._print(command_line,
_("Failed to download %s") % installer_file)
return 1
try:
headers = dict(request.response_headers)
file_name = headers["Content-Disposition"].split("=",
1)[-1]
except (KeyError, IndexError):
file_name = os.path.basename(installer_file)
file_path = os.path.join(tempfile.gettempdir(), file_name)
self._print(
command_line,
_("download {url} to {file} started").format(
url=installer_file, file=file_path))
with open(file_path, 'wb') as dest_file:
dest_file.write(request.content)
installer_file = file_path
action = "install"
else:
installer_file = os.path.abspath(installer_file)
action = "install"
if not os.path.isfile(installer_file):
self._print(command_line,
_("No such file: %s") % installer_file)
return 1
db_game = None
if game_slug and not service:
if action == "rungameid":
# Force db_game to use game id
self.run_in_background = True
db_game = games_db.get_game_by_field(game_slug, "id")
elif action == "rungame":
# Force db_game to use game slug
self.run_in_background = True
db_game = games_db.get_game_by_field(game_slug, "slug")
elif action == "install":
# Installers can use game or installer slugs
self.run_in_background = True
db_game = games_db.get_game_by_field(game_slug, "slug") \
or games_db.get_game_by_field(game_slug, "installer_slug")
else:
# Dazed and confused, try anything that might works
db_game = (games_db.get_game_by_field(game_slug, "id")
or games_db.get_game_by_field(game_slug, "slug")
or games_db.get_game_by_field(
game_slug, "installer_slug"))
# If reinstall flag is passed, force the action to install
if options.contains("reinstall"):
action = "install"
if action == "write-script":
if not db_game or not db_game["id"]:
logger.warning("No game provided to generate the script")
return 1
self.generate_script(
db_game,
options.lookup_value("output-script").get_string())
return 0
# Graphical commands
self.activate()
self.set_tray_icon()
if not action:
if db_game and db_game["installed"]:
# Game found but no action provided, ask what to do
dlg = InstallOrPlayDialog(db_game["name"])
if not dlg.action_confirmed:
action = None
elif dlg.action == "play":
action = "rungame"
elif dlg.action == "install":
action = "install"
elif game_slug or installer_file or service:
# No game found, default to install if a game_slug or
# installer_file is provided
action = "install"
if service:
service_game = ServiceGameCollection.get_game(service, appid)
if service_game:
service = get_enabled_services()[service]()
service.install(service_game)
return 0
if action == "install":
installers = get_installers(
game_slug=game_slug,
installer_file=installer_file,
revision=revision,
)
if installers:
self.show_installer_window(installers)
elif action in ("rungame", "rungameid"):
if not db_game or not db_game["id"]:
logger.warning("No game found in library")
if not self.window.is_visible():
self.do_shutdown()
return 0
game = Game(db_game["id"])
self.on_game_launch(game)
return 0
def on_realize(self, widget):
self.active_platforms = games_db.get_used_platforms()
self.runners = sorted(runners.__all__)
self.platforms = sorted(runners.RUNNER_PLATFORMS)
self.categories = categories_db.get_categories()
self.add(
SidebarRow(
"all", "category", _("Games"),
Gtk.Image.new_from_icon_name("applications-games-symbolic",
Gtk.IconSize.MENU)))
self.add(
SidebarRow(
"recent", "dynamic_category", _("Recent"),
Gtk.Image.new_from_icon_name("document-open-recent-symbolic",
Gtk.IconSize.MENU)))
self.add(
SidebarRow(
"favorite", "category", _("Favorites"),
Gtk.Image.new_from_icon_name("favorite-symbolic",
Gtk.IconSize.MENU)))
self.running_row = SidebarRow(
"running", "dynamic_category", _("Running"),
Gtk.Image.new_from_icon_name("media-playback-start-symbolic",
Gtk.IconSize.MENU))
# I wanted this to be on top but it really messes with the headers when showing/hiding the row.
self.add(self.running_row)
service_classes = services.get_enabled_services()
for service_name in service_classes:
service = service_classes[service_name]()
row_class = OnlineServiceSidebarRow if service.online else ServiceSidebarRow
service_row = row_class(service)
self.service_rows[service_name] = service_row
self.add(service_row)
for runner_name in self.runners:
icon_name = runner_name.lower().replace(" ", "") + "-symbolic"
runner = runners.import_runner(runner_name)()
self.add(
RunnerSidebarRow(runner_name,
"runner",
runner.human_name,
self.get_sidebar_icon(icon_name),
application=self.application))
for platform in self.platforms:
icon_name = (platform.lower().replace(" ", "").replace("/", "_") +
"-symbolic")
self.add(
SidebarRow(platform, "platform", platform,
self.get_sidebar_icon(icon_name)))
self.update()
for row in self.get_children():
if row.type == self.selected_row_type and row.id == self.selected_row_id:
self.select_row(row)
break
self.show_all()
self.running_row.hide()