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

setiastro/saspro/gui/mixins/dock_mixin.py

@@ -14,7 +14,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout, QWidget, QTextEdit, QListWidget, QListWidgetItem,
     QAbstractItemView, QApplication
 )
-from PyQt6.QtGui import QTextCursor
+from PyQt6.QtGui import QTextCursor, QAction
 
 if TYPE_CHECKING:
     from PyQt6.QtWidgets import QAction
@@ -194,6 +194,99 @@ class DockMixin:
         except Exception:
             pass
 
+    def _init_resource_monitor_overlay(self):
+        """Initialize the QML System Resource Monitor as a floating overlay."""
+        try:
+            from setiastro.saspro.widgets.resource_monitor import SystemMonitorWidget
+            
+            # Create as a child of the central widget or self to sit on top
+            # Using self (QMainWindow) allows it to float over everything including status bar if we want,
+            # but usually we want it over MDI area. Let's try self first for "floating" feel.
+            self.resource_monitor = SystemMonitorWidget(self)
+            self.resource_monitor.setObjectName("ResourceMonitorOverlay")
+            
+            # Make it a proper independent window to allow true transparency (translucent background)
+            # without black artifacts from parent composition.
+            # Fixed: Removed WindowStaysOnTopHint to allow it to be obscured by other apps (Alt-Tab support)
+            self.resource_monitor.setWindowFlags(
+                Qt.WindowType.Window |
+                Qt.WindowType.FramelessWindowHint |
+                Qt.WindowType.Tool
+            )
+            
+            # Sizing and Transparency
+            self.resource_monitor.setFixedSize(200, 60)
+            # self.resource_monitor.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True) # Optional: if we want click-through
+            
+            
+            # Initial placement (will be updated by resizeEvent)
+            self._update_monitor_position()
+            
+            # Defer visibility to MainWindow.showEvent to prevent appearing before main window
+            # visible = self.settings.value("ui/resource_monitor_visible", True, type=bool)
+            # if visible:
+            #    self.resource_monitor.show()
+            # else:
+            #    self.resource_monitor.hide()
+        except Exception as e:
+            print(f"WARNING: Could not initialize System Monitor overlay: {e}")
+            self.resource_monitor = None
+
+    def _toggle_resource_monitor(self, checked: bool):
+        """Toggle floating monitor visibility."""
+        if hasattr(self, 'resource_monitor') and self.resource_monitor:
+            if checked:
+                self.resource_monitor.show()
+                self._update_monitor_position()
+            else:
+                self.resource_monitor.hide()
+            self.settings.setValue("ui/resource_monitor_visible", checked)
+
+    def _update_monitor_position(self):
+        """Snap monitor to bottom-right corner or restore saved position."""
+        if hasattr(self, 'resource_monitor') and self.resource_monitor:
+            from PyQt6.QtCore import QPoint
+            
+            # Check for saved position first
+            saved_x = self.settings.value("ui/resource_monitor_pos_x", type=int)
+            saved_y = self.settings.value("ui/resource_monitor_pos_y", type=int)
+            
+            if saved_x != 0 and saved_y != 0: # Basic validity check (0,0 is unlikely to be desired but also default if missing)
+                 # Actually 0,0 is valid but type=int returns 0 if missing. 
+                 # Let's check string existence to be safer or just accept 0 if set.
+                 # Checking existence via `contains` is better but value() logic is ok for now.
+                 if self.settings.contains("ui/resource_monitor_pos_x"):
+                     self.resource_monitor.move(saved_x, saved_y)
+                     self.resource_monitor.raise_()
+                     return
+
+            m = 5  # margin
+
+            screen = self.screen()
+            geom = screen.availableGeometry()
+
+            mw = self.resource_monitor.width()
+            mh = self.resource_monitor.height()
+
+            x = geom.x() + geom.width()  - mw - m
+            y = geom.y() + geom.height() - mh - m
+
+            self.resource_monitor.move(x, y)
+            self.resource_monitor.raise_()
+
+    # We need to hook resizeEvent to call _update_monitor_position.
+    # Since this is a mixin, we can't easily override resizeEvent of the MainWindow without being careful.
+    # Best way: install an event filter on self, or since we are a mixin mixed into MainWindow, 
+    # we can rely on MainWindow calling a specific method or we can patch it... 
+    # Actually, MainWindow likely has resizeEvent. 
+    # simpler: QTimer check? No.
+    # Correct way for Mixin: The MainWindow class should call something. 
+    # BUT, I can just installEventFilter(self) ? No, infinite loop risk.
+    # 
+    # Let's use the 'GeometryMixin' or just add a standard method `_on_resize_for_monitor` 
+    # and assume I can hook it in MainWindow.py.
+
+
         # ❌ Remove this old line; it let random mouse-over updates hijack the dock:
         # self.currentDocumentChanged.disconnect(self.header_viewer.set_document)  # if previously connected
         # (If you prefer to keep the signal for explicit tab switches, it's fine to leave
@@ -210,13 +303,28 @@ class DockMixin:
 
         # Friendly ordering for common ones; others follow alphabetically.
         order_hint = {
-            "Explorer": 10,
-            "Console / Status": 20,
-            "Header Viewer": 30,
-            "Layers": 40,
-            "Window Shelf": 50,
-            "Command Search": 60,
+            self.tr("Explorer"): 10,
+            self.tr("Console / Status"): 20,
+            self.tr("Header Viewer"): 30,
+            self.tr("Layers"): 40,
+            self.tr("Window Shelf"): 50,
+            self.tr("Command Search"): 60,
         }
+        
+        # Add special action for overlay monitor
+        mon_act = QAction(self.tr("System Monitor"), self)
+        mon_act.setCheckable(True)
+        mon_act.setChecked(self.settings.value("ui/resource_monitor_visible", True, type=bool))
+        mon_act.triggered.connect(self._toggle_resource_monitor)
+        
+        # We need to insert it into the logic that populates the menu.
+        # But 'dock_mixin' automates menu from self.findChildren(QDockWidget).
+        # So we have to manually inject this action into the "Panels" menu if possible
+        # or expose it such that main_window can add it.
+        # 
+        # Easier: allow main_window to add it, or ...
+        # If I can't easily see where menu is built, I'll bind it to self.act_toggle_monitor = mon_act
+        self.act_toggle_monitor = mon_act
 
         def key_fn(d: QDockWidget):
             t = d.windowTitle()
@@ -224,6 +332,10 @@ class DockMixin:
 
         for dock in sorted(docks, key=key_fn):
             self._register_dock_in_view_menu(dock)
+            
+        if hasattr(self, "act_toggle_monitor"):
+             menu.addSeparator()
+             menu.addAction(self.act_toggle_monitor)
 
     def _add_doc_to_explorer(self, doc):
         base = self._normalize_base_doc(doc)

setiastro/saspro/gui/mixins/file_mixin.py

@@ -120,6 +120,13 @@ class FileMixin:
                 doc = self.docman.open_path(p)   # this emits documentAdded
                 self._log(f"Opened: {p}")
                 self._add_recent_image(p)        # âœ... track in MRU
+                
+                # Increment statistics
+                try:
+                    count = self.settings.value("stats/opened_images_count", 0, type=int)
+                    self.settings.setValue("stats/opened_images_count", count + 1)
+                except Exception:
+                    pass
             except Exception as e:
                 QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
 

setiastro/saspro/gui/mixins/geometry_mixin.py

@@ -51,12 +51,10 @@ except ImportError:
         return cv2.resize(arr, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
 
 
-# Try to import WCS update function
-try:
-    from setiastro.saspro.wcs_utils import update_wcs_after_crop
-except ImportError:
-    update_wcs_after_crop = None
+from setiastro.saspro.wcs_update import update_wcs_after_crop
 
+import cv2
+import math
 
 if TYPE_CHECKING:
     pass
@@ -209,6 +207,44 @@ class GeometryMixin:
         except Exception as e:
             QMessageBox.critical(self, "Rotate 180°", str(e))
 
+    def _exec_geom_rot_any(self):
+        sw = self.mdi.activeSubWindow() if hasattr(self, "mdi") else None
+        view = sw.widget() if sw else None
+        doc = getattr(view, "document", None)
+        if doc is None or getattr(doc, "image", None) is None:
+            QMessageBox.information(self, self.tr("Rotate..."), self.tr("Active view has no image."))
+            return
+
+        if cv2 is None:
+            QMessageBox.warning(self, self.tr("Rotate..."), self.tr("OpenCV (cv2) is required for arbitrary rotation."))
+            return
+
+        dlg = QInputDialog(self)
+        dlg.setWindowTitle(self.tr("Rotate..."))
+        dlg.setLabelText(self.tr("Angle in degrees (positive = CCW):"))
+        dlg.setInputMode(QInputDialog.InputMode.DoubleInput)
+        dlg.setDoubleRange(-360.0, 360.0)
+        dlg.setDoubleDecimals(2)
+        dlg.setDoubleValue(0.0)
+        dlg.setWindowFlag(Qt.WindowType.Window, True)
+
+        try:
+            from setiastro.saspro.resources import rotatearbitrary_path
+            dlg.setWindowIcon(QIcon(rotatearbitrary_path))
+        except Exception:
+            pass
+
+        if dlg.exec() != QDialog.DialogCode.Accepted:
+            return
+
+        angle = float(dlg.doubleValue())
+        try:
+            self._apply_geom_rot_any_to_doc(doc, angle_deg=angle)
+            self._log(f"Rotate ({angle:g}°) applied to active view")
+        except Exception as e:
+            QMessageBox.critical(self, self.tr("Rotate..."), str(e))
+
+
     def _exec_geom_rescale(self):
         """Execute rescale operation on active view with dialog."""
         sw = self.mdi.activeSubWindow() if hasattr(self, "mdi") else None
@@ -334,6 +370,70 @@ class GeometryMixin:
 
         self._apply_geom_with_wcs(doc, out, M_src_to_dst=M, step_name="Rotate 180°")
 
+    def _apply_geom_rot_any_to_doc(self, doc, *, angle_deg: float):
+        if cv2 is None:
+            raise RuntimeError("cv2 is required for arbitrary rotation")
+
+        src = np.asarray(doc.image, dtype=np.float32, order="C")
+        h, w = src.shape[:2]
+
+        # Rotation about center
+        cx = (w - 1) * 0.5
+        cy = (h - 1) * 0.5
+
+        # OpenCV uses CCW degrees
+        A2 = cv2.getRotationMatrix2D((cx, cy), angle_deg, 1.0)  # 2x3
+
+        # Convert to 3x3
+        M = np.array([
+            [A2[0,0], A2[0,1], A2[0,2]],
+            [A2[1,0], A2[1,1], A2[1,2]],
+            [0.0,     0.0,     1.0    ],
+        ], dtype=np.float32)
+
+        # Compute output bounds by rotating the four corners
+        corners = np.array([
+            [0.0, 0.0, 1.0],
+            [w - 1.0, 0.0, 1.0],
+            [w - 1.0, h - 1.0, 1.0],
+            [0.0, h - 1.0, 1.0],
+        ], dtype=np.float32).T  # 3x4
+
+        rc = (M @ corners)  # 3x4
+        xs = rc[0, :]
+        ys = rc[1, :]
+
+        min_x = float(xs.min())
+        max_x = float(xs.max())
+        min_y = float(ys.min())
+        max_y = float(ys.max())
+
+        out_w = int(math.ceil(max_x - min_x + 1.0))
+        out_h = int(math.ceil(max_y - min_y + 1.0))
+        if out_w <= 0 or out_h <= 0:
+            raise RuntimeError("Invalid output size after rotation")
+
+        # Shift so that min corner maps to (0,0)
+        T = np.array([
+            [1.0, 0.0, -min_x],
+            [0.0, 1.0, -min_y],
+            [0.0, 0.0, 1.0],
+        ], dtype=np.float32)
+
+        M = (T @ M).astype(np.float32)  # final src->dst 3x3
+
+        # Warp
+        # cv2.warpPerspective expects (W,H)
+        flags = cv2.INTER_LANCZOS4
+        if src.ndim == 2:
+            out = cv2.warpPerspective(src, M, (out_w, out_h), flags=flags)
+        else:
+            # warpPerspective works on multi-channel too
+            out = cv2.warpPerspective(src, M, (out_w, out_h), flags=flags)
+
+        self._apply_geom_with_wcs(doc, out, M_src_to_dst=M, step_name=f"Rotate ({angle_deg:g}°)")
+
+
     def _apply_geom_rescale_to_doc(self, doc, *, factor: float):
         """Apply rescale to document with WCS update."""
         factor = float(max(0.1, min(10.0, factor)))

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -25,6 +25,28 @@ class MenuMixin:
         # This method will be implemented as part of the main window
         # For now, this is a placeholder showing the mixin pattern
         pass
+
+    def _show_statistics(self):
+        from setiastro.saspro.gui.statistics_dialog import StatisticsDialog
+        dlg = StatisticsDialog(self)
+        dlg.exec()
+
+    def _hook_tool_stats(self, menus):
+        if not hasattr(self, "_on_tool_triggered"):
+            return
+        
+        seen = set()
+        for menu in menus:
+            for action in self._iter_menu_actions(menu):
+                if action in seen: continue
+                seen.add(action)
+                if action.isSeparator(): continue
+                
+                try:
+                    action.triggered.connect(self._on_tool_triggered)
+                except Exception:
+                    pass
+
     
     def _rebuild_recent_menus(self):
         """Rebuild the recent files and projects menus."""
@@ -163,6 +185,7 @@ class MenuMixin:
         m_geom.addAction(self.act_geom_rot_cw)
         m_geom.addAction(self.act_geom_rot_ccw)
         m_geom.addAction(self.act_geom_rot_180)   
+        m_geom.addAction(self.act_geom_rot_any) 
         m_geom.addSeparator()
         m_geom.addAction(self.act_geom_rescale)
         m_geom.addSeparator()
@@ -298,6 +321,12 @@ class MenuMixin:
         m_about.addAction(self.act_check_updates)
 
 
+        m_about.addSeparator()
+        m_about.addAction(self.tr("Statistics..."), self._show_statistics)
+
+        # Connect tool stats
+        self._hook_tool_stats([m_fn, m_tools, mCosmic, m_geom, m_star, m_masks, m_header, m_scripts])
+
         # initialize enabled state + names
         self.update_undo_redo_action_labels()
 

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -10,6 +10,9 @@ from PyQt6.QtCore import Qt, QTimer, QUrl
 from PyQt6.QtGui import QAction, QActionGroup, QIcon, QKeySequence, QDesktopServices
 from PyQt6.QtWidgets import QMenu, QToolButton
 
+from PyQt6.QtCore import QElapsedTimer
+
+
 if TYPE_CHECKING:
     pass
 
@@ -20,7 +23,7 @@ from setiastro.saspro.resources import (
     LInsert_path, rgbcombo_path, rgbextract_path, graxperticon_path,
     cropicon_path, openfile_path, abeicon_path, undoicon_path, redoicon_path,
     blastericon_path, hdr_path, invert_path, fliphorizontal_path,
-    flipvertical_path, rotateclockwise_path, rotatecounterclockwise_path,
+    flipvertical_path, rotateclockwise_path, rotatecounterclockwise_path,rotatearbitrary_path,
     rotate180_path, maskcreate_path, maskapply_path, maskremove_path,
     pixelmath_path, histogram_path, mosaic_path, rescale_path, staralign_path,
     platesolve_path, psf_path, supernova_path, starregistration_path,
@@ -73,7 +76,8 @@ class ToolbarMixin:
 
     def _init_toolbar(self):
         # View toolbar (Undo / Redo / Display-Stretch)
-        tb = DraggableToolBar("View", self)
+        tb = DraggableToolBar(self.tr("View"), self)
+        tb.setObjectName("View")
         tb.setSettingsKey("Toolbar/View")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb)
 
@@ -175,7 +179,8 @@ class ToolbarMixin:
             pass
 
         # Functions toolbar
-        tb_fn = DraggableToolBar("Functions", self)
+        tb_fn = DraggableToolBar(self.tr("Functions"), self)
+        tb_fn.setObjectName("Functions")
         tb_fn.setSettingsKey("Toolbar/Functions")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_fn)
 
@@ -227,7 +232,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tbCosmic = DraggableToolBar("Cosmic Clarity", self)
+        tbCosmic = DraggableToolBar(self.tr("Cosmic Clarity"), self)
+        tbCosmic.setObjectName("Cosmic Clarity")
         tbCosmic.setSettingsKey("Toolbar/Cosmic")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tbCosmic)
 
@@ -241,7 +247,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_tl = DraggableToolBar("Tools", self)
+        tb_tl = DraggableToolBar(self.tr("Tools"), self)
+        tb_tl.setObjectName("Tools")
         tb_tl.setSettingsKey("Toolbar/Tools")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_tl)
 
@@ -260,7 +267,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_geom = DraggableToolBar("Geometry", self)
+        tb_geom = DraggableToolBar(self.tr("Geometry"), self)
+        tb_geom.setObjectName("Geometry")
         tb_geom.setSettingsKey("Toolbar/Geometry")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_geom)
 
@@ -272,6 +280,7 @@ class ToolbarMixin:
         tb_geom.addAction(self.act_geom_rot_cw)
         tb_geom.addAction(self.act_geom_rot_ccw)
         tb_geom.addAction(self.act_geom_rot_180)
+        tb_geom.addAction(self.act_geom_rot_any)
         tb_geom.addSeparator()
         tb_geom.addAction(self.act_geom_rescale)
         tb_geom.addSeparator()
@@ -283,7 +292,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_star = DraggableToolBar("Star Stuff", self)
+        tb_star = DraggableToolBar(self.tr("Star Stuff"), self)
+        tb_star.setObjectName("Star Stuff")
         tb_star.setSettingsKey("Toolbar/StarStuff")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_star)
 
@@ -308,7 +318,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_msk = DraggableToolBar("Masks", self)
+        tb_msk = DraggableToolBar(self.tr("Masks"), self)
+        tb_msk.setObjectName("Masks")
         tb_msk.setSettingsKey("Toolbar/Masks")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_msk)
 
@@ -322,7 +333,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_wim = DraggableToolBar("What's In My...", self)
+        tb_wim = DraggableToolBar(self.tr("What's In My..."), self)
+        tb_wim.setObjectName("What's In My...")
         tb_wim.setSettingsKey("Toolbar/WhatsInMy")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_wim)
 
@@ -335,7 +347,8 @@ class ToolbarMixin:
         except Exception:
             pass
 
-        tb_bundle = DraggableToolBar("Bundles", self)
+        tb_bundle = DraggableToolBar(self.tr("Bundles"), self)
+        tb_bundle.setObjectName("Bundles")
         tb_bundle.setSettingsKey("Toolbar/Bundles")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_bundle)
 
@@ -873,6 +886,12 @@ class ToolbarMixin:
         self.act_geom_rot_180.setStatusTip(self.tr("Rotate image 180°"))
         self.act_geom_rot_180.triggered.connect(self._exec_geom_rot_180)
 
+        self.act_geom_rot_any = QAction(QIcon(rotatearbitrary_path), self.tr("Rotate..."), self)
+        self.act_geom_rot_any.setIconVisibleInMenu(True)
+        self.act_geom_rot_any.setStatusTip(self.tr("Rotate image by an arbitrary angle (degrees)"))
+        self.act_geom_rot_any.triggered.connect(self._exec_geom_rot_any)
+
+
         self.act_geom_rescale = QAction(QIcon(rescale_path), self.tr("Rescale..."), self)
         self.act_geom_rescale.setIconVisibleInMenu(True)
         self.act_geom_rescale.setStatusTip(self.tr("Rescale image by a factor"))
@@ -1196,6 +1215,7 @@ class ToolbarMixin:
         reg("geom_rotate_clockwise",       self.act_geom_rot_cw)
         reg("geom_rotate_counterclockwise",self.act_geom_rot_ccw)
         reg("geom_rotate_180",             self.act_geom_rot_180) 
+        reg("geom_rotate_any", self.act_geom_rot_any)
         reg("geom_rescale",                self.act_geom_rescale)        
         reg("project_new",  self.act_project_new)
         reg("project_save", self.act_project_save)
@@ -1387,6 +1407,7 @@ class ToolbarMixin:
                 a.setStatusTip(tip)
                 a.setEnabled(False)
 
+
     def _sync_link_action_state(self):
         g = self._current_group_of_active()
         self.act_link_group.blockSignals(True)
@@ -1432,6 +1453,7 @@ class ToolbarMixin:
         QTimer.singleShot(0, self.update_undo_redo_action_labels)
 
     def _refresh_mask_action_states(self):
+
         active_doc = self._active_doc()
 
         can_apply = bool(active_doc and self._list_candidate_mask_sources(exclude_doc=active_doc))
@@ -1455,3 +1477,4 @@ class ToolbarMixin:
         if hasattr(self, "act_hide_mask"):
             self.act_hide_mask.setEnabled(has_mask and overlay_on)
 
+

setiastro/saspro/gui/statistics_dialog.py

@@ -0,0 +1,47 @@
+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QLabel, QFormLayout, QPushButton
+from PyQt6.QtCore import Qt, QSettings
+from PyQt6.QtGui import QIcon
+
+class StatisticsDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(self.tr("App Statistics"))
+        self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowContextHelpButtonHint)
+        self.resize(300, 200)
+
+        # Settings to read stats
+        self.settings = QSettings("SetiAstro", "SetiAstroSuitePro")
+
+        layout = QVBoxLayout(self)
+
+        form_layout = QFormLayout()
+        
+        # Time Spent
+        total_seconds = self.settings.value("stats/total_time_seconds", 0, type=float)
+        days = int(total_seconds // 86400)
+        hours = int((total_seconds % 86400) // 3600)
+        minutes = int((total_seconds % 3600) // 60)
+        
+        time_str = f"{days} {self.tr('Days')}, {hours} {self.tr('Hours')}, {minutes} {self.tr('Minutes')}"
+        if days == 0:
+             time_str = f"{hours} {self.tr('Hours')}, {minutes} {self.tr('Minutes')}"
+        
+        self.lbl_time = QLabel(time_str)
+        form_layout.addRow(self.tr("Time Spent:"), self.lbl_time)
+
+        # Images Opened
+        images_count = self.settings.value("stats/opened_images_count", 0, type=int)
+        self.lbl_images = QLabel(str(images_count))
+        form_layout.addRow(self.tr("Images Opened:"), self.lbl_images)
+
+        # Tools Opened
+        tools_count = self.settings.value("stats/opened_tools_count", 0, type=int)
+        self.lbl_tools = QLabel(str(tools_count))
+        form_layout.addRow(self.tr("Tools Opened:"), self.lbl_tools)
+
+        layout.addLayout(form_layout)
+
+        # Close button
+        btn_close = QPushButton(self.tr("Close"))
+        btn_close.clicked.connect(self.accept)
+        layout.addWidget(btn_close, alignment=Qt.AlignmentFlag.AlignRight)

setiastro/saspro/halobgon.py

@@ -249,6 +249,9 @@ class HaloBGonDialogPro(QDialog):
     def __init__(self, parent, doc, icon: Optional[QIcon] = None):
         super().__init__(parent)
         self.setWindowTitle("Halo-B-Gon")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -427,7 +430,8 @@ class HaloBGonDialogPro(QDialog):
                     except Exception:
                         pass
 
-                    self.accept()
+                    # Dialog stays open - refresh document for next operation
+                    self._refresh_document_from_active()
                     return
                 else:
                     # Fallback: try legacy spawner if present; else warn and overwrite.
@@ -437,7 +441,8 @@ class HaloBGonDialogPro(QDialog):
                     if callable(spawner):
                         title = self.doc.display_name() if hasattr(self.doc, "display_name") else "Image"
                         spawner(out, f"{title} [Halo-B-Gon]")
-                        self.accept()
+                        # Dialog stays open - refresh document for next operation
+                        self._refresh_document_from_active()
                         return
                     else:
                         QMessageBox.warning(
@@ -448,11 +453,32 @@ class HaloBGonDialogPro(QDialog):
 
             # Overwrite current (original behavior)
             self._apply_overwrite(out)
-            self.accept()
+            # Dialog stays open - refresh document for next operation
+            self._refresh_document_from_active()
 
         except Exception as e:
             QMessageBox.critical(self, "Halo-B-Gon", f"Failed to apply:\n{e}")
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Refresh preview for new document
+                    self.orig = np.clip(np.asarray(new_doc.image, dtype=np.float32), 0.0, 1.0)
+                    disp = self.orig
+                    if disp.ndim == 2: disp = disp[..., None].repeat(3, axis=2)
+                    elif disp.ndim == 3 and disp.shape[2] == 1: disp = disp.repeat(3, axis=2)
+                    self._disp_base = disp
+                    self._update_preview()
+        except Exception:
+            pass
 
 
     def _reset(self):

setiastro/saspro/histogram.py

@@ -30,6 +30,9 @@ class HistogramDialog(QDialog):
     def __init__(self, parent, document):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Histogram"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.doc = document
         self.image = _to_float_preserve(document.image)
 

setiastro/saspro/history_explorer.py

@@ -436,6 +436,8 @@ class HistoryExplorerDialog(QDialog):
     def __init__(self, document, parent=None):
         super().__init__(parent)
         self.setWindowTitle("History Explorer")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         self.doc = document
 

setiastro/saspro/i18n.py

@@ -25,22 +25,34 @@ AVAILABLE_LANGUAGES: Dict[str, str] = {
     "de": "Deutsch",
     "pt": "Português",
     "ja": "日本語",
+    "hi": "हिन्दी",
+    "sw": "Kiswahili",
+    "uk": "Українська",
+    "ru": "Русский",
+    "ar": "العربية",
 }
 
 
 def get_translations_dir() -> str:
     """Get the path to the translations directory."""
-    # When running from source or installed package
+    # Source / installed package location
     module_dir = os.path.dirname(os.path.abspath(__file__))
-    translations_dir = os.path.join(module_dir, "translations")
-    
-    # Fallback for PyInstaller frozen builds
-    if hasattr(os.sys, '_MEIPASS'):
-        frozen_dir = os.path.join(os.sys._MEIPASS, "translations")
-        if os.path.exists(frozen_dir):
-            return frozen_dir
-    
-    return translations_dir
+    pkg_dir = os.path.join(module_dir, "translations")
+
+    # PyInstaller frozen builds
+    if hasattr(os.sys, "_MEIPASS"):
+        # New bundle layout (preferred)
+        frozen_internal = os.path.join(os.sys._MEIPASS, "_internal", "translations")
+        if os.path.exists(frozen_internal):
+            return frozen_internal
+
+        # Legacy bundle layout fallback
+        frozen_legacy = os.path.join(os.sys._MEIPASS, "translations")
+        if os.path.exists(frozen_legacy):
+            return frozen_legacy
+
+    return pkg_dir
+
 
 
 def get_available_languages() -> Dict[str, str]: