"""Registry operations mixin for AutomatedPrefixService.""" import os import subprocess import logging from pathlib import Path from typing import Optional logger = logging.getLogger(__name__) class RegistryOperationsMixin: """Mixin providing Wine/Proton registry operations.""" def _update_registry_path(self, system_reg_path: str, section_name: str, path_key: str, new_path: str) -> bool: """Update a specific path value in Wine registry, preserving other entries""" if not os.path.exists(system_reg_path): return False try: # Read existing content with open(system_reg_path, 'r', encoding='utf-8', errors='ignore') as f: lines = f.readlines() in_target_section = False path_updated = False # Determine Wine drive letter based on SD card detection from jackify.backend.handlers.filesystem_handler import FileSystemHandler from jackify.backend.handlers.path_handler import PathHandler linux_path = Path(new_path) if FileSystemHandler.is_sd_card(linux_path): # SD card paths use D: drive # Strip SD card prefix using the same method as other handlers relative_sd_path_str = PathHandler._strip_sdcard_path_prefix(linux_path) wine_path = relative_sd_path_str.replace('/', '\\\\') wine_drive = "D:" logger.debug(f"SD card path detected: {new_path} -> D:\\{wine_path}") else: # Regular paths use Z: drive with full path wine_path = new_path.strip('/').replace('/', '\\\\') wine_drive = "Z:" logger.debug(f"Regular path: {new_path} -> Z:\\{wine_path}") # Update existing path if found for i, line in enumerate(lines): stripped_line = line.strip() # Case-insensitive comparison for section name (Wine registry is case-insensitive) if stripped_line.split(']')[0].lower() + ']' == section_name.lower() if ']' in stripped_line else stripped_line.lower() == section_name.lower(): in_target_section = True elif stripped_line.startswith('[') and in_target_section: in_target_section = False elif in_target_section and f'"{path_key}"' in line: lines[i] = f'"{path_key}"="{wine_drive}\\\\{wine_path}\\\\"\n' # Add trailing backslashes path_updated = True break # Add new section if path wasn't updated if not path_updated: lines.append(f'\n{section_name}\n') lines.append(f'"{path_key}"="{wine_drive}\\\\{wine_path}\\\\"\n') # Add trailing backslashes # Write updated content with open(system_reg_path, 'w', encoding='utf-8') as f: f.writelines(lines) return True except Exception as e: logger.error(f"Failed to update registry path: {e}") return False def _apply_universal_dotnet_fixes(self, modlist_compatdata_path: str): """Apply universal dotnet4.x compatibility registry fixes to ALL modlists""" try: prefix_path = os.path.join(modlist_compatdata_path, "pfx") if not os.path.exists(prefix_path): logger.warning(f"Prefix path not found: {prefix_path}") return False logger.info("Applying universal dotnet4.x compatibility registry fixes...") # Find the appropriate Wine binary to use for registry operations wine_binary = self._find_wine_binary_for_registry(modlist_compatdata_path) if not wine_binary: logger.error("Could not find Wine binary for registry operations") return False # Set environment for Wine registry operations env = os.environ.copy() env['WINEPREFIX'] = prefix_path env['WINEDEBUG'] = '-all' # Suppress Wine debug output # Registry fix 1: Set *mscoree=native DLL override (asterisk for full override) # Use native .NET runtime instead of Wine's logger.debug("Setting *mscoree=native DLL override...") cmd1 = [ wine_binary, 'reg', 'add', 'HKEY_CURRENT_USER\\Software\\Wine\\DllOverrides', '/v', '*mscoree', '/t', 'REG_SZ', '/d', 'native', '/f' ] result1 = subprocess.run(cmd1, env=env, capture_output=True, text=True, errors='replace') if result1.returncode == 0: logger.info("Successfully applied *mscoree=native DLL override") else: logger.warning(f"Failed to set *mscoree DLL override: {result1.stderr}") # Registry fix 2: Set OnlyUseLatestCLR=1 # Use latest CLR to avoid .NET version conflicts logger.debug("Setting OnlyUseLatestCLR=1 registry entry...") cmd2 = [ wine_binary, 'reg', 'add', 'HKEY_LOCAL_MACHINE\\Software\\Microsoft\\.NETFramework', '/v', 'OnlyUseLatestCLR', '/t', 'REG_DWORD', '/d', '1', '/f' ] result2 = subprocess.run(cmd2, env=env, capture_output=True, text=True, errors='replace') if result2.returncode == 0: logger.info("Successfully applied OnlyUseLatestCLR=1 registry entry") else: logger.warning(f"Failed to set OnlyUseLatestCLR: {result2.stderr}") # Both fixes applied - this should eliminate dotnet4.x installation requirements if result1.returncode == 0 and result2.returncode == 0: logger.info("Universal dotnet4.x compatibility fixes applied successfully") return True else: logger.warning("Some dotnet4.x registry fixes failed, but continuing...") return False except Exception as e: logger.error(f"Failed to apply universal dotnet4.x fixes: {e}") return False def _find_wine_binary_for_registry(self, modlist_compatdata_path: str) -> Optional[str]: """Find the appropriate Wine binary for registry operations""" try: from ..handlers.config_handler import ConfigHandler from ..handlers.wine_utils import WineUtils # Method 1: Use the user's configured Proton version from settings config_handler = ConfigHandler() user_proton_path = config_handler.get_game_proton_path() if user_proton_path and user_proton_path != 'auto': # User has selected a specific Proton version proton_path = Path(user_proton_path).expanduser() # Check for wine binary in both GE-Proton and Valve Proton structures wine_candidates = [ proton_path / "files" / "bin" / "wine", # GE-Proton structure proton_path / "dist" / "bin" / "wine" # Valve Proton structure ] for wine_path in wine_candidates: if wine_path.exists() and wine_path.is_file(): logger.info(f"Using Wine binary from user's configured Proton: {wine_path}") return str(wine_path) # Wine binary not found at expected paths - search recursively in Proton directory logger.debug(f"Wine binary not found at expected paths in {proton_path}, searching recursively...") wine_binary = self._search_wine_in_proton_directory(proton_path) if wine_binary: logger.info(f"Found Wine binary via recursive search in Proton directory: {wine_binary}") return wine_binary logger.warning(f"User's configured Proton path has no wine binary: {user_proton_path}") # Method 2: Fallback to auto-detection using WineUtils best_proton = WineUtils.select_best_proton() if best_proton: wine_binary = WineUtils.find_proton_binary(best_proton['name']) if wine_binary: logger.info(f"Using Wine binary from detected Proton: {wine_binary}") return wine_binary # NEVER fall back to system wine - it will break Proton prefixes with architecture mismatches logger.error("No suitable Proton Wine binary found for registry operations") return None except Exception as e: logger.error(f"Error finding Wine binary: {e}") return None def _search_wine_in_proton_directory(self, proton_path: Path) -> Optional[str]: """ Recursively search for wine binary within a Proton directory. This handles cases where the directory structure might differ between Proton versions. Args: proton_path: Path to the Proton directory to search Returns: Path to wine binary if found, None otherwise """ try: if not proton_path.exists() or not proton_path.is_dir(): return None # Search for 'wine' executable (not 'wine64' or 'wine-preloader') # Limit search depth to avoid scanning entire filesystem max_depth = 5 for root, dirs, files in os.walk(proton_path, followlinks=False): # Calculate depth relative to proton_path try: depth = len(Path(root).relative_to(proton_path).parts) except ValueError: # Path is not relative to proton_path (shouldn't happen, but be safe) continue if depth > max_depth: dirs.clear() # Don't descend further continue # Check if 'wine' is in this directory if 'wine' in files: wine_path = Path(root) / 'wine' # Verify it's actually an executable file if wine_path.is_file() and os.access(wine_path, os.X_OK): logger.debug(f"Found wine binary at: {wine_path}") return str(wine_path) return None except Exception as e: logger.debug(f"Error during recursive wine search in {proton_path}: {e}") return None def _inject_game_registry_entries(self, modlist_compatdata_path: str, special_game_type: str): """Detect and inject FNV/Enderal game paths and apply universal dotnet4.x compatibility fixes""" system_reg_path = os.path.join(modlist_compatdata_path, "pfx", "system.reg") if not os.path.exists(system_reg_path): logger.warning("system.reg not found, skipping game path injection") return logger.info("Detecting game registry entries...") # Universal dotnet4.x registry fixes applied in modlist_handler.py after .reg downloads # Game configurations games_config = { "22380": { # Fallout New Vegas AppID "name": "Fallout New Vegas", "common_names": ["Fallout New Vegas", "FalloutNV"], "registry_section": "[Software\\\\Wow6432Node\\\\bethesda softworks\\\\falloutnv]", "path_key": "Installed Path" }, "976620": { # Enderal Special Edition AppID "name": "Enderal", "common_names": ["Enderal: Forgotten Stories (Special Edition)", "Enderal Special Edition", "Enderal"], "registry_section": "[Software\\\\Wow6432Node\\\\SureAI\\\\Enderal SE]", "path_key": "installed path" } } # Detect and inject each game for app_id, config in games_config.items(): game_path = self._find_steam_game(app_id, config["common_names"]) if game_path: logger.info(f"Detected {config['name']} at: {game_path}") success = self._update_registry_path( system_reg_path, config["registry_section"], config["path_key"], game_path ) if success: logger.info(f"Updated registry entry for {config['name']}") else: logger.warning(f"Failed to update registry entry for {config['name']}") else: logger.debug(f"{config['name']} not found in Steam libraries") logger.info("Game registry injection completed")