def on_install_finished(self):
"""Actual game installation."""
self.status_label.set_text("Installation finished!")
self.notify_install_success()
self.clean_widgets()
# Shortcut checkboxes
self.desktop_shortcut_box = Gtk.CheckButton("Create desktop shortcut")
self.menu_shortcut_box = Gtk.CheckButton("Create application menu "
"shortcut")
self.widget_box.pack_start(self.desktop_shortcut_box, False, False, 5)
self.widget_box.pack_start(self.menu_shortcut_box, False, False, 5)
self.widget_box.show_all()
if settings.read_setting('create_desktop_shortcut') == 'True':
self.desktop_shortcut_box.set_active(True)
if settings.read_setting('create_menu_shortcut') == 'True':
self.menu_shortcut_box.set_active(True)
self.connect('destroy', self.create_shortcuts)
# Buttons
self.eject_button.hide()
self.cancel_button.hide()
self.continue_button.hide()
self.install_button.hide()
self.play_button.show()
self.close_button.grab_focus()
self.close_button.show()
if not self.is_active():
self.set_urgency_hint(True) # Blink in taskbar
self.connect('focus-in-event', self.on_window_focus)
def on_install_finished(self):
self.clean_widgets()
self.install_in_progress = False
self.desktop_shortcut_box = Gtk.CheckButton("Create desktop shortcut")
self.menu_shortcut_box = Gtk.CheckButton("Create application menu " "shortcut")
self.widget_box.pack_start(self.desktop_shortcut_box, False, False, 5)
self.widget_box.pack_start(self.menu_shortcut_box, False, False, 5)
self.widget_box.show_all()
if settings.read_setting("create_desktop_shortcut") == "True":
self.desktop_shortcut_box.set_active(True)
if settings.read_setting("create_menu_shortcut") == "True":
self.menu_shortcut_box.set_active(True)
self.connect("delete-event", self.create_shortcuts)
self.eject_button.hide()
self.cancel_button.hide()
self.continue_button.hide()
self.install_button.hide()
self.play_button.show()
self.close_button.grab_focus()
self.close_button.show()
if not self.is_active():
self.set_urgency_hint(True) # Blink in taskbar
self.connect("focus-in-event", self.on_window_focus)
def __init__(self):
GObject.GObject.__init__(self)
self.runner_labels = {}
self.set_title("Manage runners")
width = int(settings.read_setting('runners_manager_width') or 700)
height = int(settings.read_setting('runners_manager_height') or 500)
self.dialog_size = (width, height)
self.set_default_size(width, height)
self.set_border_width(10)
self.set_position(Gtk.WindowPosition.CENTER)
self.vbox = Gtk.VBox()
self.add(self.vbox)
# Scrolled window
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
self.vbox.pack_start(scrolled_window, True, True, 0)
self.show_all()
# Runner list
self.runner_list = sorted(runners.__all__)
self.runner_listbox = Gtk.ListBox(visible=True, selection_mode=Gtk.SelectionMode.NONE)
self.runner_listbox.set_header_func(self._listbox_header_func)
self.populate_runners()
scrolled_window.add(self.runner_listbox)
# Bottom bar
buttons_box = Gtk.Box()
buttons_box.show()
open_runner_button = Gtk.Button("Open Runners Folder")
open_runner_button.show()
open_runner_button.connect('clicked', self.on_runner_open_clicked)
buttons_box.pack_start(open_runner_button, False, False, 0)
refresh_button = Gtk.Button("Refresh")
refresh_button.show()
refresh_button.connect('clicked', self.on_refresh_clicked)
buttons_box.pack_start(refresh_button, False, False, 10)
close_button = Gtk.Button("Close")
close_button.show()
close_button.connect('clicked', self.on_close_clicked)
buttons_box.pack_start(close_button, False, False, 0)
# Signals
self.connect('destroy', self.on_destroy)
self.connect('configure-event', self.on_resize)
self.vbox.pack_start(buttons_box, False, False, 5)
def load_icon_type_from_settings(self, view_type):
"""Return the icon style depending on the type of view."""
if view_type == 'list':
self.icon_type = settings.read_setting('icon_type_listview')
default = settings.ICON_TYPE_LISTVIEW
else:
self.icon_type = settings.read_setting('icon_type_gridview')
default = settings.ICON_TYPE_GRIDVIEW
if self.icon_type not in ("banner_small", "banner", "icon"):
self.icon_type = default
return self.icon_type
def get_icon_type(self, view_type):
"""Return the icon style depending on the type of view."""
if view_type == 'icon':
icon_type = settings.read_setting('icon_type_iconview')
default = settings.ICON_TYPE_ICONVIEW
elif view_type == 'list':
icon_type = settings.read_setting('icon_type_listview')
default = settings.ICON_TYPE_LISTVIEW
if icon_type not in ("banner_small", "banner", "icon"):
icon_type = default
return icon_type
def get_icon_type(self, view_type):
"""Return the icon style depending on the type of view."""
if view_type == "list":
icon_type = settings.read_setting("icon_type_listview")
default = settings.ICON_TYPE_LISTVIEW
else:
icon_type = settings.read_setting("icon_type_gridview")
default = settings.ICON_TYPE_GRIDVIEW
if icon_type not in ("banner_small", "banner", "icon"):
icon_type = default
return icon_type
def load_icon_type_from_settings(self, view_type):
"""Return the icon style depending on the type of view."""
if view_type == "list":
self.icon_type = settings.read_setting("icon_type_listview")
default = "icon"
else:
self.icon_type = settings.read_setting("icon_type_gridview")
default = "banner"
if self.icon_type not in IMAGE_SIZES.keys():
self.icon_type = default
return self.icon_type
def __init__(self, store):
self.game_store = store
self.model = self.game_store.modelfilter.sort_new_with_model()
super(GameListView, self).__init__(self.model)
self.set_rules_hint(True)
# Icon column
image_cell = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("", image_cell, pixbuf=COL_ICON)
column.set_reorderable(True)
self.append_column(column)
# Text columns
default_text_cell = self.set_text_cell()
name_cell = self.set_text_cell()
name_cell.set_padding(5, 0)
column = self.set_column(name_cell, "Name", COL_NAME)
width = settings.read_setting('name_column_width', 'list view')
column.set_fixed_width(int(width) if width else 200)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Year", COL_YEAR)
width = settings.read_setting('year_column_width', 'list view')
column.set_fixed_width(int(width) if width else 60)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Runner", COL_RUNNER_HUMAN_NAME)
width = settings.read_setting('runner_column_width', 'list view')
column.set_fixed_width(int(width) if width else 120)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Platform", COL_PLATFORM)
width = settings.read_setting('platform_column_width', 'list view')
column.set_fixed_width(int(width) if width else 120)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Last played", COL_LASTPLAYED_TEXT)
self.set_sort_with_column(COL_LASTPLAYED_TEXT, COL_LASTPLAYED)
width = settings.read_setting('lastplayed_column_width', 'list view')
column.set_fixed_width(int(width) if width else 120)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
self.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
self.connect_signals()
self.connect('row-activated', self.on_row_activated)
self.get_selection().connect('changed', self.on_cursor_changed)
def initialize(self, **kwargs):
width = int(settings.read_setting("runners_manager_width") or 800)
height = int(settings.read_setting("runners_manager_height") or 800)
self.dialog_size = (width, height)
self.dialog.resize(width, height)
self.runner_listbox = self.builder.get_object('runners_listbox')
self.runner_listbox.set_header_func(self._listbox_header_func)
self.refresh_button = self.builder.get_object('refresh_button')
self.runner_list = sorted(runners.__all__)
# Run this after show_all, else all hidden buttons gets shown
self.populate_runners()
def get_services_synced_at_startup():
"""Return services synced at startup"""
return [
import_service(name)
for name in __all__
if read_setting("sync_at_startup", name) == "True"
]
def get_view_type(self):
if not flowbox.FLOWBOX_SUPPORTED:
return 'list'
view_type = settings.read_setting('view_type')
if view_type in ['grid', 'list']:
return view_type
return settings.GAME_VIEW
def __init__(self, service):
super(ServiceSyncRow, self).__init__()
self.set_spacing(20)
self.identifier = service.__name__.split('.')[-1]
name = service.NAME
icon = get_runner_icon(self.identifier)
self.pack_start(icon, False, False, 0)
label = Gtk.Label(xalign=0)
label.set_markup("<b>{}</b>".format(name))
self.pack_start(label, True, True, 0)
actions = Gtk.VBox()
self.pack_start(actions, False, False, 0)
sync_switch = Gtk.Switch()
sync_switch.set_tooltip_text("Sync when Lutris starts")
sync_switch.props.valign = Gtk.Align.CENTER
sync_switch.connect('notify::active', self.on_switch_changed)
if read_setting('sync_at_startup', self.identifier) == 'True':
sync_switch.set_state(True)
actions.pack_start(sync_switch, False, False, 0)
sync_button = Gtk.Button("Sync")
sync_button.set_tooltip_text("Sync now")
sync_button.connect('clicked', self.on_sync_button_clicked, service.sync_with_lutris)
actions.pack_start(sync_button, False, False, 0)
def check_libs(all_components=False):
"""Checks that required libraries are installed on the system"""
missing_libs = LINUX_SYSTEM.get_missing_libs()
if all_components:
components = LINUX_SYSTEM.requirements
else:
components = LINUX_SYSTEM.critical_requirements
missing_vulkan_libs = []
for req in components:
for index, arch in enumerate(LINUX_SYSTEM.runtime_architectures):
for lib in missing_libs[req][index]:
if req == "VULKAN":
missing_vulkan_libs.append(arch)
logger.error("%s %s missing (needed by %s)", arch, lib, req.lower())
if missing_vulkan_libs:
setting = "dismiss-missing-vulkan-library-warning"
if settings.read_setting(setting) != "True":
DontShowAgainDialog(
setting,
"Missing vulkan libraries",
secondary_message="The Vulkan library for %s has not been found. "
"This will prevent games using Vulkan (such as DXVK games) from running. "
"To install it, please follow "
"<a href='https://github.com/lutris/lutris/wiki/Installing-drivers'>"
"the instructions on our Wiki</a>"
% " and ".join(missing_vulkan_libs)
)
def __init__(self):
GObject.GObject.__init__(self)
self.set_title("Manage runners")
width = int(settings.read_setting('runners_manager_width') or 700)
height = int(settings.read_setting('runners_manager_height') or 500)
self.dialog_size = (width, height)
self.set_default_size(width, height)
self.set_border_width(10)
self.set_position(Gtk.WindowPosition.CENTER)
self.vbox = Gtk.VBox()
self.add(self.vbox)
# Scrolled window
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
self.vbox.pack_start(scrolled_window, True, True, 0)
self.show_all()
# Runner list
runner_list = lutris.runners.__all__
runner_vbox = Gtk.VBox()
runner_vbox.show()
self.runner_labels = {}
for runner_name in runner_list:
hbox = self.get_runner_hbox(runner_name)
runner_vbox.pack_start(hbox, True, True, 5)
separator = Gtk.Separator()
runner_vbox.pack_start(separator, False, False, 5)
scrolled_window.add_with_viewport(runner_vbox)
# Bottom bar
buttons_box = Gtk.Box()
buttons_box.show()
open_runner_button = Gtk.Button("Open Runners Folder")
open_runner_button.show()
open_runner_button.connect('clicked', self.on_runner_open_clicked)
buttons_box.add(open_runner_button)
# Signals
self.connect('destroy', self.on_destroy)
self.connect('configure-event', self.on_resize)
self.vbox.pack_start(buttons_box, False, False, 5)
def on_version_received(version, error):
if not version:
return
latest_version = settings.read_setting('latest_version')
if version > (latest_version or settings.VERSION):
dialogs.ClientUpdateDialog()
# Store latest version seen to avoid showing
# the dialog more than once.
settings.write_setting('latest_version', version)
def __init__(self, games, filter_text='', filter_runner='',
icon_type=None):
self.icon_type = icon_type
self.game_store = GameStore(icon_type=icon_type,
filter_text=filter_text,
filter_runner=filter_runner)
self.fill_store(games)
self.model = self.game_store.modelfilter.sort_new_with_model()
super(GameListView, self).__init__(self.model)
self.set_rules_hint(True)
# Icon column
image_cell = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("", image_cell, pixbuf=COL_ICON)
column.set_reorderable(True)
self.append_column(column)
# Text columns
default_text_cell = self.set_text_cell()
name_cell = self.set_text_cell()
name_cell.set_padding(5, 0)
column = self.set_column(name_cell, "Name", COL_NAME)
width = settings.read_setting('name_column_width', 'list view')
column.set_fixed_width(int(width) if width else 200)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Year", COL_YEAR)
width = settings.read_setting('year_column_width', 'list view')
column.set_fixed_width(int(width) if width else 60)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
column = self.set_column(default_text_cell, "Runner", COL_RUNNER)
width = settings.read_setting('runner_column_width', 'list view')
column.set_fixed_width(int(width) if width else 100)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
self.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
self.connect_signals()
self.connect('row-activated', self.on_row_activated)
self.connect('cursor-changed', self.on_cursor_changed)
def migrate():
current_version = int(settings.read_setting("migration_version") or 0)
if current_version >= MIGRATION_VERSION:
return
for i in range(current_version, MIGRATION_VERSION):
for migration_name in MIGRATIONS[i]:
logger.info("Running migration: %s", migration_name)
migration = get_migration_module(migration_name)
migration.migrate()
settings.write_setting("migration_version", MIGRATION_VERSION)
def check_update(self):
"""Verify availability of client update."""
version_request = http.Request('https://lutris.net/version')
version_request.get()
version = version_request.content
if version:
latest_version = settings.read_setting('latest_version')
if version > (latest_version or settings.VERSION):
dialogs.ClientUpdateDialog()
# Store latest version seen to avoid showing
# the dialog more than once.
settings.write_setting('latest_version', version)
def migrate():
current_version = settings.read_setting('migration_version') or 0
current_version = int(current_version)
if current_version >= MIGRATION_VERSION:
return
for i in range(current_version, MIGRATION_VERSION):
for migration_name in MIGRATIONS[i]:
logger.debug('Running migration: %s' % migration_name)
migration = get_migration_module(migration_name)
migration.migrate()
settings.write_setting('migration_version', MIGRATION_VERSION)
def check_donate():
setting = "dont-support-lutris"
if settings.read_setting(setting) != "True":
DontShowAgainDialog(
setting,
"Please support Lutris!",
secondary_message="Lutris is entirely funded by its community and will "
"remain an independent gaming platform.\n"
"For Lutris to survive and grow, the project needs your help.\n"
"Please consider making a donation if you can. This will greatly help "
"cover the costs of hosting the project and fund new features "
"like cloud saves or a full-screen interface for the TV!\n"
"<a href='https://lutris.net/donate'>SUPPORT US! https://lutris.net/donate</a>"
)
def set_column(self, cell, header, column_id, default_width, sort_id=None):
column = Gtk.TreeViewColumn(header, cell, markup=column_id)
column.set_sort_indicator(True)
column.set_sort_column_id(column_id if sort_id is None else sort_id)
self.set_column_sort(column_id if sort_id is None else sort_id)
column.set_resizable(True)
column.set_reorderable(True)
width = settings.read_setting(
"%s_column_width" % COLUMN_NAMES[column_id], "list view"
)
column.set_fixed_width(int(width) if width else default_width)
self.append_column(column)
column.connect("notify::width", self.on_column_width_changed)
return column
def esync_display_version_warning(on_launch=False):
setting = "hide-wine-non-esync-version-warning"
if on_launch:
checkbox_message = "Launch anyway and do not show this message again."
else:
checkbox_message = "Enable anyway and do not show this message again."
DontShowAgainDialog(
setting,
"Incompatible Wine version detected",
secondary_message="The wine build you have selected "
"does not seem to support Esync.\n"
"Please switch to an esync-capable version such as wine-tkg.",
checkbox_message=checkbox_message,
)
return settings.read_setting(setting) == "True"
def display_vulkan_error(on_launch):
if on_launch:
checkbox_message = "Launch anyway and do not show this message again."
else:
checkbox_message = "Enable anyway and do not show this message again."
setting = "hide-no-vulkan-warning"
DontShowAgainDialog(
setting,
"Vulkan is not installed or is not supported by your system",
secondary_message="If you have compatible hardware, please follow "
"the installation procedures as described in\n"
"<a href='https://github.com/lutris/lutris/wiki/How-to:-DXVK'>"
"How-to:-DXVK (https://github.com/lutris/lutris/wiki/How-to:-DXVK)</a>",
checkbox_message=checkbox_message,
)
return settings.read_setting(setting) == "True"
def check_driver():
"""Report on the currently running driver"""
driver_info = {}
if drivers.is_nvidia():
driver_info = drivers.get_nvidia_driver_info()
# pylint: disable=logging-format-interpolation
logger.info("Using {vendor} drivers {version} for {arch}".format(**driver_info["nvrm"]))
gpus = drivers.get_nvidia_gpu_ids()
for gpu_id in gpus:
gpu_info = drivers.get_nvidia_gpu_info(gpu_id)
logger.info("GPU: %s", gpu_info.get("Model"))
elif LINUX_SYSTEM.glxinfo:
logger.info("Using %s", LINUX_SYSTEM.glxinfo.opengl_vendor)
if hasattr(LINUX_SYSTEM.glxinfo, "GLX_MESA_query_renderer"):
logger.info(
"Running Mesa driver %s on %s",
LINUX_SYSTEM.glxinfo.GLX_MESA_query_renderer.version,
LINUX_SYSTEM.glxinfo.GLX_MESA_query_renderer.device,
)
else:
logger.warning("glxinfo is not available on your system, unable to detect driver version")
for card in drivers.get_gpus():
# pylint: disable=logging-format-interpolation
try:
logger.info(
"GPU: {PCI_ID} {PCI_SUBSYS_ID} using {DRIVER} drivers".format(
**drivers.get_gpu_info(card)
)
)
except KeyError:
logger.error("Unable to get GPU information from '%s'", card)
if drivers.is_outdated():
setting = "hide-outdated-nvidia-driver-warning"
if settings.read_setting(setting) != "True":
DontShowAgainDialog(
setting,
"Your Nvidia driver is outdated.",
secondary_message="You are currently running driver %s which does not "
"fully support all features for Vulkan and DXVK games.\n"
"Please upgrade your driver as described in our "
"<a href='https://github.com/lutris/lutris/wiki/Installing-drivers'>"
"installation guide</a>"
% driver_info["nvrm"]["version"]
)
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 __init__(
self,
setting,
message,
secondary_message=None,
parent=None,
checkbox_message=None,
):
if settings.read_setting(setting) == "True":
logger.info("Dialog %s dismissed by user", setting)
return
super().__init__(
type=Gtk.MessageType.WARNING, buttons=Gtk.ButtonsType.OK, parent=parent
)
self.set_border_width(12)
self.set_markup("<b>%s</b>" % message)
if secondary_message:
self.props.secondary_use_markup = True
self.props.secondary_text = secondary_message
if not checkbox_message:
checkbox_message = "Do not display this message again."
dont_show_checkbutton = Gtk.CheckButton(checkbox_message)
dont_show_checkbutton.props.halign = Gtk.Align.CENTER
dont_show_checkbutton.show()
content_area = self.get_content_area()
content_area.pack_start(dont_show_checkbutton, False, False, 0)
self.run()
if dont_show_checkbutton.get_active():
settings.write_setting(setting, True)
self.destroy()
def __init__(self, application, **kwargs):
self.application = application
self.runtime_updater = RuntimeUpdater()
self.running_game = None
self.threads_stoppers = []
# Emulate double click to workaround GTK bug #484640
# https://bugzilla.gnome.org/show_bug.cgi?id=484640
self.game_selection_time = 0
self.game_launch_time = 0
self.last_selected_game = None
self.selected_runner = None
self.selected_platform = None
self.icon_type = None
# Load settings
width = int(settings.read_setting('width') or 800)
height = int(settings.read_setting('height') or 600)
self.window_size = (width, height)
self.maximized = settings.read_setting('maximized') == 'True'
view_type = self.get_view_type()
self.load_icon_type_from_settings(view_type)
self.filter_installed = settings.read_setting(
'filter_installed') == 'true'
self.show_installed_first = \
settings.read_setting('show_installed_first') == 'true'
self.sidebar_visible = \
settings.read_setting('sidebar_visible') in ['true', None]
self.sidebar_width = int(settings.read_setting('sidebar_width') or 180)
self.use_dark_theme = settings.read_setting(
'dark_theme', default='false').lower() == 'true'
self.show_tray_icon = settings.read_setting(
'show_tray_icon', default='false').lower() == 'true'
# Sync local lutris library with current Steam games and desktop games
for service in get_services_synced_at_startup():
service.sync_with_lutris()
# Window initialization
self.game_list = pga.get_games(
show_installed_first=self.show_installed_first)
self.game_store = GameStore([], self.icon_type, self.filter_installed,
self.show_installed_first)
self.view = self.get_view(view_type)
super().__init__(default_width=width,
default_height=height,
icon_name='lutris',
application=application,
**kwargs)
if self.maximized:
self.maximize()
self.init_template()
self._init_actions()
# Set theme to dark if set in the settings
self.set_dark_theme(self.use_dark_theme)
# Load view
self.games_scrollwindow.add(self.view)
self.connect_signals()
self.view.show()
# Contextual menu
main_entries = [
('play', "Play", self.on_game_run),
('install', "Install", self.on_install_clicked),
('add', "Add manually", self.on_add_manually),
('configure', "Configure", self.on_edit_game_configuration),
('execute-script', "Execute script",
self.on_execute_script_clicked),
('browse', "Browse files", self.on_browse_files),
('desktop-shortcut', "Create desktop shortcut",
self.create_desktop_shortcut),
('rm-desktop-shortcut', "Delete desktop shortcut",
self.remove_desktop_shortcut),
('menu-shortcut', "Create application menu shortcut",
self.create_menu_shortcut),
('rm-menu-shortcut', "Delete application menu shortcut",
self.remove_menu_shortcut),
('install_more', "Install (add) another version",
self.on_install_clicked),
('remove', "Remove", self.on_remove_game),
('view', "View on Lutris.net", self.on_view_game),
]
self.menu = ContextualMenu(main_entries)
self.view.contextual_menu = self.menu
# Sidebar
self.sidebar_treeview = SidebarTreeView()
self.sidebar_treeview.connect('cursor-changed',
self.on_sidebar_changed)
self.sidebar_viewport.add(self.sidebar_treeview)
self.sidebar_treeview.show()
self.game_store.fill_store(self.game_list)
self.switch_splash_screen()
self.show_sidebar()
self.update_runtime()
# Connect account and/or sync
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials)
else:
self.toggle_connection(False)
self.sync_library()
# Timers
self.timer_ids = [GLib.timeout_add(300, self.refresh_status)]
steamapps_paths = steam.get_steamapps_paths(flat=True)
self.steam_watcher = SteamWatcher(steamapps_paths,
self.on_steam_game_changed)
self.gui_needs_update = True
self.config_menu_first_access = True
def get_view_type():
"""Return the type of view saved by the user"""
view_type = settings.read_setting('view_type')
if view_type in ['grid', 'list']:
return view_type
return settings.GAME_VIEW
def show_tray_icon(self):
"""Setting to hide or show status icon"""
return settings.read_setting("show_tray_icon",
default="false").lower() == "true"
def show_installed_first(self):
return settings.read_setting("show_installed_first") == "true"
def view_sorting(self):
return settings.read_setting("view_sorting") or "name"
def generate_widgets(self, config_section):
"""Parse the config dict and generates widget accordingly."""
if not self.options:
no_options_label = Label("No options available")
no_options_label.set_halign(Gtk.Align.CENTER)
no_options_label.set_valign(Gtk.Align.CENTER)
self.pack_start(no_options_label, True, True, 0)
return
# Select config section.
if config_section == "game":
self.config = self.lutris_config.game_config
self.raw_config = self.lutris_config.raw_game_config
elif config_section == "runner":
self.config = self.lutris_config.runner_config
self.raw_config = self.lutris_config.raw_runner_config
elif config_section == "system":
self.config = self.lutris_config.system_config
self.raw_config = self.lutris_config.raw_system_config
# Go thru all options.
for option in self.options:
if "scope" in option:
if config_section not in option["scope"]:
continue
option_key = option["option"]
value = self.config.get(option_key)
default = option.get("default")
if callable(option.get("choices")):
option["choices"] = option["choices"]()
if callable(option.get("condition")):
option["condition"] = option["condition"]()
self.wrapper = Gtk.Box()
self.wrapper.set_spacing(12)
self.wrapper.set_margin_bottom(6)
# Set tooltip's "Default" part
default = option.get("default")
self.tooltip_default = default if isinstance(default, str) else None
# Generate option widget
self.option_widget = None
self.call_widget_generator(option, option_key, value, default)
# Reset button
reset_btn = Gtk.Button.new_from_icon_name("edit-clear", Gtk.IconSize.MENU)
reset_btn.set_relief(Gtk.ReliefStyle.NONE)
reset_btn.set_tooltip_text("Reset option to global or " "default config")
reset_btn.connect(
"clicked",
self.on_reset_button_clicked,
option,
self.option_widget,
self.wrapper,
)
placeholder = Gtk.Box()
placeholder.set_size_request(32, 32)
if option_key not in self.raw_config:
reset_btn.set_visible(False)
reset_btn.set_no_show_all(True)
placeholder.pack_start(reset_btn, False, False, 0)
# Tooltip
helptext = option.get("help")
if isinstance(self.tooltip_default, str):
helptext = helptext + "\n\n" if helptext else ""
helptext += "<b>Default</b>: " + self.tooltip_default
if value != default and option_key not in self.raw_config:
helptext = helptext + "\n\n" if helptext else ""
helptext += (
"<i>(Italic indicates that this option is "
"modified in a lower configuration level.)</i>"
)
if helptext:
self.wrapper.props.has_tooltip = True
self.wrapper.connect("query-tooltip", self.on_query_tooltip, helptext)
hbox = Gtk.Box()
hbox.set_margin_left(18)
hbox.pack_end(placeholder, False, False, 5)
# Grey out option if condition unmet
if "condition" in option and not option["condition"]:
hbox.set_sensitive(False)
# Hide if advanced
if option.get("advanced"):
hbox.get_style_context().add_class("advanced")
show_advanced = settings.read_setting("show_advanced_options")
if not show_advanced == "True":
hbox.set_no_show_all(True)
hbox.pack_start(self.wrapper, True, True, 0)
self.pack_start(hbox, False, False, 0)
def __init__(self):
ui_filename = os.path.join(datapath.get(), "ui", "LutrisWindow.ui")
if not os.path.exists(ui_filename):
raise IOError("File %s not found" % ui_filename)
self.running_game = None
self.threads_stoppers = []
# Emulate double click to workaround GTK bug #484640
# https://bugzilla.gnome.org/show_bug.cgi?id=484640
self.game_selection_time = 0
self.game_launch_time = 0
self.last_selected_game = None
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_filename)
# Load settings
width = int(settings.read_setting("width") or 800)
height = int(settings.read_setting("height") or 600)
self.window_size = (width, height)
view_type = self.get_view_type()
self.icon_type = self.get_icon_type(view_type)
filter_installed_setting = settings.read_setting("filter_installed") or "false"
filter_installed = filter_installed_setting == "true"
show_installed_games_menuitem = self.builder.get_object("filter_installed")
show_installed_games_menuitem.set_active(filter_installed)
# Load view
logger.debug("Loading view")
self.game_store = GameStore([], self.icon_type, filter_installed)
self.view = load_view(view_type, self.game_store)
logger.debug("Connecting signals")
self.main_box = self.builder.get_object("main_box")
self.splash_box = self.builder.get_object("splash_box")
# View menu
self.grid_view_menuitem = self.builder.get_object("gridview_menuitem")
self.grid_view_menuitem.set_active(view_type == "grid")
self.list_view_menuitem = self.builder.get_object("listview_menuitem")
self.list_view_menuitem.set_active(view_type == "list")
# View buttons
self.grid_view_btn = self.builder.get_object("switch_grid_view_btn")
self.grid_view_btn.set_active(view_type == "grid")
self.list_view_btn = self.builder.get_object("switch_list_view_btn")
self.list_view_btn.set_active(view_type == "list")
# Icon type menu
self.banner_small_menuitem = self.builder.get_object("banner_small_menuitem")
self.banner_small_menuitem.set_active(self.icon_type == "banner_small")
self.banner_menuitem = self.builder.get_object("banner_menuitem")
self.banner_menuitem.set_active(self.icon_type == "banner")
self.icon_menuitem = self.builder.get_object("icon_menuitem")
self.icon_menuitem.set_active(self.icon_type == "icon")
self.search_entry = self.builder.get_object("search_entry")
self.search_entry.connect("icon-press", self.on_clear_search)
# Scroll window
self.games_scrollwindow = self.builder.get_object("games_scrollwindow")
self.games_scrollwindow.add(self.view)
# Status bar
self.status_label = self.builder.get_object("status_label")
self.joystick_icons = []
# Buttons
self.stop_button = self.builder.get_object("stop_button")
self.stop_button.set_sensitive(False)
self.delete_button = self.builder.get_object("delete_button")
self.delete_button.set_sensitive(False)
self.play_button = self.builder.get_object("play_button")
self.play_button.set_sensitive(False)
# Contextual menu
main_entries = [
("play", "Play", self.on_game_run),
("install", "Install", self.on_install_clicked),
("add", "Add manually", self.add_manually),
("configure", "Configure", self.edit_game_configuration),
("browse", "Browse files", self.on_browse_files),
("desktop-shortcut", "Create desktop shortcut", self.create_desktop_shortcut),
("rm-desktop-shortcut", "Delete desktop shortcut", self.remove_desktop_shortcut),
("menu-shortcut", "Create application menu shortcut", self.create_menu_shortcut),
("rm-menu-shortcut", "Delete application menu shortcut", self.remove_menu_shortcut),
("remove", "Remove", self.on_remove_game),
]
self.menu = ContextualMenu(main_entries)
self.view.contextual_menu = self.menu
# Sidebar
sidebar_paned = self.builder.get_object("sidebar_paned")
sidebar_paned.set_position(150)
self.sidebar_treeview = SidebarTreeView()
self.sidebar_treeview.connect("cursor-changed", self.on_sidebar_changed)
self.sidebar_viewport = self.builder.get_object("sidebar_viewport")
self.sidebar_viewport.add(self.sidebar_treeview)
# Window initialization
self.window = self.builder.get_object("window")
self.window.resize_to_geometry(width, height)
self.window.show_all()
self.builder.connect_signals(self)
self.connect_signals()
# XXX Hide PGA config menu item until it actually gets implemented
pga_menuitem = self.builder.get_object("pga_menuitem")
pga_menuitem.hide()
self.init_game_store()
# Connect account and/or sync
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials)
else:
self.toggle_connection(False)
self.sync_library()
# Timers
self.timer_ids = [GLib.timeout_add(300, self.refresh_status), GLib.timeout_add(10000, self.on_sync_timer)]
def __init__(self, service=None):
Gtk.Application.__init__(
self, application_id="net.lutris.main",
flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE
)
ui_filename = os.path.join(
datapath.get(), 'ui', 'lutris-window.ui'
)
if not os.path.exists(ui_filename):
raise IOError('File %s not found' % ui_filename)
self.service = service
self.runtime_updater = RuntimeUpdater()
self.running_game = None
self.threads_stoppers = []
# Emulate double click to workaround GTK bug #484640
# https://bugzilla.gnome.org/show_bug.cgi?id=484640
self.game_selection_time = 0
self.game_launch_time = 0
self.last_selected_game = None
self.selected_runner = None
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_filename)
# Load settings
width = int(settings.read_setting('width') or 800)
height = int(settings.read_setting('height') or 600)
self.window_size = (width, height)
window = self.builder.get_object('window')
window.resize(width, height)
view_type = self.get_view_type()
self.load_icon_type_from_settings(view_type)
self.filter_installed = \
settings.read_setting('filter_installed') == 'true'
self.sidebar_visible = \
settings.read_setting('sidebar_visible') in ['true', None]
# Set theme to dark if set in the settings
dark_theme_menuitem = self.builder.get_object('dark_theme_menuitem')
use_dark_theme = settings.read_setting('dark_theme') == 'true'
dark_theme_menuitem.set_active(use_dark_theme)
self.set_dark_theme(use_dark_theme)
self.game_list = pga.get_games()
# Load view
self.game_store = GameStore([], self.icon_type, self.filter_installed)
self.view = self.get_view(view_type)
self.main_box = self.builder.get_object('main_box')
self.splash_box = self.builder.get_object('splash_box')
self.connect_link = self.builder.get_object('connect_link')
# View menu
installed_games_only_menuitem =\
self.builder.get_object('filter_installed')
installed_games_only_menuitem.set_active(self.filter_installed)
self.grid_view_menuitem = self.builder.get_object("gridview_menuitem")
self.grid_view_menuitem.set_active(view_type == 'grid')
self.list_view_menuitem = self.builder.get_object("listview_menuitem")
self.list_view_menuitem.set_active(view_type == 'list')
sidebar_menuitem = self.builder.get_object('sidebar_menuitem')
sidebar_menuitem.set_active(self.sidebar_visible)
# View buttons
self.grid_view_btn = self.builder.get_object('switch_grid_view_btn')
self.grid_view_btn.set_active(view_type == 'grid')
self.list_view_btn = self.builder.get_object('switch_list_view_btn')
self.list_view_btn.set_active(view_type == 'list')
# Icon type menu
self.banner_small_menuitem = \
self.builder.get_object('banner_small_menuitem')
self.banner_small_menuitem.set_active(self.icon_type == 'banner_small')
self.banner_menuitem = self.builder.get_object('banner_menuitem')
self.banner_menuitem.set_active(self.icon_type == 'banner')
self.icon_menuitem = self.builder.get_object('icon_menuitem')
self.icon_menuitem.set_active(self.icon_type == 'icon')
self.search_entry = self.builder.get_object('search_entry')
self.search_entry.connect('icon-press', self.on_clear_search)
# Scroll window
self.games_scrollwindow = self.builder.get_object('games_scrollwindow')
self.games_scrollwindow.add(self.view)
# Buttons
self.stop_button = self.builder.get_object('stop_button')
self.stop_button.set_sensitive(False)
self.delete_button = self.builder.get_object('delete_button')
self.delete_button.set_sensitive(False)
self.play_button = self.builder.get_object('play_button')
self.play_button.set_sensitive(False)
# Contextual menu
main_entries = [
('play', "Play", self.on_game_run),
('install', "Install", self.on_install_clicked),
('add', "Add manually", self.on_add_manually),
('configure', "Configure", self.on_edit_game_configuration),
('browse', "Browse files", self.on_browse_files),
('desktop-shortcut', "Create desktop shortcut",
self.create_desktop_shortcut),
('rm-desktop-shortcut', "Delete desktop shortcut",
self.remove_desktop_shortcut),
('menu-shortcut', "Create application menu shortcut",
self.create_menu_shortcut),
('rm-menu-shortcut', "Delete application menu shortcut",
self.remove_menu_shortcut),
('install_more', "Install (add) another version", self.on_install_clicked),
('remove', "Remove", self.on_remove_game),
]
self.menu = ContextualMenu(main_entries)
self.view.contextual_menu = self.menu
# Sidebar
self.sidebar_paned = self.builder.get_object('sidebar_paned')
self.sidebar_treeview = SidebarTreeView()
self.sidebar_treeview.connect('cursor-changed', self.on_sidebar_changed)
self.sidebar_viewport = self.builder.get_object('sidebar_viewport')
self.sidebar_viewport.add(self.sidebar_treeview)
# Window initialization
self.window = self.builder.get_object("window")
self.window.resize_to_geometry(width, height)
self.window.set_default_icon_name('lutris')
self.window.show_all()
self.builder.connect_signals(self)
self.connect_signals()
self.statusbar = self.builder.get_object("statusbar")
# XXX Hide PGA config menu item until it actually gets implemented
pga_menuitem = self.builder.get_object('pga_menuitem')
pga_menuitem.hide()
# Sync local lutris library with current Steam games before setting up
# view
steam.sync_with_lutris()
self.game_store.fill_store(self.game_list)
self.switch_splash_screen()
self.show_sidebar()
self.update_runtime()
# Connect account and/or sync
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials)
else:
self.toggle_connection(False)
self.sync_library()
# Timers
self.timer_ids = [GLib.timeout_add(300, self.refresh_status)]
steamapps_paths = steam.get_steamapps_paths(flat=True)
self.steam_watcher = steam.SteamWatcher(steamapps_paths,
self.on_steam_game_changed)
def get_enabled_services():
return {
key: _class
for key, _class in SERVICES.items()
if settings.read_setting(key, section="services").lower() == "true"
}
def filter_installed(self):
return settings.read_setting("filter_installed").lower() == "true"
def view_type(self):
"""Return the type of view saved by the user"""
view_type = settings.read_setting("view_type")
if view_type in ["grid", "list"]:
return view_type
return self.default_view_type
def view_sorting_ascending(self):
return settings.read_setting(
"view_sorting_ascending").lower() != "false"
def get_view_type(self):
view_type = settings.read_setting("view_type")
if view_type in ["grid", "list"]:
return view_type
return settings.GAME_VIEW
def generate_widgets(self, config_section):
"""Parse the config dict and generates widget accordingly."""
if not self.options:
label = Label("No options available")
label.set_halign(Gtk.Align.CENTER)
label.set_valign(Gtk.Align.CENTER)
self.pack_start(label, True, True, 0)
return
# Select config section.
if config_section == 'game':
self.config = self.lutris_config.game_config
self.raw_config = self.lutris_config.raw_game_config
elif config_section == 'runner':
self.config = self.lutris_config.runner_config
self.raw_config = self.lutris_config.raw_runner_config
elif config_section == 'system':
self.config = self.lutris_config.system_config
self.raw_config = self.lutris_config.raw_system_config
# Go thru all options.
for option in self.options:
if 'scope' in option:
if config_section not in option['scope']:
continue
option_key = option['option']
value = self.config.get(option_key)
default = option.get('default')
if callable(option.get('choices')):
option['choices'] = option['choices']()
if callable(option.get('condition')):
option['condition'] = option['condition']()
hbox = Gtk.HBox()
hbox.set_margin_left(20)
self.wrapper = Gtk.HBox()
self.wrapper.set_spacing(20)
placeholder = Gtk.HBox()
placeholder.set_size_request(32, 32)
hbox.pack_end(placeholder, False, False, 5)
# Set tooltip's "Default" part
default = option.get('default')
self.tooltip_default = default if type(default) is str else None
# Generate option widget
self.option_widget = None
self.call_widget_generator(option, option_key, value, default)
# Reset button
reset_btn = Gtk.Button.new_from_icon_name('edit-clear',
Gtk.IconSize.MENU)
reset_btn.set_relief(Gtk.ReliefStyle.NONE)
reset_btn.set_tooltip_text("Reset option to global or "
"default config")
reset_btn.connect('clicked', self.on_reset_button_clicked,
option, self.option_widget, self.wrapper)
if option_key not in self.raw_config:
reset_btn.set_visible(False)
reset_btn.set_no_show_all(True)
placeholder.pack_start(reset_btn, False, False, 0)
# Tooltip
helptext = option.get("help")
if type(self.tooltip_default) is str:
helptext = helptext + '\n\n' if helptext else ''
helptext += "<b>Default</b>: " + self.tooltip_default
if value != default and option_key not in self.raw_config:
helptext = helptext + '\n\n' if helptext else ''
helptext += ("<i>(Italic indicates that this option is "
"modified in a lower configuration level.)</i>")
if helptext:
self.wrapper.props.has_tooltip = True
self.wrapper.connect('query-tooltip', self.on_query_tooltip,
helptext)
# Grey out option if condition unmet
if 'condition' in option and not option['condition']:
hbox.set_sensitive(False)
# Hide if advanced
if option.get('advanced'):
hbox.get_style_context().add_class('advanced')
show_advanced = settings.read_setting('show_advanced_options')
if not show_advanced == 'True':
hbox.set_no_show_all(True)
hbox.pack_start(self.wrapper, True, True, 0)
self.pack_start(hbox, False, False, 5)
def get_cache_path():
"""Return the path of the PGA cache"""
pga_cache_path = settings.read_setting("pga_cache_path")
if pga_cache_path:
return os.path.expanduser(pga_cache_path)
return None
def on_game_start(self, game):
self.running_games.append(game)
if settings.read_setting("hide_client_on_game_start") == "True":
self.window.hide() # Hide launcher window
return True
def sidebar_visible(self):
return settings.read_setting("sidebar_visible") in [
"true",
None,
]
def __init__(self, service=None):
Gtk.Application.__init__(
self,
application_id="net.lutris.main",
flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE)
ui_filename = os.path.join(datapath.get(), 'ui', 'lutris-window.ui')
if not os.path.exists(ui_filename):
raise IOError('File %s not found' % ui_filename)
self.service = service
self.runtime_updater = RuntimeUpdater()
self.running_game = None
self.threads_stoppers = []
# Emulate double click to workaround GTK bug #484640
# https://bugzilla.gnome.org/show_bug.cgi?id=484640
self.game_selection_time = 0
self.game_launch_time = 0
self.last_selected_game = None
self.selected_runner = None
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_filename)
# Load settings
width = int(settings.read_setting('width') or 800)
height = int(settings.read_setting('height') or 600)
self.window_size = (width, height)
window = self.builder.get_object('window')
window.resize(width, height)
view_type = self.get_view_type()
self.load_icon_type_from_settings(view_type)
self.filter_installed = \
settings.read_setting('filter_installed') == 'true'
self.sidebar_visible = \
settings.read_setting('sidebar_visible') in ['true', None]
# Set theme to dark if set in the settings
dark_theme_menuitem = self.builder.get_object('dark_theme_menuitem')
use_dark_theme = settings.read_setting('dark_theme') == 'true'
dark_theme_menuitem.set_active(use_dark_theme)
self.set_dark_theme(use_dark_theme)
self.game_list = pga.get_games()
# Load view
self.game_store = GameStore([], self.icon_type, self.filter_installed)
self.view = self.get_view(view_type)
self.main_box = self.builder.get_object('main_box')
self.splash_box = self.builder.get_object('splash_box')
self.connect_link = self.builder.get_object('connect_link')
# View menu
installed_games_only_menuitem =\
self.builder.get_object('filter_installed')
installed_games_only_menuitem.set_active(self.filter_installed)
self.grid_view_menuitem = self.builder.get_object("gridview_menuitem")
self.grid_view_menuitem.set_active(view_type == 'grid')
self.list_view_menuitem = self.builder.get_object("listview_menuitem")
self.list_view_menuitem.set_active(view_type == 'list')
sidebar_menuitem = self.builder.get_object('sidebar_menuitem')
sidebar_menuitem.set_active(self.sidebar_visible)
# View buttons
self.grid_view_btn = self.builder.get_object('switch_grid_view_btn')
self.grid_view_btn.set_active(view_type == 'grid')
self.list_view_btn = self.builder.get_object('switch_list_view_btn')
self.list_view_btn.set_active(view_type == 'list')
# Icon type menu
self.banner_small_menuitem = \
self.builder.get_object('banner_small_menuitem')
self.banner_small_menuitem.set_active(self.icon_type == 'banner_small')
self.banner_menuitem = self.builder.get_object('banner_menuitem')
self.banner_menuitem.set_active(self.icon_type == 'banner')
self.icon_menuitem = self.builder.get_object('icon_menuitem')
self.icon_menuitem.set_active(self.icon_type == 'icon')
self.search_entry = self.builder.get_object('search_entry')
self.search_entry.connect('icon-press', self.on_clear_search)
# Scroll window
self.games_scrollwindow = self.builder.get_object('games_scrollwindow')
self.games_scrollwindow.add(self.view)
# Buttons
self.stop_button = self.builder.get_object('stop_button')
self.stop_button.set_sensitive(False)
self.delete_button = self.builder.get_object('delete_button')
self.delete_button.set_sensitive(False)
self.play_button = self.builder.get_object('play_button')
self.play_button.set_sensitive(False)
# Contextual menu
main_entries = [
('play', "Play", self.on_game_run),
('install', "Install", self.on_install_clicked),
('add', "Add manually", self.on_add_manually),
('configure', "Configure", self.on_edit_game_configuration),
('browse', "Browse files", self.on_browse_files),
('desktop-shortcut', "Create desktop shortcut",
self.create_desktop_shortcut),
('rm-desktop-shortcut', "Delete desktop shortcut",
self.remove_desktop_shortcut),
('menu-shortcut', "Create application menu shortcut",
self.create_menu_shortcut),
('rm-menu-shortcut', "Delete application menu shortcut",
self.remove_menu_shortcut),
('install_more', "Install (add) another version",
self.on_install_clicked),
('remove', "Remove", self.on_remove_game),
]
self.menu = ContextualMenu(main_entries)
self.view.contextual_menu = self.menu
# Sidebar
self.sidebar_paned = self.builder.get_object('sidebar_paned')
self.sidebar_treeview = SidebarTreeView()
self.sidebar_treeview.connect('cursor-changed',
self.on_sidebar_changed)
self.sidebar_viewport = self.builder.get_object('sidebar_viewport')
self.sidebar_viewport.add(self.sidebar_treeview)
# Window initialization
self.window = self.builder.get_object("window")
self.window.resize_to_geometry(width, height)
self.window.set_default_icon_name('lutris')
self.window.show_all()
self.builder.connect_signals(self)
self.connect_signals()
self.statusbar = self.builder.get_object("statusbar")
# XXX Hide PGA config menu item until it actually gets implemented
pga_menuitem = self.builder.get_object('pga_menuitem')
pga_menuitem.hide()
# Sync local lutris library with current Steam games before setting up
# view
steam.sync_with_lutris()
self.game_store.fill_store(self.game_list)
self.switch_splash_screen()
self.show_sidebar()
self.update_runtime()
# Connect account and/or sync
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials)
else:
self.toggle_connection(False)
self.sync_library()
# Timers
self.timer_ids = [GLib.timeout_add(300, self.refresh_status)]
steamapps_paths = steam.get_steamapps_paths(flat=True)
self.steam_watcher = steam.SteamWatcher(steamapps_paths,
self.on_steam_game_changed)
def show_tray_icon(self):
return settings.read_setting("show_tray_icon",
default="false").lower() == "true"
def get_view_type(self):
view_type = settings.read_setting('view_type')
if view_type in ['grid', 'list']:
return view_type
return settings.GAME_VIEW
def __init__(self, application, **kwargs):
width = int(settings.read_setting("width") or self.default_width)
height = int(settings.read_setting("height") or self.default_height)
super().__init__(default_width=width,
default_height=height,
icon_name="lutris",
application=application,
**kwargs)
self.application = application
self.runtime_updater = RuntimeUpdater()
self.threads_stoppers = []
self.selected_runner = None
self.selected_platform = None
self.icon_type = None
# Load settings
self.window_size = (width, height)
self.maximized = settings.read_setting("maximized") == "True"
view_type = self.get_view_type()
self.load_icon_type_from_settings(view_type)
# Window initialization
self.game_actions = GameActions(application=application, window=self)
self.search_terms = None
self.game_store = self.get_store()
self.view = self.get_view(view_type)
GObject.add_emission_hook(Game, "game-updated", self.on_game_updated)
GObject.add_emission_hook(GenericPanel, "game-searched",
self.on_game_searched)
GObject.add_emission_hook(GenericPanel, "running-game-selected",
self.game_selection_changed)
self.connect("delete-event", self.on_window_delete)
if self.maximized:
self.maximize()
self.init_template()
self._init_actions()
self._bind_zoom_adjustment()
# Load view
self.games_scrollwindow.add(self.view)
self._connect_signals()
# Set theme to dark if set in the settings
self.set_dark_theme()
self.set_viewtype_icon(view_type)
# Add additional widgets
self.sidebar_listbox = SidebarListBox()
self.sidebar_listbox.set_size_request(250, -1)
self.sidebar_listbox.connect("selected-rows-changed",
self.on_sidebar_changed)
self.sidebar_scrolled.add(self.sidebar_listbox)
self.game_panel = GenericPanel(application=self.application)
self.game_scrolled = Gtk.ScrolledWindow(visible=True)
self.game_scrolled.set_size_request(320, -1)
self.game_scrolled.get_style_context().add_class("game-scrolled")
self.game_scrolled.set_policy(Gtk.PolicyType.EXTERNAL,
Gtk.PolicyType.EXTERNAL)
self.game_scrolled.add(self.game_panel)
self.panel_revealer = Gtk.Revealer(visible=True)
self.panel_revealer.set_transition_duration(300)
self.panel_revealer.set_transition_type(
Gtk.RevealerTransitionType.SLIDE_LEFT)
self.panel_revealer.set_reveal_child(True)
self.panel_revealer.add(self.game_scrolled)
self.main_box.pack_end(self.panel_revealer, False, False, 0)
self.view.show()
self.game_store.load()
# Contextual menu
self.view.contextual_menu = ContextualMenu(
self.game_actions.get_game_actions())
# Sidebar
self.sidebar_revealer.set_reveal_child(self.sidebar_visible)
self.sidebar_revealer.set_transition_duration(300)
self.update_runtime()
# Connect account and/or sync
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials["username"])
else:
self.toggle_connection(False)
self.sync_library()
self.sync_services()
def __init__(self):
ui_filename = os.path.join(datapath.get(), 'ui', 'LutrisWindow.ui')
if not os.path.exists(ui_filename):
raise IOError('File %s not found' % ui_filename)
# Currently running game
self.running_game = None
# Emulate double click to workaround GTK bug #484640
# https://bugzilla.gnome.org/show_bug.cgi?id=484640
self.game_selection_time = 0
self.game_launch_time = 0
self.last_selected_game = None
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_filename)
# load config
width = int(settings.read_setting('width') or 800)
height = int(settings.read_setting('height') or 600)
self.window_size = (width, height)
view_type = self.get_view_type()
self.icon_type = self.get_icon_type(view_type)
filter_installed_setting = settings.read_setting(
'filter_installed') or 'false'
self.filter_installed = filter_installed_setting == 'true'
show_installed_games_menuitem = self.builder.get_object(
'filter_installed')
show_installed_games_menuitem.set_active(self.filter_installed)
logger.debug("Getting game list")
game_list = get_game_list(self.filter_installed)
logger.debug("Switching view")
self.view = load_view(view_type, game_list, icon_type=self.icon_type)
logger.debug("Connecting signals")
self.main_box = self.builder.get_object('main_box')
self.splash_box = self.builder.get_object('splash_box')
# View menu
self.grid_view_menuitem = self.builder.get_object("gridview_menuitem")
self.grid_view_menuitem.set_active(view_type == 'grid')
self.list_view_menuitem = self.builder.get_object("listview_menuitem")
self.list_view_menuitem.set_active(view_type == 'list')
# View buttons
self.grid_view_btn = self.builder.get_object('switch_grid_view_btn')
self.grid_view_btn.set_active(view_type == 'grid')
self.list_view_btn = self.builder.get_object('switch_list_view_btn')
self.list_view_btn.set_active(view_type == 'list')
# Icon type menu
self.banner_small_menuitem = \
self.builder.get_object('banner_small_menuitem')
self.banner_small_menuitem.set_active(self.icon_type == 'banner_small')
self.banner_menuitem = self.builder.get_object('banner_menuitem')
self.banner_menuitem.set_active(self.icon_type == 'banner')
self.icon_menuitem = self.builder.get_object('icon_menuitem')
self.icon_menuitem.set_active(self.icon_type == 'grid')
self.search_entry = self.builder.get_object('search_entry')
# Scroll window
self.games_scrollwindow = self.builder.get_object('games_scrollwindow')
self.games_scrollwindow.add(self.view)
# Status bar
self.status_label = self.builder.get_object('status_label')
self.joystick_icons = []
# Buttons
self.stop_button = self.builder.get_object('stop_button')
self.stop_button.set_sensitive(False)
self.delete_button = self.builder.get_object('delete_button')
self.delete_button.set_sensitive(False)
self.play_button = self.builder.get_object('play_button')
self.play_button.set_sensitive(False)
# Contextual menu
menu_callbacks = [
('play', self.on_game_clicked),
('install', self.on_game_clicked),
('add', self.add_manually),
('configure', self.edit_game_configuration),
('browse', self.on_browse_files),
('desktop-shortcut', self.create_desktop_shortcut),
('menu-shortcut', self.create_menu_shortcut),
('remove', self.on_remove_game),
]
self.menu = ContextualMenu(menu_callbacks)
self.view.contextual_menu = self.menu
# Timer
self.timer_id = GLib.timeout_add(2000, self.refresh_status)
sidebar_paned = self.builder.get_object('sidebar_paned')
sidebar_paned.set_position(150)
sidebar_treeview = SidebarTreeView()
sidebar_treeview.connect('cursor-changed', self.on_sidebar_changed)
self.sidebar_viewport = self.builder.get_object('sidebar_viewport')
self.sidebar_viewport.add(sidebar_treeview)
# Window initialization
self.window = self.builder.get_object("window")
self.window.resize_to_geometry(width, height)
self.window.show_all()
self.builder.connect_signals(self)
self.connect_signals()
# XXX Hide PGA config menu item until it actually gets implemented
pga_menuitem = self.builder.get_object('pga_menuitem')
pga_menuitem.hide()
self.switch_splash_screen()
credentials = api.read_api_key()
if credentials:
self.on_connect_success(None, credentials)
else:
self.toggle_connection(False)
sync = Sync()
async_call(sync.sync_steam_local,
lambda r, e: async_call(self.sync_icons, None),
caller=self)
# Update Lutris Runtime
async_call(runtime.update_runtime, None)
def current_view_type(self):
"""Returns which kind of view is currently presented (grid or list)"""
return settings.read_setting("view_type") or "grid"
def side_panel_visible(self):
return settings.read_setting("side_panel_visible").lower() != "false"
def use_dark_theme(self):
"""Return whether to use the dark theme variant (if the theme provides one)"""
return settings.read_setting("dark_theme",
default="false").lower() == "true"
def generate_widgets(self, config_section):
"""Parse the config dict and generates widget accordingly."""
if not self.options:
label = Label("No options available")
label.set_halign(Gtk.Align.CENTER)
label.set_valign(Gtk.Align.CENTER)
self.pack_start(label, True, True, 0)
return
# Select config section.
if config_section == 'game':
self.config = self.lutris_config.game_config
self.raw_config = self.lutris_config.raw_game_config
elif config_section == 'runner':
self.config = self.lutris_config.runner_config
self.raw_config = self.lutris_config.raw_runner_config
elif config_section == 'system':
self.config = self.lutris_config.system_config
self.raw_config = self.lutris_config.raw_system_config
# Go thru all options.
for option in self.options:
if 'scope' in option:
if config_section not in option['scope']:
continue
option_key = option['option']
value = self.config.get(option_key)
default = option.get('default')
if callable(option.get('choices')):
option['choices'] = option['choices']()
if callable(option.get('condition')):
option['condition'] = option['condition']()
hbox = Gtk.HBox()
hbox.set_margin_left(20)
self.wrapper = Gtk.HBox()
self.wrapper.set_spacing(20)
placeholder = Gtk.HBox()
placeholder.set_size_request(32, 32)
hbox.pack_end(placeholder, False, False, 5)
# Set tooltip's "Default" part
default = option.get('default')
self.tooltip_default = default if type(default) is str else None
# Generate option widget
self.option_widget = None
self.call_widget_generator(option, option_key, value, default)
# Reset button
reset_btn = Gtk.Button.new_from_icon_name('edit-clear',
Gtk.IconSize.MENU)
reset_btn.set_relief(Gtk.ReliefStyle.NONE)
reset_btn.set_tooltip_text("Reset option to global or "
"default config")
reset_btn.connect('clicked', self.on_reset_button_clicked, option,
self.option_widget, self.wrapper)
if option_key not in self.raw_config:
reset_btn.set_visible(False)
reset_btn.set_no_show_all(True)
placeholder.pack_start(reset_btn, False, False, 0)
# Tooltip
helptext = option.get("help")
if type(self.tooltip_default) is str:
helptext = helptext + '\n\n' if helptext else ''
helptext += "<b>Default</b>: " + self.tooltip_default
if value != default and option_key not in self.raw_config:
helptext = helptext + '\n\n' if helptext else ''
helptext += ("<i>(Italic indicates that this option is "
"modified in a lower configuration level.)</i>")
if helptext:
self.wrapper.props.has_tooltip = True
self.wrapper.connect('query-tooltip', self.on_query_tooltip,
helptext)
# Grey out option if condition unmet
if 'condition' in option and not option['condition']:
hbox.set_sensitive(False)
# Hide if advanced
if option.get('advanced'):
hbox.get_style_context().add_class('advanced')
show_advanced = settings.read_setting('show_advanced_options')
if not show_advanced == 'True':
hbox.set_no_show_all(True)
hbox.pack_start(self.wrapper, True, True, 0)
self.pack_start(hbox, False, False, 5)
def view_sorting(self):
value = settings.read_setting("view_sorting") or "name"
if value.endswith("_text"):
value = value[:-5]
return value
def __init__(self, service, _dialog):
super().__init__(orientation=Gtk.Orientation.VERTICAL)
self.set_spacing(12)
self.set_margin_right(12)
self.set_margin_left(12)
self.set_margin_bottom(12)
self.service = service
self.identifier = service.__name__.split(".")[-1]
self.is_connecting = False
self.name = service.NAME
self.games = []
self.store = None
self.num_selected = 0
self.games_loaded = False
self.current_filter = None
self.store_filter = None
title_box = Gtk.Box(spacing=6)
label = Gtk.Label()
label.set_markup("<b>{}</b>".format(self.name))
title_box.pack_start(label, True, True, 0)
self.connect_button = Gtk.Button()
self.connect_button.connect("clicked", self.on_connect_clicked)
if service.ONLINE:
self.refresh_button = Gtk.Button()
self.refresh_button.connect("clicked", self.on_refresh_clicked)
self.refresh_button.set_tooltip_text(_("Reload"))
self.refresh_button.set_image(
Gtk.Image.new_from_icon_name("view-refresh-symbolic",
Gtk.IconSize.MENU))
title_box.add(self.refresh_button)
title_box.add(self.connect_button)
self.pack_start(title_box, False, False, 12)
self.content_widget = self.get_content_widget()
self.pack_start(self.content_widget, True, True, 0)
actions = Gtk.Box(spacing=6)
self.pack_start(actions, False, False, 0)
self.import_button = Gtk.Button(_("Import games"))
self.import_button.set_sensitive(False)
self.import_button.set_tooltip_text(_("Sync now"))
self.import_button.connect("clicked", self.on_sync_button_clicked,
service.SYNCER.sync)
actions.pack_start(self.import_button, False, False, 0)
self.sync_switch = Gtk.Switch()
self.sync_switch.props.valign = Gtk.Align.CENTER
self.sync_switch.connect("notify::active", self.on_switch_changed)
if read_setting("sync_at_startup", self.identifier) == "True":
self.sync_switch.set_state(True)
actions.pack_start(Gtk.Alignment(), True, True, 0)
actions.pack_start(self.sync_switch, False, False, 0)
actions.pack_start(Gtk.Label(_("Sync all games at startup")), False,
False, 0)
if self.service.ONLINE:
AsyncCall(self._connect_button_toggle, None)
def show_hidden_games(self):
return settings.read_setting("show_hidden_games").lower() == "true"
def right_side_panel_visible(self):
show_right_panel = (settings.read_setting("right_side_panel_visible").lower() != "false")
return show_right_panel or self.sidebar_visible
def __init__(self, application, **kwargs):
width = int(settings.read_setting("width") or self.default_width)
height = int(settings.read_setting("height") or self.default_height)
super().__init__(default_width=width,
default_height=height,
window_position=Gtk.WindowPosition.NONE,
name="lutris",
icon_name="lutris",
application=application,
**kwargs)
update_desktop_icons()
load_icon_theme()
self.application = application
self.runtime_updater = RuntimeUpdater()
self.threads_stoppers = []
self.window_size = (width, height)
self.maximized = settings.read_setting("maximized") == "True"
self.service = None
self.game_actions = GameActions(application=application, window=self)
self.search_timer_id = None
self.selected_category = settings.read_setting("selected_category",
default="runner:all")
self.filters = self.load_filters()
self.set_service(self.filters.get("service"))
self.icon_type = self.load_icon_type()
self.game_store = GameStore(self.service, self.service_media)
self.view = Gtk.Box()
self.connect("delete-event", self.on_window_delete)
self.connect("map-event", self.on_load)
if self.maximized:
self.maximize()
self.init_template()
self._init_actions()
self.set_dark_theme()
self.set_viewtype_icon(self.view_type)
lutris_icon = Gtk.Image.new_from_icon_name("lutris", Gtk.IconSize.MENU)
lutris_icon.set_margin_right(3)
self.sidebar = LutrisSidebar(self.application,
selected=self.selected_category)
self.sidebar.connect("selected-rows-changed", self.on_sidebar_changed)
self.sidebar_scrolled.add(self.sidebar)
self.sidebar_revealer.set_reveal_child(self.side_panel_visible)
self.sidebar_revealer.set_transition_duration(300)
self.tabs_box.hide()
self.game_bar = None
self.revealer_box = Gtk.HBox(visible=True)
self.game_revealer.add(self.revealer_box)
self.connect("view-updated", self.update_store)
GObject.add_emission_hook(BaseService, "service-login",
self.on_service_login)
GObject.add_emission_hook(BaseService, "service-logout",
self.on_service_logout)
GObject.add_emission_hook(BaseService, "service-games-load",
self.on_service_games_updating)
GObject.add_emission_hook(BaseService, "service-games-loaded",
self.on_service_games_updated)
GObject.add_emission_hook(Game, "game-updated",
self.on_game_collection_changed)
GObject.add_emission_hook(Game, "game-removed",
self.on_game_collection_changed)
def sidebar_visible(self):
"""Deprecated: For compability only"""
return settings.read_setting("sidebar_visible") in [
"true",
None,
]
def left_side_panel_visible(self):
show_left_panel = settings.read_setting(
"left_side_panel_visible").lower() == "true"
return show_left_panel or self.sidebar_visible
def show_installed_first(self):
return settings.read_setting("show_installed_first", default="false").lower() == "true"
