mirror of
https://github.com/Omni-guides/Jackify.git
synced 2026-08-14 01:23:46 +02:00
345 lines
16 KiB
Python
345 lines
16 KiB
Python
"""Launch options and icon methods for ShortcutHandler (Mixin)."""
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import time
|
|
import vdf
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_MANIFEST_FILE_RE = re.compile(r'<file\s+name="([^"]+)"\s*/>', re.IGNORECASE)
|
|
|
|
|
|
class ShortcutLaunchOptionsMixin:
|
|
"""Mixin providing launch options and icon methods."""
|
|
|
|
def get_shortcut_launch_options(self, app_name: str, exe_path: str) -> 'Optional[str]':
|
|
"""Return current LaunchOptions for a shortcut, or None if the shortcut is not found."""
|
|
shortcuts_file = self.path_handler._find_shortcuts_vdf()
|
|
if not shortcuts_file or not os.path.exists(shortcuts_file):
|
|
return None
|
|
try:
|
|
with open(shortcuts_file, 'rb') as f:
|
|
data = vdf.binary_loads(f.read())
|
|
except Exception as e:
|
|
self.logger.debug(f"Could not read shortcuts.vdf: {e}")
|
|
return None
|
|
|
|
def _norm(p: str) -> str:
|
|
try:
|
|
return os.path.normpath(os.path.abspath(p.strip().strip('"'))).lower()
|
|
except Exception:
|
|
return p.strip().strip('"').lower()
|
|
|
|
exe_norm = _norm(exe_path)
|
|
for shortcut_data in data.get('shortcuts', {}).values():
|
|
if (shortcut_data.get('AppName', '').strip() == app_name and
|
|
_norm(shortcut_data.get('Exe', '')) == exe_norm):
|
|
return shortcut_data.get('LaunchOptions', '')
|
|
return None
|
|
|
|
def ensure_mounts_in_steam_compat(self, app_name: str, exe_path: str, *paths: str) -> str:
|
|
"""Add mountpoints of any supplied paths to STEAM_COMPAT_MOUNTS if not already present.
|
|
|
|
Reads existing launch options and appends only what is missing - never overwrites
|
|
unrelated options. Adds the top-level directory of each path so Proton's container
|
|
can bind-mount the subtree into the prefix.
|
|
|
|
When Steam is running, the write is deferred: returns "steam_running" so the caller
|
|
can stop Steam first, call apply_pending_mounts_update(), then restart Steam.
|
|
|
|
Returns:
|
|
"unchanged" - mounts already correct, no action needed
|
|
"updated" - Steam was not running; write succeeded
|
|
"steam_running" - changes needed but deferred; call apply_pending_mounts_update()
|
|
after stopping Steam
|
|
"failed" - shortcut not found or write error
|
|
"""
|
|
import re
|
|
from pathlib import Path as _Path
|
|
|
|
def _is_covered(path: str, mounts: list) -> bool:
|
|
"""Return True if path is already reachable via an existing mount entry.
|
|
|
|
A path is covered if an existing mount entry is equal to it or is a
|
|
parent of it. Root '/' is excluded as a catch-all.
|
|
"""
|
|
p = _Path(path)
|
|
for mount in mounts:
|
|
if mount == '/':
|
|
continue
|
|
try:
|
|
p.relative_to(mount)
|
|
return True
|
|
except ValueError:
|
|
pass
|
|
return False
|
|
|
|
current = self.get_shortcut_launch_options(app_name, exe_path)
|
|
if current is None:
|
|
self.logger.warning(f"Shortcut '{app_name}' not found in shortcuts.vdf; cannot update STEAM_COMPAT_MOUNTS")
|
|
return "failed"
|
|
|
|
compat_re = re.compile(r'STEAM_COMPAT_MOUNTS="([^"]*)"')
|
|
m = compat_re.search(current)
|
|
existing = [p for p in m.group(1).split(':') if p] if m else []
|
|
|
|
mounts_to_add = []
|
|
for p in paths:
|
|
if not p:
|
|
continue
|
|
if not _is_covered(p, existing) and p not in mounts_to_add:
|
|
mounts_to_add.append(p)
|
|
|
|
if not mounts_to_add:
|
|
self.logger.debug(f"STEAM_COMPAT_MOUNTS for '{app_name}' already covers required paths")
|
|
return "unchanged"
|
|
|
|
if m:
|
|
updated_val = ':'.join(existing + mounts_to_add)
|
|
updated = compat_re.sub(f'STEAM_COMPAT_MOUNTS="{updated_val}"', current)
|
|
else:
|
|
val = ':'.join(mounts_to_add)
|
|
prefix = f'STEAM_COMPAT_MOUNTS="{val}"'
|
|
updated = f'{prefix} {current}' if current.strip() else f'{prefix} %command%'
|
|
|
|
self.logger.info(f"STEAM_COMPAT_MOUNTS update needed for '{app_name}': adding {mounts_to_add}")
|
|
|
|
try:
|
|
from jackify.backend.services.steam_restart_service import get_steam_processes
|
|
steam_running = bool(get_steam_processes())
|
|
except Exception:
|
|
steam_running = False
|
|
|
|
if steam_running:
|
|
# Defer the write - Steam holds shortcuts.vdf in memory and would clobber it.
|
|
# Store the pending options so the GUI can stop Steam, apply, then restart.
|
|
self._pending_mounts_app_name = app_name
|
|
self._pending_mounts_exe_path = exe_path
|
|
self._pending_mounts_options = updated
|
|
return "steam_running"
|
|
|
|
success = self.update_shortcut_launch_options(app_name, exe_path, updated)
|
|
return "updated" if success else "failed"
|
|
|
|
def apply_pending_mounts_update(self) -> bool:
|
|
"""Write a deferred STEAM_COMPAT_MOUNTS update. Call only after Steam has stopped."""
|
|
app_name = getattr(self, '_pending_mounts_app_name', None)
|
|
exe_path = getattr(self, '_pending_mounts_exe_path', None)
|
|
options = getattr(self, '_pending_mounts_options', None)
|
|
if not (app_name and exe_path and options):
|
|
self.logger.warning("apply_pending_mounts_update called with no pending update")
|
|
return False
|
|
self._pending_mounts_app_name = None
|
|
self._pending_mounts_exe_path = None
|
|
self._pending_mounts_options = None
|
|
return self.update_shortcut_launch_options(app_name, exe_path, options)
|
|
|
|
def update_shortcut_launch_options(self, app_name, exe_path, new_launch_options):
|
|
"""
|
|
Updates the LaunchOptions for a specific existing shortcut in shortcuts.vdf by matching AppName and Exe.
|
|
|
|
Args:
|
|
app_name (str): The AppName of the shortcut to update (from config summary).
|
|
exe_path (str): The Exe path of the shortcut to update (from config summary, including quotes if present in VDF).
|
|
new_launch_options (str): The new string to set for LaunchOptions.
|
|
|
|
Returns:
|
|
bool: True if the update was successful, False otherwise.
|
|
"""
|
|
self.logger.info(f"Attempting to update launch options for shortcut with AppName '{app_name}' and Exe '{exe_path}' (no AppID matching)...")
|
|
|
|
shortcuts_file = self.path_handler._find_shortcuts_vdf()
|
|
if not shortcuts_file:
|
|
self.logger.error("Could not find shortcuts.vdf to update.")
|
|
return False
|
|
|
|
data = {'shortcuts': {}}
|
|
try:
|
|
if os.path.exists(shortcuts_file):
|
|
with open(shortcuts_file, 'rb') as f:
|
|
file_data = f.read()
|
|
if file_data:
|
|
data = vdf.binary_loads(file_data)
|
|
if 'shortcuts' not in data:
|
|
data['shortcuts'] = {}
|
|
else:
|
|
self.logger.error(f"shortcuts.vdf does not exist at {shortcuts_file}. Cannot update.")
|
|
return False
|
|
except Exception as e:
|
|
self.logger.error(f"Error reading or parsing shortcuts.vdf: {e}")
|
|
return False
|
|
|
|
def _normalize_path(p: str) -> str:
|
|
try:
|
|
p_clean = os.path.abspath(os.path.expanduser(p.strip().strip('"')))
|
|
return os.path.normpath(p_clean).lower()
|
|
except Exception:
|
|
return p.strip().strip('"').lower()
|
|
|
|
exe_norm = _normalize_path(exe_path)
|
|
target_index = None
|
|
for index, shortcut_data in data.get('shortcuts', {}).items():
|
|
shortcut_name = (shortcut_data.get('AppName', '') or '').strip()
|
|
shortcut_exe_raw = shortcut_data.get('Exe', '')
|
|
shortcut_exe_norm = _normalize_path(shortcut_exe_raw)
|
|
if shortcut_name == app_name and shortcut_exe_norm == exe_norm:
|
|
target_index = index
|
|
break
|
|
|
|
if target_index is None:
|
|
self.logger.error(f"Could not find shortcut with AppName '{app_name}' and Exe '{exe_path}' in shortcuts.vdf.")
|
|
for index, shortcut_data in data.get('shortcuts', {}).items():
|
|
shortcut_name = shortcut_data.get('AppName', '')
|
|
shortcut_exe = shortcut_data.get('Exe', '')
|
|
self.logger.error(f"Found shortcut: AppName='{shortcut_name}', Exe='{shortcut_exe}' -> norm='{_normalize_path(shortcut_exe)}'")
|
|
return False
|
|
|
|
if target_index in data['shortcuts']:
|
|
self.logger.info(f"Found shortcut at index {target_index}. Updating LaunchOptions...")
|
|
data['shortcuts'][target_index]['LaunchOptions'] = new_launch_options
|
|
else:
|
|
self.logger.error(f"Target index {target_index} not found in shortcuts dictionary after identification.")
|
|
return False
|
|
|
|
try:
|
|
temp_file = f"{shortcuts_file}.temp"
|
|
with open(temp_file, 'wb') as f:
|
|
vdf_data = vdf.binary_dumps(data)
|
|
f.write(vdf_data)
|
|
|
|
backup_dir = os.path.join(os.path.dirname(shortcuts_file), "backups")
|
|
os.makedirs(backup_dir, exist_ok=True)
|
|
timestamp = time.strftime("%Y%m%d_%H%M%S")
|
|
backup_path = os.path.join(backup_dir, f"shortcuts_update_{app_name}_{timestamp}.bak")
|
|
if os.path.exists(shortcuts_file):
|
|
shutil.copy2(shortcuts_file, backup_path)
|
|
self.logger.info(f"Created backup before update at {backup_path}")
|
|
|
|
shutil.move(temp_file, shortcuts_file)
|
|
self.logger.info(f"Successfully updated LaunchOptions for shortcut '{app_name}' in {shortcuts_file}.")
|
|
return True
|
|
except Exception as e:
|
|
self.logger.error(f"Error writing updated shortcuts.vdf: {e}")
|
|
if 'backup_path' in locals() and os.path.exists(backup_path):
|
|
try:
|
|
shutil.copy2(backup_path, shortcuts_file)
|
|
self.logger.warning(f"Restored shortcuts.vdf from backup {backup_path} after update failure.")
|
|
except Exception as restore_e:
|
|
self.logger.critical(f"CRITICAL: Failed to write updated shortcuts.vdf AND failed to restore backup! Error: {restore_e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def get_steam_shortcut_icon_path(exe_path, steamicons_dir=None, logger=None):
|
|
"""
|
|
Select the best icon for a Steam shortcut given an executable path and optional SteamIcons directory.
|
|
Prefers grid-tall.png, else any .png, else returns ''.
|
|
Logs selection steps if logger is provided.
|
|
"""
|
|
exe_dir = os.path.dirname(exe_path)
|
|
if not steamicons_dir:
|
|
steamicons_dir = os.path.join(exe_dir, "SteamIcons")
|
|
if logger:
|
|
logger.debug(f"[DEBUG] Looking for Steam shortcut icon in: {steamicons_dir}")
|
|
if os.path.isdir(steamicons_dir):
|
|
preferred_icon = os.path.join(steamicons_dir, "grid-tall.png")
|
|
if os.path.isfile(preferred_icon):
|
|
if logger:
|
|
logger.debug(f"[DEBUG] Using grid-tall.png as shortcut icon: {preferred_icon}")
|
|
return preferred_icon
|
|
pngs = [f for f in os.listdir(steamicons_dir) if f.lower().endswith('.png')]
|
|
if pngs:
|
|
icon_path = os.path.join(steamicons_dir, pngs[0])
|
|
if logger:
|
|
logger.debug(f"[DEBUG] Using fallback icon for shortcut: {icon_path}")
|
|
return icon_path
|
|
if logger:
|
|
logger.debug("[DEBUG] No .png icon found in SteamIcons directory.")
|
|
return ""
|
|
if logger:
|
|
logger.debug("[DEBUG] No SteamIcons directory found; shortcut will have no icon.")
|
|
return ""
|
|
|
|
def repair_dlls_manifest(self, mo2_dir: str) -> None:
|
|
"""
|
|
Some MO2 builds ship a dlls/dlls.manifest (Windows SxS assembly manifest) that omits
|
|
an entry for a DLL actually present in dlls/. Wine's loader only redirects lookups for
|
|
files declared in the manifest, so an undeclared DLL is invisible to dependents even
|
|
though it exists on disk (e.g. Qt6Core.dll importing icuuc.dll) - ModOrganizer.exe then
|
|
fails to load entirely (status c0000135). Patch in any missing entries so the manifest
|
|
matches what's actually in the directory. Never removes existing entries.
|
|
"""
|
|
dlls_dir = os.path.join(mo2_dir, "dlls")
|
|
manifest_path = os.path.join(dlls_dir, "dlls.manifest")
|
|
if not os.path.isfile(manifest_path):
|
|
return
|
|
|
|
try:
|
|
with open(manifest_path, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
except Exception as e:
|
|
self.logger.debug(f"Could not read dlls.manifest: {e}")
|
|
return
|
|
|
|
declared = {m.group(1).lower() for m in _MANIFEST_FILE_RE.finditer(content)}
|
|
try:
|
|
actual = {name for name in os.listdir(dlls_dir) if name.lower().endswith(".dll")}
|
|
except Exception as e:
|
|
self.logger.debug(f"Could not list dlls directory: {e}")
|
|
return
|
|
|
|
missing = sorted(name for name in actual if name.lower() not in declared)
|
|
if not missing:
|
|
return
|
|
|
|
if "</assembly>" not in content:
|
|
self.logger.warning(f"dlls.manifest at {manifest_path} has unexpected format - skipping repair")
|
|
return
|
|
|
|
insert = "".join(f' <file name="{name}" />\n' for name in missing)
|
|
patched = content.replace("</assembly>", insert + "</assembly>")
|
|
|
|
try:
|
|
with open(manifest_path, "w", encoding="utf-8") as f:
|
|
f.write(patched)
|
|
self.logger.info(f"Added missing dlls.manifest entries: {', '.join(missing)}")
|
|
except Exception as e:
|
|
self.logger.error(f"Failed to patch dlls.manifest: {e}")
|
|
|
|
def write_nxmhandler_ini(self, modlist_dir, mo2_exe_path):
|
|
"""
|
|
Create nxmhandler.ini in the modlist directory to suppress the NXM Handling popup on first MO2 launch.
|
|
The executable path will be written as Z:\\<absolute path with double backslashes>, matching MO2's format.
|
|
|
|
Some modlists ship their own nxmhandler.ini bundled with the packaged MO2 install,
|
|
carrying handler entries from the author's own machine (wrong drive letters, paths
|
|
to other modlists). Only skip writing if an existing file already references this
|
|
modlist's own executable path - otherwise regenerate it, since stale foreign entries
|
|
can make MO2 fail to re-verify its self-registration on close.
|
|
"""
|
|
ini_path = os.path.join(modlist_dir, "nxmhandler.ini")
|
|
abs_path = os.path.abspath(mo2_exe_path)
|
|
z_path = f"Z:{abs_path}"
|
|
win_path = z_path.replace('/', '\\')
|
|
win_path = win_path.replace('\\', '\\\\')
|
|
|
|
if os.path.exists(ini_path):
|
|
with open(ini_path, "r", encoding="utf-8") as f:
|
|
existing = f.read()
|
|
if win_path in existing:
|
|
self.logger.info(f"nxmhandler.ini already configured for this modlist at {ini_path}")
|
|
return
|
|
self.logger.info(f"nxmhandler.ini exists but does not reference this modlist, regenerating: {ini_path}")
|
|
|
|
content = (
|
|
"[handlers]\n"
|
|
"size=1\n"
|
|
"1\\games=\"skyrimse,skyrim,fallout4,falloutnv,fallout3,oblivion,enderal,starfield\"\n"
|
|
f"1\\executable={win_path}\n"
|
|
"1\\arguments=\n"
|
|
)
|
|
with open(ini_path, "w") as f:
|
|
f.write(content)
|
|
self.logger.info(f"[SUCCESS] nxmhandler.ini written to {ini_path}")
|