setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/gui/main_window.py

@@ -128,7 +128,8 @@ from PyQt6.QtGui import (QPixmap, QColor, QIcon, QKeySequence, QShortcut,
 )
 
 # ----- QtCore -----
-from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker,  QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject
+from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker,  QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject,
+    QPropertyAnimation, QEasingCurve, QElapsedTimer
 )
 
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -186,7 +187,7 @@ from setiastro.saspro.resources import (
     platesolve_path, psf_path, supernova_path, starregistration_path,
     stacking_path, pedestal_icon_path, starspike_path, aperture_path,
     jwstpupil_path, signature_icon_path, livestacking_path, hrdiagram_path,
-    convoicon_path, spcc_icon_path, sasp_data_path, exoicon_path, peeker_icon,
+    convoicon_path, spcc_icon_path, sasp_data_path, exoicon_path, peeker_icon,rotatearbitrary_path,
     dse_icon_path, astrobin_filters_csv_path, isophote_path, statstretch_path,
     starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path,
     nbtorgb_path, freqsep_path, contsub_path, halo_path, cosmic_path,
@@ -201,9 +202,32 @@ from setiastro.saspro.resources import (
 import faulthandler
 
 def _install_crash_logging():
-    faulthandler.enable(all_threads=True)
+    # Ensure logging is configured before we try to use it
+    if not logging.getLogger().hasHandlers():
+        logging.basicConfig(
+            level=logging.WARNING,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[logging.StreamHandler(sys.stderr)]
+        )
+    
+    try:
+        faulthandler.enable(all_threads=True)
+    except (PermissionError, OSError) as e:
+        # On macOS, faulthandler.enable() might fail due to security restrictions
+        # We can still continue without it as it's primarily for debugging
+        try:
+            logging.warning(f"Could not enable faulthandler: {e}")
+        except Exception:
+            # Fallback if logging isn't configured yet
+            print(f"WARNING: Could not enable faulthandler: {e}")
+    
     def _excepthook(t, v, tb):
-        logging.critical("Uncaught exception", exc_info=(t, v, tb))
+        try:
+            logging.critical("Uncaught exception", exc_info=(t, v, tb))
+        except Exception:
+            # Fallback if logging fails
+            print(f"CRITICAL: Uncaught exception: {t.__name__}: {v}")
+            traceback.print_tb(tb)
         try:
             faulthandler.dump_traceback(file=sys.stderr)
         except Exception:
@@ -272,6 +296,16 @@ class AstroSuiteProMainWindow(
     def __init__(self, image_manager=None, parent=None,
                  version: str = "dev", build_timestamp: str = "dev"):
         super().__init__(parent)
+        # Prevent white flash: start strictly transparent and force dark bg
+        self.setWindowOpacity(0.0)
+        self.setStyleSheet("QMainWindow { background-color: #0F0F19; }")
+
+        # --- Usage Stats ---
+        self._session_start_time = time.time()
+        self._stats_timer = QTimer(self)
+        self._stats_timer.timeout.connect(self._update_usage_stats)
+        self._stats_timer.start(60000)  # Update every minute
+        
         from setiastro.saspro.doc_manager import DocManager
         from setiastro.saspro.window_shelf import WindowShelf, MinimizeInterceptor
         from setiastro.saspro.imageops.mdi_snap import MdiSnapController
@@ -285,7 +319,13 @@ class AstroSuiteProMainWindow(
         self.setWindowIcon(self.app_icon)
         self._doc = None
         self._force_close_all = False
-        self.settings = QSettings()  # reuse everywhere
+        self._is_restarting = False  # Flag to bypass exit confirmation on restart
+        self.settings = QSettings("SetiAstro", "SetiAstroSuitePro")
+        
+        # Optimization: Cache the settings dialog for instant opening
+        self._settings_dlg_cache = None
+        # Pre-load settings dialog after 2.5 seconds (background)
+        QTimer.singleShot(1000, self._preload_settings)
         self._last_active_view = None
         self._current_active_sw = None
         self._last_active_sw = None
@@ -396,6 +436,7 @@ class AstroSuiteProMainWindow(
         self._init_console_dock()
         self._init_header_viewer_dock()
         self._init_layers_dock()
+        self._init_resource_monitor_overlay()
         self._shutting_down = False
         self._init_status_log_dock()
         self._init_log_dock()
@@ -426,26 +467,23 @@ class AstroSuiteProMainWindow(
         self.mdi.linkViewDropped.connect(self._on_linkview_drop)
 
         self.doc_manager.set_mdi_area(self.mdi)
-
+        # Coalesce undo/redo label refreshes
+        self._undo_redo_refresh_pending = False
+        self._undo_redo_refresh_timer = QTimer(self)
+        self._undo_redo_refresh_timer.setSingleShot(True)
+        self._undo_redo_refresh_timer.timeout.connect(self._do_undo_redo_label_refresh)
         # Keep the toolbar in sync whenever anything relevant changes
-        self.doc_manager.documentAdded.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.documentRemoved.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.imageRegionUpdated.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.previewRepaintRequested.connect(lambda *_: self.update_undo_redo_action_labels())
-
-        # Also refresh when the active subwindow changes
-        try:
-            self.mdi.subWindowActivated.connect(lambda *_: self.update_undo_redo_action_labels())
-        except Exception:
-            pass
-
-        try:
-            QApplication.instance().focusChanged.connect(
-                lambda *_: QTimer.singleShot(0, self.update_undo_redo_action_labels)
-            )
-        except Exception:
-            pass
-
+        self.doc_manager.documentAdded.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.documentRemoved.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.imageRegionUpdated.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.previewRepaintRequested.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.mdi.subWindowActivated.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+
+        # optional: keep, but schedule (or remove entirely)
+        #try:
+        #    QApplication.instance().focusChanged.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        #except Exception:
+        #    pass
         self.shortcuts.load_shortcuts()
         self._ensure_persistent_names() 
         self._restore_window_placement()
@@ -529,6 +567,45 @@ class AstroSuiteProMainWindow(
 
     # _init_log_dock, _hook_stdout_stderr, and _append_log_text are now in DockMixin
 
+    def _schedule_undo_redo_label_refresh(self):
+        # Coalesce many triggers into one UI update
+        if getattr(self, "_undo_redo_refresh_pending", False):
+            return
+        self._undo_redo_refresh_pending = True
+        # 0ms is fine *if* it’s a real attribute timer (not a local)
+        self._undo_redo_refresh_timer.start(0)
+
+    def _do_undo_redo_label_refresh(self):
+        self._undo_redo_refresh_pending = False
+        try:
+            self.update_undo_redo_action_labels()
+        except Exception:
+            pass
+
+
+    def _rebuild_menus_for_language(self):
+        """Rebuild menus after language change to apply new translations."""
+        try:
+            # Clear the menubar and rebuild it
+            mb = self.menuBar()
+            mb.clear()
+            self._init_menubar()
+        except Exception:
+            pass
+
+    def createPopupMenu(self):
+        """Override to add System Monitor to the toolbar/dock context menu."""
+        # Get the default popup menu from QMainWindow
+        menu = super().createPopupMenu()
+        if menu is None:
+            menu = QMenu(self)
+        
+        # Add System Monitor toggle if available
+        if hasattr(self, "act_toggle_monitor") and self.act_toggle_monitor is not None:
+            menu.addSeparator()
+            menu.addAction(self.act_toggle_monitor)
+        
+        return menu
 
     def _on_sw_activated(self, sw):
         if not sw:
@@ -544,7 +621,7 @@ class AstroSuiteProMainWindow(
             doc.changed.connect(self.update_undo_redo_action_labels)
         except Exception:
             pass
-        self.update_undo_redo_action_labels()
+        self._schedule_undo_redo_label_refresh()
 
     def _promote_roi_preview_to_real_doc(self, st: dict, preview_doc) -> None:
         """
@@ -1142,11 +1219,11 @@ class AstroSuiteProMainWindow(
         global_pos = lw.viewport().mapToGlobal(pos)
 
         menu = QMenu(lw)
-        act_copy_selected = menu.addAction("Copy Selected")
-        act_copy_all      = menu.addAction("Copy All")
+        act_copy_selected = menu.addAction(self.tr("Copy Selected"))
+        act_copy_all      = menu.addAction(self.tr("Copy All"))
         menu.addSeparator()
-        act_select_all    = menu.addAction("Select All Lines")
-        act_clear         = menu.addAction("Clear Console")
+        act_select_all    = menu.addAction(self.tr("Select All Lines"))
+        act_clear         = menu.addAction(self.tr("Clear Console"))
 
         action = menu.exec(global_pos)
         if action is None:
@@ -1740,7 +1817,7 @@ class AstroSuiteProMainWindow(
 
             show_view_bundles(self)
         except Exception as e:
-            QMessageBox.warning(self, "View Bundles", f"Open failed:\n{e}")
+            QMessageBox.warning(self, self.tr("View Bundles"), f"Open failed:\n{e}")
 
     def _open_function_bundles(self):
         from setiastro.saspro.function_bundle import show_function_bundles
@@ -1748,7 +1825,7 @@ class AstroSuiteProMainWindow(
 
             show_function_bundles(self)
         except Exception as e:
-            QMessageBox.warning(self, "Function Bundles", f"Open failed:\n{e}")
+            QMessageBox.warning(self, self.tr("Function Bundles"), f"Open failed:\n{e}")
 
     def _open_scripts_folder(self):
         if hasattr(self, "scriptman"):
@@ -1784,6 +1861,7 @@ class AstroSuiteProMainWindow(
             actions = self._collect_all_qactions()
         except Exception:
             actions = self.findChildren(QAction)
+
         for act in actions:
             for seq in _seqs_for_action(act):
                 rows.append((_qs_to_str(seq), _describe_action(act), _where_for_action(act)))
@@ -1794,6 +1872,12 @@ class AstroSuiteProMainWindow(
             if seq and not seq.isEmpty():
                 rows.append((_qs_to_str(seq), _describe_shortcut(sc), _where_for_shortcut(sc)))
 
+        # 3) App-level shortcuts not represented by QAction/QShortcut
+        try:
+            add_extra_shortcuts(rows)  # ✅ Ctrl+K, Ctrl+Alt+M, etc.
+        except Exception:
+            pass
+
         # De-duplicate and sort by shortcut text
         rows = _uniq_keep_order(rows)
         rows.sort(key=lambda r: (r[0].lower(), r[1].lower()))
@@ -1803,43 +1887,43 @@ class AstroSuiteProMainWindow(
         # Manual list (extend anytime). Format: (Gesture, Context, Effect)
         rows = [
             # Command search
-            ("A", "Display Stretch", "Toggle Display Auto-Stretch"),
-            ("Ctrl+I", "Invert", "Invert the Image"),
-            ("Ctrl+Shift+P", "Command Search", "Focus the command search bar; Enter runs first match"),
+            ("A", "Display Stretch", self.tr("Toggle Display Auto-Stretch")),
+            ("Ctrl+I", "Invert", self.tr("Invert the Image")),
+            ("Ctrl+Shift+P", "Command Search", self.tr("Focus the command search bar; Enter runs first match")),
 
             # View Icon
-            ("Drag view -> Off to Canvas", "View", "Duplicate Image"),
-            ("Drag view -> On to Other Image", "View", "Copy Zoom and Pan"),
-            ("Shift+Drag -> On to Other Image", "View", "Apply that image to the other as a mask"), 
-            ("Ctrl+Drag -> On to Other Image", "View", "Copy Astrometric Solution"),            
+            ("Drag view -> Off to Canvas", "View", self.tr("Duplicate Image")),
+            ("Drag view -> On to Other Image", "View", self.tr("Copy Zoom and Pan")),
+            ("Shift+Drag -> On to Other Image", "View", self.tr("Apply that image to the other as a mask")), 
+            ("Ctrl+Drag -> On to Other Image", "View", self.tr("Copy Astrometric Solution")),            
 
             # View zoom
-            ("Ctrl+1", "View", "Zoom to 100% (1:1)"),
-            ("Ctrl+0", "View", "Fit image to current window"),
-            ("Ctrl++", "View", "Zoom In"),
-            ("Ctrl+-", "View", "Zoom Out"),
+            ("Ctrl+1", "View", self.tr("Zoom to 100% (1:1)")),
+            ("Ctrl+0", "View", self.tr("Fit image to current window")),
+            ("Ctrl++", "View", self.tr("Zoom In")),
+            ("Ctrl+-", "View", self.tr("Zoom Out")),
 
             # Window switching
-            ("Ctrl+PgDown", "MDI", "Switch to previously active view"),
-            ("Ctrl+PgUp",   "MDI", "Switch to next active view"),
+            ("Ctrl+PgDown", "MDI", self.tr("Switch to previously active view")),
+            ("Ctrl+PgUp",   "MDI", self.tr("Switch to next active view")),
 
             # Shortcuts canvas + buttons
-            ("Alt+Drag (toolbar button)", "Toolbar", "Create a desktop shortcut for that action"),
-            ("Alt+Drag (shortcut button -> view)", "Shortcuts", "Headless apply the shortcut's command/preset to a view"),
-            ("Ctrl/Shift+Click", "Shortcuts", "Multi-select shortcut buttons"),
-            ("Drag (selection)", "Shortcuts", "Move selected shortcut buttons"),
-            ("Delete / Backspace", "Shortcuts", "Delete selected shortcut buttons"),
-            ("Ctrl+A", "Shortcuts", "Select all shortcut buttons"),
-            ("Double-click empty area", "MDI background", "Open files dialog"),
+            ("Alt+Drag (toolbar button)", "Toolbar", self.tr("Create a desktop shortcut for that action")),
+            ("Alt+Drag (shortcut button -> view)", "Shortcuts", self.tr("Headless apply the shortcut's command/preset to a view")),
+            ("Ctrl/Shift+Click", "Shortcuts", self.tr("Multi-select shortcut buttons")),
+            ("Drag (selection)", "Shortcuts", self.tr("Move selected shortcut buttons")),
+            ("Delete / Backspace", "Shortcuts", self.tr("Delete selected shortcut buttons")),
+            ("Ctrl+A", "Shortcuts", self.tr("Select all shortcut buttons")),
+            ("Double-click empty area", "MDI background", self.tr("Open files dialog")),
 
             # Layers dock
-            ("Drag view -> Layers list", "Layers", "Add dragged view as a new layer (on top)"),
-            ("Shift+Drag mask -> Layers list", "Layers", "Attach dragged image as mask to the selected layer"),
+            ("Drag view -> Layers list", "Layers", self.tr("Add dragged view as a new layer (on top)")),
+            ("Shift+Drag mask -> Layers list", "Layers", self.tr("Attach dragged image as mask to the selected layer")),
 
             # Crop tool
-            ("Click-drag", "Crop Tool", "Draw a crop rectangle"),
-            ("Drag corner handles", "Crop Tool", "Resize crop rectangle"),
-            ("Shift+Drag on box", "Crop Tool", "Rotate crop rectangle"),
+            ("Click-drag", "Crop Tool", self.tr("Draw a crop rectangle")),
+            ("Drag corner handles", "Crop Tool", self.tr("Resize crop rectangle")),
+            ("Shift+Drag on box", "Crop Tool", self.tr("Rotate crop rectangle")),
         ]
         return rows
 
@@ -1886,7 +1970,11 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
-    def _confirm_discard(self, title="New Project", msg="This will close all views and clear desktop shortcuts. Continue?"):
+    def _confirm_discard(self, title=None, msg=None):
+        if title is None:
+            title = self.tr("New Project")
+        if msg is None:
+            msg = self.tr("This will close all views and clear desktop shortcuts. Continue?")
         btn = QMessageBox.question(self, title, msg,
                                 QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                                 QMessageBox.StandardButton.No)
@@ -1894,8 +1982,8 @@ class AstroSuiteProMainWindow(
 
     def _clear_views_keep_shortcuts(self):
         if not self._confirm_discard(
-            title="Clear All Views",
-            msg="Close all views and documents? Desktop shortcuts will be preserved."
+            title=self.tr("Clear All Views"),
+            msg=self.tr("Close all views and documents? Desktop shortcuts will be preserved.")
         ):
             return
 
@@ -1952,7 +2040,7 @@ class AstroSuiteProMainWindow(
         if getattr(self, "doc_manager", None) and self.doc_manager._docs:
             if not self._confirm_discard(
                 title=title,
-                msg=(
+                msg=self.tr(
                     "Loading a project will close current views and replace desktop shortcuts.\n"
                     "Continue?"
                 ),
@@ -2072,9 +2160,30 @@ class AstroSuiteProMainWindow(
             self._refresh_mask_action_states()
 
 
+    # ---------------- Settings Caching ----------------
+    def _preload_settings(self):
+        """Build the SettingsDialog in the background so it opens instantly."""
+        if getattr(self, "_settings_dlg_cache", None) is None:
+            from setiastro.saspro.ops.settings import SettingsDialog
+            try:
+                self._settings_dlg_cache = SettingsDialog(self, self.settings)
+            except Exception as e:
+                # Log error but don't crash if preload fails
+                print(f"Error preloading settings: {e}")
+
     def _open_settings(self):
         from setiastro.saspro.ops.settings import SettingsDialog
-        dlg = SettingsDialog(self, self.settings)
+        
+        # Create cache if it doesn't exist (e.g. opened before preload timer fired)
+        if getattr(self, "_settings_dlg_cache", None) is None:
+            self._settings_dlg_cache = SettingsDialog(self, self.settings)
+
+        dlg = self._settings_dlg_cache
+        
+        # Refresh UI from current settings before showing
+        if hasattr(dlg, "refresh_ui"):
+            dlg.refresh_ui()
+            
         if dlg.exec():
             # (Optional) react to changes if needed
             pass
@@ -2592,8 +2701,8 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
-        # ðŸ'‡ this is the key: stay on top
-        dlg.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+        # this is the key: stay on top
+        # dlg.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
 
         dlg.show()
         dlg.raise_()
@@ -4263,7 +4372,7 @@ class AstroSuiteProMainWindow(
         dlg.show()
 
     def _open_whats_in_my_sky(self):
-        from wims import WhatsInMySkyDialog
+        from setiastro.saspro.wims import WhatsInMySkyDialog
         dlg = WhatsInMySkyDialog(
             parent=self,
             wims_path=wims_path,          # window icon
@@ -4275,7 +4384,7 @@ class AstroSuiteProMainWindow(
 
     def _open_wimi(self):
         # Lazy import to avoid loading lightkurve at startup (~12s)
-        from wimi import WIMIDialog
+        from setiastro.saspro.wimi import WIMIDialog
         dlg = WIMIDialog(
             parent=self,
             settings=getattr(self, "settings", None),
@@ -5446,6 +5555,10 @@ class AstroSuiteProMainWindow(
                 "rotate_180": "geom_rotate_180",
                 "geom_rotate_180": "geom_rotate_180",
 
+                "rotate_any": "geom_rotate_any",
+                "rotate_arbitrary": "geom_rotate_any",
+                "geom_rotate_any": "geom_rotate_any",
+
                 "invert": "geom_invert",
                 "geom_invert": "geom_invert",
 
@@ -6446,6 +6559,17 @@ class AstroSuiteProMainWindow(
                 QMessageBox.warning(self, "Rotate 180Â deg", str(e))
             return
 
+        if cid == "geom_rotate_any":
+            try:
+                angle = float(preset.get("angle_deg", preset.get("angle", 0.0)))
+                called = _call_any(["_apply_geom_rot_any_to_doc"], doc, angle_deg=angle)
+                if not called:
+                    raise RuntimeError("No rotate-any apply method found")
+                self._log(f"Rotate ({angle:g}°) applied to '{target_sw.windowTitle()}'")
+            except Exception as e:
+                QMessageBox.warning(self, "Rotate...", str(e))
+            return
+
         if cid == "geom_rescale":
             try:
                 factor = float(preset.get("factor", 1.0))
@@ -7251,7 +7375,7 @@ class AstroSuiteProMainWindow(
             self._search_dock = None
 
         # --- Right-side mini dock with the search box ---
-        self._search_dock = QDockWidget("Command Search", self)
+        self._search_dock = QDockWidget(self.tr("Command Search"), self)
         self._search_dock.setObjectName("CommandSearchDock")
         # âœ... Allow moving/closing like other panels
         self._search_dock.setAllowedAreas(
@@ -7466,7 +7590,7 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
-            try: self.update_undo_redo_action_labels()
+            try: self._schedule_undo_redo_label_refresh()
             except Exception as e:
                 import logging
                 logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
@@ -7726,6 +7850,90 @@ class AstroSuiteProMainWindow(
         flags |= Qt.WindowType.WindowMaximizeButtonHint
         sw.setWindowFlags(flags)
 
+        # -------------------------------------------------------------------------
+        # Explicitly size the window to valid dimensions so it doesn't default
+        # to "maximized" or "full MDI area" if the previous window was large.
+        # We target ~60% of the viewport height, clamped to sane bounds.
+        # -------------------------------------------------------------------------
+        vp = self.mdi.viewport()
+        area = vp.rect() if vp else self.mdi.rect()
+        
+        # Determine aspect ratio
+        img_w = img_h = None
+        try:
+            img_w, img_h = self._infer_image_size(view)
+        except Exception:
+            pass
+
+        if not img_w or not img_h:
+            aspect = 1.0
+        else:
+            aspect = float(img_w) / float(img_h)
+
+        # Clamp aspect
+        aspect = max(0.3, min(aspect, 4.0))
+
+        target_h = int(area.height() * 0.6)
+        target_w = int(target_h * aspect)
+        
+        # Ensure it fits within the area (with some margin)
+        max_w = int(area.width() * 0.9)
+        max_h = int(area.height() * 0.9)
+        
+        if target_w > max_w:
+            target_w = max_w
+            # Recalculate height to preserve aspect, if possible
+            target_h = int(target_w / aspect)
+        
+        if target_h > max_h:
+            target_h = max_h
+
+        # Enforce minimums
+        target_w = max(200, target_w)
+        target_h = max(200, target_h)
+
+        sw.resize(target_w, target_h)
+        sw.showNormal()  # CRITICAL: clears any "maximized" flag from previous active window
+
+        # -------------------------------------------------------------------------
+        # Smart Cascade: Position relative to the *currently active* window
+        # (before we make the new one active).
+        # -------------------------------------------------------------------------
+        new_x, new_y = 0, 0
+        
+        # Get dominant/active window *before* we activate the new one
+        active = self.mdi.activeSubWindow()
+        if active and active.isVisible() and not (active.windowState() & Qt.WindowState.WindowMinimized):
+            # Cascade from the active window
+            geo = active.geometry()
+            new_x = geo.x() + 30
+            new_y = geo.y() + 30
+        else:
+            # Fallback: try to find the "last added" visible window to cascade from
+            # (useful if active is None but windows exist)
+            try:
+                subs = [s for s in self.mdi.subWindowList() if s.isVisible() and s is not sw]
+                if subs:
+                    # simplistic "last created" might be at end of list
+                    last = subs[-1]
+                    geo = last.geometry()
+                    new_x = geo.x() + 30
+                    new_y = geo.y() + 30
+            except Exception:
+                pass
+
+        # Bounds check: don't let it drift completely off-screen
+        # (allow valid title bar to be visible at least)
+        if (new_x + target_w > area.width() + 50) or (new_y + 50 > area.height()):
+            new_x = 0
+            new_y = 0
+        
+        # Clamp to 0 if negative for some reason
+        new_x = max(0, new_x)
+        new_y = max(0, new_y)
+
+        sw.move(new_x, new_y)
+
         # ❌ removed the "fill MDI viewport" block - we *don't* want full-monitor first window
 
         # Show / activate
@@ -7870,7 +8078,7 @@ class AstroSuiteProMainWindow(
         # If no subwindows remain, clear all "active doc" UI bits, including header
         if not self.mdi.subWindowList():
             self.currentDocumentChanged.emit(None)   # drives HeaderViewerDock.set_document(None)
-            self.update_undo_redo_action_labels()
+            self._schedule_undo_redo_label_refresh()
             self._hdr_refresh_timer.start(0)       # belt-and-suspenders for manual widgets
             # If your dock has its own set_document, call it explicitly too
             hv = getattr(self, "header_viewer", None)
@@ -8212,19 +8420,20 @@ class AstroSuiteProMainWindow(
 
         # Misc UI refreshes (guarded)
         try:
-            self.update_undo_redo_action_labels()
-        except Exception:
-            pass
-        try:
-            if hasattr(self, "_hdr_refresh_timer") and self._hdr_refresh_timer is not None:
-                self._hdr_refresh_timer.start(0)
+            self._schedule_undo_redo_label_refresh()
         except Exception:
             pass
+        #try:
+        #    if hasattr(self, "_hdr_refresh_timer") and self._hdr_refresh_timer is not None:
+        #        self._hdr_refresh_timer.start(0)
+        #except Exception:
+        #    pass
         try:
             self._refresh_mask_action_states()
         except Exception:
             pass
 
+
     def _sync_docman_active(self, doc):
         dm = self.doc_manager
         try:
@@ -8385,7 +8594,131 @@ class AstroSuiteProMainWindow(
         if self._suspend_dock_sync:
             QTimer.singleShot(0, lambda: self.changeEvent(QEvent(QEvent.Type.WindowStateChange)))
 
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        # Update floating resource monitor position if it exists (from DockMixin)
+        if hasattr(self, "_update_monitor_position"):
+            self._update_monitor_position()
+
+    def moveEvent(self, event):
+        super().moveEvent(event)
+        # Update floating resource monitor position if it exists (from DockMixin)
+        if hasattr(self, "_update_monitor_position"):
+            self._update_monitor_position()
+
+    def changeEvent(self, event):
+        super().changeEvent(event)
+        # 1. Existing logic for dock sync (re-instated from showEvent logic if needed, but usually changeEvent is enough)
+        # (The snippet viewed previously showed showEvent firing a oneshot to call changeEvent)
+        
+        # 2. Resource Monitor Sync
+        if event.type() == QEvent.Type.WindowStateChange:
+            if self.windowState() & Qt.WindowState.WindowMinimized:
+                # App minimized -> hide overlay
+                if hasattr(self, "resource_monitor") and self.resource_monitor:
+                    self.resource_monitor.hide()
+            elif not (self.windowState() & Qt.WindowState.WindowMinimized):
+                # Only auto-show if the initial fade-in is done
+                if getattr(self, "_fade_in_complete", False):
+                    # App restored -> show overlay if enabled in settings
+                    if hasattr(self, "resource_monitor") and self.resource_monitor:
+                        if self.settings.value("ui/resource_monitor_visible", True, type=bool):
+                            self.resource_monitor.show()
+                            # Ensure position is correct upon restore
+                            if hasattr(self, "_update_monitor_position"):
+                                self._update_monitor_position()
+
+    def save_ui_state(self):
+        """Save window geometry, state, and shortcuts to settings."""
+        self._ensure_persistent_names()
+        try:
+            if self.isMaximized():
+                self.settings.setValue("ui/main/maximized", True)
+                # To get accurate geometry for non-maximized state, we'd need to showNormal()
+                # but that causes flicker. For a restart, we'll just save what we have.
+            else:
+                self.settings.setValue("ui/main/maximized", False)
+                self.settings.setValue("ui/main/geometry", self.saveGeometry())
+
+            self.settings.setValue("ui/main/state", self.saveState(version=1))
+        except Exception:
+            pass
+
+        # save shortcuts
+        try:
+            save_on_exit = self.settings.value("shortcuts/save_on_exit", True, type=bool)
+        except Exception:
+            save_on_exit = True
+        if save_on_exit and hasattr(self, "shortcuts"):
+            try:
+                self.shortcuts.save_shortcuts()
+            except Exception:
+                pass
+        
+        self.settings.sync()
+
+    def on_fade_in_complete(self):
+        """Called when main window fade-in is finished."""
+        self._fade_in_complete = True
+        # Sync Monitor Visibility
+        if hasattr(self, "resource_monitor") and self.resource_monitor:
+            if not self.isMinimized() and self.settings.value("ui/resource_monitor_visible", True, type=bool):
+                # Delay show to ensure visually pleasing sequence (monitor appears AFTER app)
+                QTimer.singleShot(500, self.resource_monitor.show)
+                # Ensure position
+                QTimer.singleShot(600, self._update_monitor_position)
+
+    def keyPressEvent(self, event):
+        """Handle key press events for secret shortcuts."""
+        if (event.modifiers() == (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.AltModifier) and 
+            event.key() == Qt.Key.Key_M):
+            
+            # Secret minigame launcher
+            # __file__ is in .../saspro/gui/main_window.py
+            # We want to go up to .../saspro/
+            base_pkg = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            minigame_path = os.path.join(base_pkg, "widgets", "minigame", "index.html")
+            
+            if os.path.exists(minigame_path):
+                QDesktopServices.openUrl(QUrl.fromLocalFile(minigame_path))
+                event.accept()
+                return
+
+        super().keyPressEvent(event)
+
+    def _update_usage_stats(self):
+        try:
+            now = time.time()
+            elapsed = now - self._session_start_time
+            self._session_start_time = now  # Reset session start to avoid double counting
+            
+            total = self.settings.value("stats/total_time_seconds", 0.0, type=float)
+            self.settings.setValue("stats/total_time_seconds", total + elapsed)
+        except Exception:
+            pass
+
+    def _on_tool_triggered(self):
+        """Slot to track tool usage count."""
+        try:
+            count = self.settings.value("stats/opened_tools_count", 0, type=int)
+            self.settings.setValue("stats/opened_tools_count", count + 1)
+        except Exception:
+            pass
+
     def closeEvent(self, e):
+        self._update_usage_stats()
+
+
+        # Optimization: If restarting (e.g. language change), bypass confirmation and close immediately
+        if getattr(self, "_is_restarting", False):
+            e.accept()
+            return
+        
+        # Check if we have already faded out
+        if getattr(self, "_fade_out_complete", False):
+            # Proceed with shutdown
+            self._do_shutdown_steps(e)
+            return
 
         try:
             if hasattr(self, "_orig_stdout") and self._orig_stdout is not None:
@@ -8394,6 +8727,8 @@ class AstroSuiteProMainWindow(
                 sys.stderr = self._orig_stderr
         except Exception:
             pass        
+
+        # --- Confirmation Logic ---
         self._shutting_down = True
         # Gather open docs
         docs = []
@@ -8404,64 +8739,73 @@ class AstroSuiteProMainWindow(
                 docs.append(d)
 
         edited = [d for d in docs if self._document_has_edits(d)]
-        msg = "Exit Seti Astro Suite Pro?"
-        detail = []
-        if docs:
-            detail.append(f"Open images: {len(docs)}")
-        if edited:
-            detail.append(f"Edited since open: {len(edited)}")
-        if detail:
-            msg += "\n\n" + "\n".join(detail)
-
-        # --- stay-on-top message box ---
-        mbox = QMessageBox(self)
-        mbox.setIcon(QMessageBox.Icon.Question)
-        mbox.setWindowTitle("Confirm Exit")
-        mbox.setText(msg)
-        mbox.setStandardButtons(
-            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
-        )
-        mbox.setDefaultButton(QMessageBox.StandardButton.No)
-        # ðŸ'‡ key line
-        mbox.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
-        mbox.raise_()
-        mbox.activateWindow()
-        btn = mbox.exec()
+        # If user has disabled exit confirmation (optional setting, but default is confirm)
+        confirm = True 
+        
+        if confirm:
+            msg = self.tr("Exit Seti Astro Suite Pro?")
+            detail = []
+            if docs:
+                detail.append(self.tr("Open images:") + f" {len(docs)}")
+            if edited:
+                detail.append(self.tr("Edited since open:") + f" {len(edited)}")
+            if detail:
+                msg += "\n\n" + "\n".join(detail)
+
+            # --- stay-on-top message box ---
+            mbox = QMessageBox(self)
+            mbox.setIcon(QMessageBox.Icon.Question)
+            mbox.setWindowTitle(self.tr("Confirm Exit"))
+            mbox.setText(msg)
+            mbox.setStandardButtons(
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
+            mbox.setDefaultButton(QMessageBox.StandardButton.No)
+            mbox.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+            mbox.raise_()
+            mbox.activateWindow()
+            btn = mbox.exec()
+
+            if btn != QMessageBox.StandardButton.Yes:
+                e.ignore()
+                self._shutting_down = False
+                return
 
-        if btn != QMessageBox.StandardButton.Yes:
-            e.ignore()
-            return
+        # --- User confirmed (or no confirm needed) ---
+        # Start Fade Out Animation
+        e.ignore() # Defer close until animation completes
+        self.setEnabled(False) # Prevent further interaction
+        
+        # Hide monitor immediately when fade starts (user preference)
+        if hasattr(self, "resource_monitor") and self.resource_monitor:
+            try:
+                if hasattr(self.resource_monitor, "backend"):
+                    self.resource_monitor.backend.stop()
+            except Exception:
+                pass
+            self.resource_monitor.hide()
+            self.resource_monitor.close()
+        
+        self._anim_close = QPropertyAnimation(self, b"windowOpacity")
+        self._anim_close.setDuration(800)
+        self._anim_close.setStartValue(1.0)
+        self._anim_close.setEndValue(0.0)
+        self._anim_close.setEasingCurve(QEasingCurve.Type.OutQuad)
+        self._anim_close.finished.connect(self._on_fade_out_finished)
+        self._anim_close.start()
+
+    def _on_fade_out_finished(self):
+        """Called when close animation completes."""    
+        self._fade_out_complete = True
+        self.close()
 
-        # User confirmed: prevent per-subwindow prompts and proceed
+    def _do_shutdown_steps(self, e):
+        """Actual shutdown logic after verification and animation."""
         self._force_close_all = True
         self._shutting_down = True
 
         # Save UI layout/placement
-        self._ensure_persistent_names()
-        try:
-            if self.isMaximized():
-                self.settings.setValue("ui/main/maximized", True)
-                self.showNormal()
-                self.settings.setValue("ui/main/geometry", self.saveGeometry())
-                self.showMaximized()
-            else:
-                self.settings.setValue("ui/main/maximized", False)
-                self.settings.setValue("ui/main/geometry", self.saveGeometry())
-
-            self.settings.setValue("ui/main/state", self.saveState(version=1))
-        except Exception:
-            pass
-
-        # save shortcuts
-        try:
-            save_on_exit = self.settings.value("shortcuts/save_on_exit", True, type=bool)
-        except Exception:
-            save_on_exit = True
-        if save_on_exit and hasattr(self, "shortcuts"):
-            try:
-                self.shortcuts.save_shortcuts()
-            except Exception:
-                pass
+        self.save_ui_state()
 
         # wait on bg threads
         try:
@@ -8480,6 +8824,7 @@ class AstroSuiteProMainWindow(
 # CheatSheet dialog and helper functions imported from setiastro.saspro.cheat_sheet
 from setiastro.saspro.cheat_sheet import (
     CheatSheetDialog as _CheatSheetDialog,
+    add_extra_shortcuts,
     _qs_to_str,
     _clean_text,
     _uniq_keep_order,