def wineexec(executable,
args="",
wine_path=None,
prefix=None,
arch=None,
working_dir=None,
winetricks_wine='',
blocking=False,
config=None):
"""Execute a Wine command."""
detected_arch = detect_prefix_arch(prefix)
executable = str(executable) if executable else ''
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
if executable.endswith(".msi"):
executable = 'msiexec /i "%s"' % executable
elif executable:
executable = '%s' % executable
# Create prefix if necessary
if not detected_arch:
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
env = {'WINEARCH': arch}
if winetricks_wine:
env['WINE'] = winetricks_wine
else:
env['WINE'] = wine_path
if prefix:
env['WINEPREFIX'] = prefix
wine_config = config or LutrisConfig(runner_slug='wine')
if not wine_config.system_config[
'disable_runtime'] and not runtime.is_disabled():
env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths())
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=env, cwd=working_dir)
else:
thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir)
thread.start()
return thread
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None,
working_dir=None, winetricks_wine='', blocking=False):
"""Execute a Wine command."""
detected_arch = detect_prefix_arch(prefix)
executable = str(executable) if executable else ''
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
if executable.endswith(".msi"):
executable = 'msiexec /i "%s"' % executable
elif executable:
executable = '%s' % executable
# Create prefix if necessary
if not detected_arch:
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
env = {
'WINEARCH': arch
}
if winetricks_wine:
env['WINE'] = winetricks_wine
else:
env['WINE'] = wine_path
if prefix:
env['WINEPREFIX'] = prefix
wine_config = LutrisConfig(runner_slug='wine')
if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled():
env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths())
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=env, cwd=working_dir)
else:
thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir)
thread.start()
return thread
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None,
working_dir=None, winetricks_env='', blocking=True):
"""Execute a Wine command."""
detected_arch = detect_prefix_arch(prefix)
executable = str(executable) if executable else ''
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
if executable.endswith(".msi"):
executable = 'msiexec /i "%s"' % executable
elif executable:
executable = '"%s"' % executable
# Create prefix if necessary
if not detected_arch:
create_prefix(prefix, wine_dir=os.path.dirname(wine_path), arch=arch)
env = ['WINEARCH=%s' % arch]
if winetricks_env:
env.append('WINE="%s"' % winetricks_env)
if prefix:
env.append('WINEPREFIX="%s" ' % prefix)
if settings.RUNNER_DIR in wine_path:
runtime_path = ':'.join(runtime.get_paths())
env.append('LD_LIBRARY_PATH={}'.format(runtime_path))
command = '{0} "{1}" {2} {3}'.format(
" ".join(env), wine_path, executable, args
)
p = subprocess.Popen(command, cwd=working_dir, shell=True,
stdout=subprocess.PIPE)
if blocking:
p.communicate()
def wineexec(
executable,
args="",
wine_path=None,
prefix=None,
arch=None, # pylint: disable=too-many-locals
working_dir=None,
winetricks_wine='',
blocking=False,
config=None,
include_processes=[],
exclude_processes=[],
disable_runtime=False,
env={},
overrides=None):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
LutrisThread instance otherwise.
"""
executable = str(executable) if executable else ''
if not wine_path:
wine = import_runner('wine')
wine_path = wine().get_executable()
if not wine_path:
raise RuntimeError("Wine is not installed")
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
executable, _args, working_dir = get_real_executable(
executable, working_dir)
if _args:
args = '{} "{}"'.format(_args[0], _args[1])
# Create prefix if necessary
if arch not in ('win32', 'win64'):
arch = detect_arch(prefix, wine_path)
if not detect_prefix_arch(prefix):
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
wineenv = {'WINEARCH': arch}
if winetricks_wine:
wineenv['WINE'] = winetricks_wine
else:
wineenv['WINE'] = wine_path
if prefix:
wineenv['WINEPREFIX'] = prefix
wine_config = config or LutrisConfig(runner_slug='wine')
disable_runtime = disable_runtime or wine_config.system_config[
'disable_runtime']
if use_lutris_runtime(wine_path=wineenv['WINE'],
force_disable=disable_runtime):
if WINE_DIR in wine_path:
wine_root_path = os.path.dirname(os.path.dirname(wine_path))
elif WINE_DIR in winetricks_wine:
wine_root_path = os.path.dirname(os.path.dirname(winetricks_wine))
else:
wine_root_path = None
wineenv['LD_LIBRARY_PATH'] = ':'.join(
runtime.get_paths(prefer_system_libs=wine_config.
system_config['prefer_system_libs'],
wine_path=wine_root_path))
if overrides:
wineenv['WINEDLLOVERRIDES'] = get_overrides_env(overrides)
wineenv.update(env)
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=wineenv, cwd=working_dir)
wine = import_runner('wine')
thread = LutrisThread(command,
runner=wine(),
env=wineenv,
cwd=working_dir,
include_processes=include_processes,
exclude_processes=exclude_processes)
thread.start()
return thread
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None,
working_dir=None, winetricks_wine='', blocking=False,
config=None, include_processes=[]):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
LutrisThread instance otherwise.
"""
detected_arch = detect_prefix_arch(prefix)
executable = str(executable) if executable else ''
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
executable, _args = get_real_executable(executable)
if _args:
args = '{} "{}"'.format(_args[0], _args[1])
# Create prefix if necessary
if not detected_arch:
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
env = {
'WINEARCH': arch
}
if winetricks_wine:
env['WINE'] = winetricks_wine
else:
env['WINE'] = wine_path
if prefix:
env['WINEPREFIX'] = prefix
wine_config = config or LutrisConfig(runner_slug='wine')
if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled():
env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths())
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=env, cwd=working_dir)
else:
thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir,
include_processes=include_processes)
thread.start()
return thread
def wineexec( # noqa: C901
executable,
args="",
wine_path=None,
prefix=None,
arch=None,
working_dir=None,
winetricks_wine="",
blocking=False,
config=None,
include_processes=None,
exclude_processes=None,
disable_runtime=False,
env=None,
overrides=None,
):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
MonitoredCommand instance otherwise.
"""
if env is None:
env = {}
if exclude_processes is None:
exclude_processes = []
if include_processes is None:
include_processes = []
executable = str(executable) if executable else ""
if isinstance(include_processes, str):
include_processes = shlex.split(include_processes)
if isinstance(exclude_processes, str):
exclude_processes = shlex.split(exclude_processes)
if not wine_path:
wine = import_runner("wine")
wine_path = wine().get_executable()
if not wine_path:
raise RuntimeError("Wine is not installed")
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
executable, _args, working_dir = get_real_executable(
executable, working_dir)
if _args:
args = '{} "{}"'.format(_args[0], _args[1])
# Create prefix if necessary
if arch not in ("win32", "win64"):
arch = detect_arch(prefix, wine_path)
if not detect_prefix_arch(prefix):
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
wineenv = {"WINEARCH": arch}
if winetricks_wine:
wineenv["WINE"] = winetricks_wine
else:
wineenv["WINE"] = wine_path
if prefix:
wineenv["WINEPREFIX"] = prefix
wine_config = config or LutrisConfig(runner_slug="wine")
disable_runtime = disable_runtime or wine_config.system_config[
"disable_runtime"]
if use_lutris_runtime(wine_path=wineenv["WINE"],
force_disable=disable_runtime):
if WINE_DIR in wine_path:
wine_root_path = os.path.dirname(os.path.dirname(wine_path))
elif WINE_DIR in winetricks_wine:
wine_root_path = os.path.dirname(os.path.dirname(winetricks_wine))
else:
wine_root_path = None
wineenv["LD_LIBRARY_PATH"] = ":".join(
runtime.get_paths(
prefer_system_libs=wine_config.
system_config["prefer_system_libs"],
wine_path=wine_root_path,
))
if overrides:
wineenv["WINEDLLOVERRIDES"] = get_overrides_env(overrides)
if env:
wineenv.update(env)
command_parameters = [wine_path]
if executable:
command_parameters.append(executable)
command_parameters += split_arguments(args)
if blocking:
return system.execute(command_parameters, env=wineenv, cwd=working_dir)
wine = import_runner("wine")
command = MonitoredCommand(
command_parameters,
runner=wine(),
env=wineenv,
cwd=working_dir,
include_processes=include_processes,
exclude_processes=exclude_processes,
)
command.start()
return command
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None,
working_dir=None, winetricks_wine='', blocking=False,
config=None, include_processes=[]):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
LutrisThread instance otherwise.
"""
detected_arch = detect_prefix_arch(prefix)
executable = str(executable) if executable else ''
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
if executable.endswith(".msi"):
args = '/i "%s"' % executable
executable = 'msiexec'
# Create prefix if necessary
if not detected_arch:
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
env = {
'WINEARCH': arch
}
if winetricks_wine:
env['WINE'] = winetricks_wine
else:
env['WINE'] = wine_path
if prefix:
env['WINEPREFIX'] = prefix
wine_config = config or LutrisConfig(runner_slug='wine')
if not wine_config.system_config['disable_runtime'] and not runtime.is_disabled():
env['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths())
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=env, cwd=working_dir)
else:
thread = LutrisThread(command, runner=wine(), env=env, cwd=working_dir,
include_processes=include_processes)
thread.start()
return thread
def wineexec(executable, args="", wine_path=None, prefix=None, arch=None,
working_dir=None, winetricks_wine='', blocking=False,
config=None, include_processes=[], exclude_processes=[],
disable_runtime=False, env={}, overrides=None):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
LutrisThread instance otherwise.
"""
executable = str(executable) if executable else ''
if not wine_path:
wine_path = wine().get_executable()
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
executable, _args, working_dir = get_real_executable(executable, working_dir)
if _args:
args = '{} "{}"'.format(_args[0], _args[1])
# Create prefix if necessary
detected_arch = detect_prefix_arch(prefix)
if arch not in ('win32', 'win64'):
arch = detected_arch or 'win32'
if not detected_arch:
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
wineenv = {
'WINEARCH': arch
}
if winetricks_wine:
wineenv['WINE'] = winetricks_wine
else:
wineenv['WINE'] = wine_path
if prefix:
wineenv['WINEPREFIX'] = prefix
wine_config = config or LutrisConfig(runner_slug='wine')
if (
not runtime.RUNTIME_DISABLED and
not disable_runtime and
not wine_config.system_config['disable_runtime']
):
wineenv['LD_LIBRARY_PATH'] = ':'.join(runtime.get_paths())
if overrides:
wineenv['WINEDLLOVERRIDES'] = get_overrides_env(overrides)
wineenv.update(env)
command = [wine_path]
if executable:
command.append(executable)
command += shlex.split(args)
if blocking:
return system.execute(command, env=wineenv, cwd=working_dir)
else:
thread = LutrisThread(command, runner=wine(), env=wineenv, cwd=working_dir,
include_processes=include_processes,
exclude_processes=exclude_processes)
thread.start()
return thread
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
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'
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)
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')
if ld_preload:
env["LD_PRELOAD"] = ld_preload
ld_library_path = []
if self.runner.use_runtime():
env['STEAM_RUNTIME'] = os.path.join(settings.RUNTIME_DIR, 'steam')
ld_library_path += runtime.get_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)
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 wineexec(
executable,
args="",
wine_path=None,
prefix=None,
arch=None, # pylint: disable=too-many-locals
working_dir=None,
winetricks_wine="",
blocking=False,
config=None,
include_processes=[],
exclude_processes=[],
disable_runtime=False,
env={},
overrides=None,
):
"""
Execute a Wine command.
Args:
executable (str): wine program to run, pass None to run wine itself
args (str): program arguments
wine_path (str): path to the wine version to use
prefix (str): path to the wine prefix to use
arch (str): wine architecture of the prefix
working_dir (str): path to the working dir for the process
winetricks_wine (str): path to the wine version used by winetricks
blocking (bool): if true, do not run the process in a thread
config (LutrisConfig): LutrisConfig object for the process context
watch (list): list of process names to monitor (even when in a ignore list)
Returns:
Process results if the process is running in blocking mode or
MonitoredCommand instance otherwise.
"""
executable = str(executable) if executable else ""
if isinstance(include_processes, str):
include_processes = shlex.split(include_processes)
if isinstance(exclude_processes, str):
exclude_processes = shlex.split(exclude_processes)
if not wine_path:
wine = import_runner("wine")
wine_path = wine().get_executable()
if not wine_path:
raise RuntimeError("Wine is not installed")
if not working_dir:
if os.path.isfile(executable):
working_dir = os.path.dirname(executable)
executable, _args, working_dir = get_real_executable(executable, working_dir)
if _args:
args = '{} "{}"'.format(_args[0], _args[1])
# Create prefix if necessary
if arch not in ("win32", "win64"):
arch = detect_arch(prefix, wine_path)
if not detect_prefix_arch(prefix):
wine_bin = winetricks_wine if winetricks_wine else wine_path
create_prefix(prefix, wine_path=wine_bin, arch=arch)
wineenv = {"WINEARCH": arch}
if winetricks_wine:
wineenv["WINE"] = winetricks_wine
else:
wineenv["WINE"] = wine_path
if prefix:
wineenv["WINEPREFIX"] = prefix
wine_config = config or LutrisConfig(runner_slug="wine")
disable_runtime = disable_runtime or wine_config.system_config["disable_runtime"]
if use_lutris_runtime(wine_path=wineenv["WINE"], force_disable=disable_runtime):
if WINE_DIR in wine_path:
wine_root_path = os.path.dirname(os.path.dirname(wine_path))
elif WINE_DIR in winetricks_wine:
wine_root_path = os.path.dirname(os.path.dirname(winetricks_wine))
else:
wine_root_path = None
wineenv["LD_LIBRARY_PATH"] = ":".join(
runtime.get_paths(
prefer_system_libs=wine_config.system_config["prefer_system_libs"],
wine_path=wine_root_path,
)
)
if overrides:
wineenv["WINEDLLOVERRIDES"] = get_overrides_env(overrides)
wineenv.update(env)
command_parameters = [wine_path]
if executable:
command_parameters.append(executable)
command_parameters += shlex.split(args)
if blocking:
return system.execute(command_parameters, env=wineenv, cwd=working_dir)
wine = import_runner("wine")
command = MonitoredCommand(
command_parameters,
runner=wine(),
env=wineenv,
cwd=working_dir,
include_processes=include_processes,
exclude_processes=exclude_processes,
)
command.start()
return command
