Sync from development - prepare for v0.4.0

jackify/frontends/gui/mixins/main_window_backend.py

@@ -7,14 +7,9 @@ import os
 
 from jackify.backend.models.configuration import SystemInfo
 from jackify.backend.services.modlist_service import ModlistService
+import logging
 
-
-def _debug_print(message):
-    from jackify.backend.handlers.config_handler import ConfigHandler
-    ch = ConfigHandler()
-    if ch.get('debug_mode', False):
-        print(message)
-
+logger = logging.getLogger(__name__)
 
 class MainWindowBackendMixin:
     """Mixin for backend service initialization."""
@@ -37,7 +32,7 @@ class MainWindowBackendMixin:
         from jackify.backend.services.update_service import UpdateService
         from jackify import __version__
         self.update_service = UpdateService(__version__)
-        _debug_print(f"GUI Backend initialized - Steam Deck: {self.system_info.is_steamdeck}")
+        logger.debug(f"GUI Backend initialized - Steam Deck: {self.system_info.is_steamdeck}")
 
     def _is_steamdeck(self):
         try:
@@ -58,7 +53,7 @@ class MainWindowBackendMixin:
             if success:
                 status = resource_manager.get_limit_status()
                 if status['target_achieved']:
-                    _debug_print(f"Resource limits optimized: file descriptors set to {status['current_soft']}")
+                    logger.debug(f"Resource limits optimized: file descriptors set to {status['current_soft']}")
                 else:
                     print(f"Resource limits improved: file descriptors increased to {status['current_soft']} (target: {status['target_limit']})")
             else:

jackify/frontends/gui/mixins/main_window_dialogs.py

@@ -11,6 +11,43 @@ from jackify.frontends.gui.dialogs.settings_dialog import SettingsDialog
 
 class MainWindowDialogsMixin:
     """Mixin for settings/about dialogs, open URL, and cleanup."""
+    def _stop_qthread(self, thread, thread_name: str, cooperative_timeout_ms: int = 5000):
+        """Stop a QThread robustly to avoid teardown crashes on app exit."""
+        if thread is None:
+            return None
+        try:
+            if not thread.isRunning():
+                return None
+        except RuntimeError:
+            return None
+
+        try:
+            thread.requestInterruption()
+        except Exception:
+            pass
+
+        try:
+            thread.quit()
+        except Exception:
+            pass
+
+        try:
+            if thread.wait(cooperative_timeout_ms):
+                return None
+        except Exception:
+            pass
+
+        try:
+            thread.terminate()
+        except Exception:
+            pass
+
+        try:
+            if not thread.wait(10000):
+                print(f"WARNING: {thread_name} still running during shutdown")
+        except Exception:
+            pass
+        return None
 
     def open_settings_dialog(self):
         try:
@@ -83,27 +120,35 @@ class MainWindowDialogsMixin:
     def cleanup_processes(self):
         try:
             if hasattr(self, '_update_thread') and self._update_thread is not None:
-                if self._update_thread.isRunning():
-                    self._update_thread.quit()
-                    self._update_thread.wait(2000)
-                self._update_thread = None
+                self._update_thread = self._stop_qthread(self._update_thread, "_update_thread")
             if hasattr(self, '_gallery_cache_preload_thread') and self._gallery_cache_preload_thread is not None:
-                if self._gallery_cache_preload_thread.isRunning():
-                    self._gallery_cache_preload_thread.quit()
-                    self._gallery_cache_preload_thread.wait(2000)
-                self._gallery_cache_preload_thread = None
+                self._gallery_cache_preload_thread = self._stop_qthread(
+                    self._gallery_cache_preload_thread,
+                    "_gallery_cache_preload_thread",
+                )
             for service in self.gui_services.values():
                 if hasattr(service, 'cleanup'):
                     service.cleanup()
             screens = [
-                self.modlist_tasks_screen, self.install_modlist_screen,
-                self.configure_new_modlist_screen, self.configure_existing_modlist_screen,
+                getattr(self, 'modlist_tasks_screen', None),
+                getattr(self, 'additional_tasks_screen', None),
+                getattr(self, 'install_modlist_screen', None),
+                getattr(self, 'install_ttw_screen', None),
+                getattr(self, 'configure_new_modlist_screen', None),
+                getattr(self, 'wabbajack_installer_screen', None),
+                getattr(self, 'configure_existing_modlist_screen', None),
+                getattr(self, 'install_mo2_screen', None),
             ]
             for screen in screens:
+                if screen is None:
+                    continue
                 if hasattr(screen, 'cleanup_processes'):
                     screen.cleanup_processes()
                 elif hasattr(screen, 'cleanup'):
                     screen.cleanup()
+                elif hasattr(screen, 'worker'):
+                    worker = getattr(screen, 'worker', None)
+                    setattr(screen, 'worker', self._stop_qthread(worker, f"{screen.__class__.__name__}.worker"))
             try:
                 subprocess.run(['pkill', '-f', 'jackify-engine'], timeout=5, capture_output=True)
             except Exception:

jackify/frontends/gui/mixins/main_window_geometry.py

@@ -7,17 +7,11 @@ from PySide6.QtWidgets import QMainWindow, QApplication
 from PySide6.QtCore import Qt, QTimer, QRect
 
 from jackify.frontends.gui.utils import get_screen_geometry, set_responsive_minimum
+import logging
 
+logger = logging.getLogger(__name__)
 ENABLE_WINDOW_HEIGHT_ANIMATION = False
 
-
-def _debug_print(message):
-    from jackify.backend.handlers.config_handler import ConfigHandler
-    ch = ConfigHandler()
-    if ch.get('debug_mode', False):
-        print(message)
-
-
 class MainWindowGeometryMixin:
     """Mixin for window geometry, save/restore, compact mode, and resize behavior."""
 
@@ -135,10 +129,10 @@ class MainWindowGeometryMixin:
                 self.showMaximized()
 
     def _on_child_resize_request(self, mode: str):
-        _debug_print(f"DEBUG: _on_child_resize_request called with mode='{mode}', current_size={self.size()}")
+        logger.debug(f"DEBUG: _on_child_resize_request called with mode='{mode}', current_size={self.size()}")
         try:
             if self.system_info and self.system_info.is_steamdeck:
-                _debug_print("DEBUG: Steam Deck detected, ignoring resize request")
+                logger.debug("DEBUG: Steam Deck detected, ignoring resize request")
                 try:
                     if hasattr(self, 'install_ttw_screen') and self.install_ttw_screen.show_details_checkbox:
                         self.install_ttw_screen.show_details_checkbox.setVisible(False)
@@ -183,7 +177,7 @@ class MainWindowGeometryMixin:
             before = self.size()
             self._programmatic_resize = True
             self.resize(self.size().width(), target_height)
-            _debug_print(f"DEBUG: Animated fallback resize from {before} to {self.size()}")
+            logger.debug(f"DEBUG: Animated fallback resize from {before} to {self.size()}")
             QTimer.singleShot(100, lambda: setattr(self, '_programmatic_resize', False))
             return
         start_rect = self.geometry()

jackify/frontends/gui/mixins/main_window_startup.py

@@ -7,14 +7,9 @@ import sys
 
 from PySide6.QtCore import QThread, Signal, QTimer
 from PySide6.QtWidgets import QDialog
+import logging
 
-
-def _debug_print(message):
-    from jackify.backend.handlers.config_handler import ConfigHandler
-    ch = ConfigHandler()
-    if ch.get('debug_mode', False):
-        print(message)
-
+logger = logging.getLogger(__name__)
 
 class MainWindowStartupMixin:
     """Mixin for startup and background tasks."""
@@ -38,23 +33,23 @@ class MainWindowStartupMixin:
                     if metadata:
                         modlists_with_mods = sum(1 for m in metadata.modlists if hasattr(m, 'mods') and m.mods)
                         if modlists_with_mods > 0:
-                            _debug_print(f"Gallery cache ready ({modlists_with_mods} modlists with mods)")
+                            logger.debug(f"Gallery cache ready ({modlists_with_mods} modlists with mods)")
                         else:
-                            _debug_print("Gallery cache updated")
+                            logger.debug("Gallery cache updated")
                     else:
-                        _debug_print("Failed to load gallery cache")
+                        logger.debug("Failed to load gallery cache")
                 except Exception as e:
-                    _debug_print(f"Gallery cache preload error: {str(e)}")
+                    logger.debug(f"Gallery cache preload error: {str(e)}")
 
         self._gallery_cache_preload_thread = GalleryCachePreloadThread()
         self._gallery_cache_preload_thread.start()
-        _debug_print("Started background gallery cache preload")
+        logger.debug("Started background gallery cache preload")
 
     def _check_protontricks_on_startup(self):
         try:
             method = self.config_handler.get('component_installation_method', 'winetricks')
             if method != 'system_protontricks':
-                _debug_print(f"Skipping protontricks check (current method: {method}).")
+                logger.debug(f"Skipping protontricks check (current method: {method}).")
                 return
             is_installed, installation_type, details = self.protontricks_service.detect_protontricks()
             if not is_installed:
@@ -66,13 +61,13 @@ class MainWindowStartupMixin:
                     print("User chose to exit due to missing protontricks")
                     sys.exit(1)
             else:
-                _debug_print(f"Protontricks detected: {details}")
+                logger.debug(f"Protontricks detected: {details}")
         except Exception as e:
             print(f"Error checking protontricks: {e}")
 
     def _check_for_updates_on_startup(self):
         try:
-            _debug_print("Checking for updates on startup...")
+            logger.debug("Checking for updates on startup...")
 
             class UpdateCheckThread(QThread):
                 update_available = Signal(object)
@@ -87,7 +82,7 @@ class MainWindowStartupMixin:
                         self.update_available.emit(update_info)
 
             def on_update_available(update_info):
-                _debug_print(f"Update available: v{update_info.version}")
+                logger.debug(f"Update available: v{update_info.version}")
 
                 def show_update_dialog():
                     from jackify.frontends.gui.dialogs.update_dialog import UpdateDialog
@@ -99,4 +94,4 @@ class MainWindowStartupMixin:
             self._update_thread.update_available.connect(on_update_available)
             self._update_thread.start()
         except Exception as e:
-            _debug_print(f"Error setting up update check: {e}")
+            logger.debug(f"Error setting up update check: {e}")

jackify/frontends/gui/mixins/main_window_ui.py

@@ -1,9 +1,13 @@
 """
 Main window UI setup mixin.
 Stacked widget, screens, bottom bar, screen change handling.
+
+Screens 1-9 are lazy-initialised: placeholder QWidgets are inserted at startup
+and swapped for real screens on first navigation.  Only index 0 (MainMenu) is
+created eagerly because it is always visible first.
 """
 
-import sys
+import logging
 
 from PySide6.QtWidgets import (
     QWidget, QLabel, QVBoxLayout, QHBoxLayout,
@@ -15,81 +19,43 @@ from jackify import __version__
 from jackify.frontends.gui.shared_theme import DEBUG_BORDERS
 from jackify.frontends.gui.widgets.feature_placeholder import FeaturePlaceholder
 
+logger = logging.getLogger(__name__)
 
-def _debug_print(message):
-    from jackify.backend.handlers.config_handler import ConfigHandler
-    ch = ConfigHandler()
-    if ch.get('debug_mode', False):
-        print(message)
+
+class _LazyPlaceholder(QWidget):
+    """Sentinel widget used in place of a not-yet-initialised screen."""
 
 
 class MainWindowUIMixin:
     """Mixin for main window UI: stacked widget, screens, bottom bar."""
 
     def _setup_ui(self, dev_mode=False):
+        self._dev_mode = dev_mode
         self.stacked_widget = QStackedWidget()
-        from jackify.frontends.gui.screens import (
-            MainMenu, ModlistTasksScreen, AdditionalTasksScreen,
-            InstallModlistScreen, ConfigureNewModlistScreen, ConfigureExistingModlistScreen,
-        )
-        from jackify.frontends.gui.screens.install_ttw import InstallTTWScreen
-        from jackify.frontends.gui.screens.wabbajack_installer import WabbajackInstallerScreen
 
+        # Only MainMenu is created eagerly (always shown first).
+        from jackify.frontends.gui.screens import MainMenu
         self.main_menu = MainMenu(stacked_widget=self.stacked_widget, dev_mode=dev_mode)
-        self.feature_placeholder = FeaturePlaceholder(stacked_widget=self.stacked_widget)
-        self.modlist_tasks_screen = ModlistTasksScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, dev_mode=dev_mode
-        )
-        self.additional_tasks_screen = AdditionalTasksScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, system_info=self.system_info
-        )
-        self.install_modlist_screen = InstallModlistScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, system_info=self.system_info
-        )
-        self.configure_new_modlist_screen = ConfigureNewModlistScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, system_info=self.system_info
-        )
-        self.configure_existing_modlist_screen = ConfigureExistingModlistScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, system_info=self.system_info
-        )
-        self.install_ttw_screen = InstallTTWScreen(
-            stacked_widget=self.stacked_widget, main_menu_index=0, system_info=self.system_info
-        )
-        self.wabbajack_installer_screen = WabbajackInstallerScreen(
-            stacked_widget=self.stacked_widget, additional_tasks_index=3, system_info=self.system_info
-        )
+        self.stacked_widget.addWidget(self.main_menu)          # index 0
 
-        try:
-            self.install_ttw_screen.resize_request.connect(self._on_child_resize_request)
-        except Exception:
-            pass
-        try:
-            self.install_modlist_screen.resize_request.connect(self._on_child_resize_request)
-        except Exception:
-            pass
-        try:
-            self.configure_new_modlist_screen.resize_request.connect(self._on_child_resize_request)
-        except Exception:
-            pass
-        try:
-            self.configure_existing_modlist_screen.resize_request.connect(self._on_child_resize_request)
-        except Exception:
-            pass
-        try:
-            self.wabbajack_installer_screen.resize_request.connect(self._on_child_resize_request)
-        except Exception:
-            pass
+        # Indexes 1-9: insert lightweight placeholders now; real screens on demand.
+        for _ in range(9):
+            self.stacked_widget.addWidget(_LazyPlaceholder())
 
-        self.stacked_widget.addWidget(self.main_menu)
-        self.stacked_widget.addWidget(self.feature_placeholder)
-        self.stacked_widget.addWidget(self.modlist_tasks_screen)
-        self.stacked_widget.addWidget(self.additional_tasks_screen)
-        self.stacked_widget.addWidget(self.install_modlist_screen)
-        self.stacked_widget.addWidget(self.install_ttw_screen)
-        self.stacked_widget.addWidget(self.configure_new_modlist_screen)
-        self.stacked_widget.addWidget(self.wabbajack_installer_screen)
-        self.stacked_widget.addWidget(self.configure_existing_modlist_screen)
+        # Factory map: index -> callable that creates and caches the real screen.
+        self._screen_factories = {
+            1: self._make_feature_placeholder,
+            2: self._make_modlist_tasks_screen,
+            3: self._make_additional_tasks_screen,
+            4: self._make_install_modlist_screen,
+            5: self._make_install_ttw_screen,
+            6: self._make_configure_new_modlist_screen,
+            7: self._make_wabbajack_installer_screen,
+            8: self._make_configure_existing_modlist_screen,
+            9: self._make_install_mo2_screen,
+        }
 
+        self.stacked_widget.currentChanged.connect(self._lazy_init_screen)
         self.stacked_widget.currentChanged.connect(self._debug_screen_change)
         self.stacked_widget.currentChanged.connect(self._maintain_fullscreen_on_deck)
 
@@ -141,6 +107,121 @@ class MainWindowUIMixin:
         self.stacked_widget.setCurrentIndex(0)
         self._check_protontricks_on_startup()
 
+    def _lazy_init_screen(self, index: int) -> None:
+        """Swap placeholder at *index* for the real screen on first visit."""
+        if index == 0:
+            return
+        widget = self.stacked_widget.widget(index)
+        if not isinstance(widget, _LazyPlaceholder):
+            return
+        factory = self._screen_factories.get(index)
+        if factory is None:
+            return
+        real_screen = factory()
+        # Block signals for the entire swap including setCurrentWidget so that:
+        # (a) Qt's auto-current-change on removeWidget doesn't cascade into the
+        #     other placeholders via a re-entrant _lazy_init_screen call, and
+        # (b) setCurrentWidget does not fire a second currentChanged — the outer
+        #     currentChanged (which triggered this lazy init) is still being
+        #     dispatched and will reach _debug_screen_change with the real screen
+        #     already in place, so reset_screen_to_defaults runs exactly once.
+        self.stacked_widget.blockSignals(True)
+        self.stacked_widget.removeWidget(widget)
+        widget.deleteLater()
+        self.stacked_widget.insertWidget(index, real_screen)
+        self.stacked_widget.setCurrentWidget(real_screen)
+        self.stacked_widget.blockSignals(False)
+
+    def _make_feature_placeholder(self):
+        screen = FeaturePlaceholder(stacked_widget=self.stacked_widget)
+        self.feature_placeholder = screen
+        return screen
+
+    def _make_modlist_tasks_screen(self):
+        from jackify.frontends.gui.screens import ModlistTasksScreen
+        screen = ModlistTasksScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=0, dev_mode=self._dev_mode
+        )
+        self.modlist_tasks_screen = screen
+        return screen
+
+    def _make_additional_tasks_screen(self):
+        from jackify.frontends.gui.screens import AdditionalTasksScreen
+        screen = AdditionalTasksScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=0,
+            system_info=self.system_info, install_mo2_screen_index=9,
+        )
+        self.additional_tasks_screen = screen
+        return screen
+
+    def _make_install_modlist_screen(self):
+        from jackify.frontends.gui.screens import InstallModlistScreen
+        screen = InstallModlistScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=2, system_info=self.system_info
+        )
+        self.install_modlist_screen = screen
+        try:
+            screen.resize_request.connect(self._on_child_resize_request)
+        except Exception:
+            pass
+        return screen
+
+    def _make_install_ttw_screen(self):
+        from jackify.frontends.gui.screens.install_ttw import InstallTTWScreen
+        screen = InstallTTWScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=3, system_info=self.system_info
+        )
+        self.install_ttw_screen = screen
+        try:
+            screen.resize_request.connect(self._on_child_resize_request)
+        except Exception:
+            pass
+        return screen
+
+    def _make_configure_new_modlist_screen(self):
+        from jackify.frontends.gui.screens import ConfigureNewModlistScreen
+        screen = ConfigureNewModlistScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=2, system_info=self.system_info
+        )
+        self.configure_new_modlist_screen = screen
+        try:
+            screen.resize_request.connect(self._on_child_resize_request)
+        except Exception:
+            pass
+        return screen
+
+    def _make_wabbajack_installer_screen(self):
+        from jackify.frontends.gui.screens.wabbajack_installer import WabbajackInstallerScreen
+        screen = WabbajackInstallerScreen(
+            stacked_widget=self.stacked_widget, additional_tasks_index=3, system_info=self.system_info
+        )
+        self.wabbajack_installer_screen = screen
+        try:
+            screen.resize_request.connect(self._on_child_resize_request)
+        except Exception:
+            pass
+        return screen
+
+    def _make_configure_existing_modlist_screen(self):
+        from jackify.frontends.gui.screens import ConfigureExistingModlistScreen
+        screen = ConfigureExistingModlistScreen(
+            stacked_widget=self.stacked_widget, main_menu_index=2, system_info=self.system_info
+        )
+        self.configure_existing_modlist_screen = screen
+        try:
+            screen.resize_request.connect(self._on_child_resize_request)
+        except Exception:
+            pass
+        return screen
+
+    def _make_install_mo2_screen(self):
+        from jackify.frontends.gui.screens.install_mo2_screen import InstallMO2Screen
+        screen = InstallMO2Screen(
+            stacked_widget=self.stacked_widget, additional_tasks_index=3, system_info=self.system_info
+        )
+        self.install_mo2_screen = screen
+        return screen
+
     def _debug_screen_change(self, index):
         try:
             idx = int(index) if index is not None else 0
@@ -167,21 +248,22 @@ class MainWindowUIMixin:
                 6: "Configure New Modlist",
                 7: "Wabbajack Installer",
                 8: "Configure Existing Modlist",
+                9: "Install MO2 Screen",
             }
             screen_name = screen_names.get(idx, f"Unknown Screen (Index {idx})")
             widget = self.stacked_widget.widget(idx)
         except (OverflowError, TypeError, ValueError):
             return
         widget_class = widget.__class__.__name__ if widget else "None"
-        print(f"[DEBUG] Screen changed to Index {idx}: {screen_name} (Widget: {widget_class})", file=sys.stderr)
+        logger.debug(f"Screen changed to Index {idx}: {screen_name} (Widget: {widget_class})")
         if idx == 4:
-            print("   Install Modlist Screen details:", file=sys.stderr)
-            print(f"      - Widget type: {type(widget)}", file=sys.stderr)
-            print(f"      - Widget file: {widget.__class__.__module__}", file=sys.stderr)
+            logger.debug("Install Modlist Screen details:")
+            logger.debug(f"  Widget type: {type(widget)}")
+            logger.debug(f"  Widget file: {widget.__class__.__module__}")
             if hasattr(widget, 'windowTitle'):
-                print(f"      - Window title: {widget.windowTitle()}", file=sys.stderr)
+                logger.debug(f"  Window title: {widget.windowTitle()}")
             if hasattr(widget, 'layout'):
                 layout = widget.layout()
                 if layout:
-                    print(f"      - Layout type: {type(layout)}", file=sys.stderr)
-                    print(f"      - Layout children count: {layout.count()}", file=sys.stderr)
+                    logger.debug(f"  Layout type: {type(layout)}")
+                    logger.debug(f"  Layout children count: {layout.count()}")