setiastrosuitepro 1.6.2__py3-none-any.whl → 1.6.12__py3-none-any.whl

setiastro/saspro/gui/mixins/dock_mixin.py

@@ -12,13 +12,43 @@ from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtWidgets import (
     QDockWidget, QPlainTextEdit, QTreeWidget, QTreeWidgetItem,
     QVBoxLayout, QWidget, QTextEdit, QListWidget, QListWidgetItem,
-    QAbstractItemView, QApplication
+    QAbstractItemView, QApplication, QLineEdit, QMenu
 )
-from PyQt6.QtGui import QTextCursor, QAction
+from PyQt6.QtGui import QTextCursor, QAction, QGuiApplication
 
 if TYPE_CHECKING:
     from PyQt6.QtWidgets import QAction
 
+import os
+
+GLYPHS = "■●◆▲▪▫•◼◻◾◽🔗"
+
+def _strip_ui_decorations(text: str) -> str:
+    """
+    Strip UI-only decorations from titles:
+    - Qt mnemonics (&)
+    - link badges like "[LINK]"
+    - your glyph badges
+    - file extension (optional, but nice for Explorer)
+    """
+    if not text:
+        return ""
+    s = str(text)
+
+    # remove mnemonics
+    s = s.replace("&", "")
+
+    # remove common prefixes/badges
+    s = s.replace("[LINK]", "").strip()
+
+    # remove glyph badges
+    s = s.translate({ord(ch): None for ch in GLYPHS})
+
+    # collapse whitespace
+    s = " ".join(s.split())
+
+    return s
+
 
 class DockMixin:
     """
@@ -105,14 +135,44 @@ class DockMixin:
         self._view_panels_menu.removeAction(action)
     
     def _init_explorer_dock(self):
-        self.explorer = QListWidget()
-        # Enter/Return or single-activation: focus if open, else open
+        host = QWidget(self)
+        lay = QVBoxLayout(host)
+        lay.setContentsMargins(4, 4, 4, 4)
+        lay.setSpacing(4)
+
+        # Optional filter box (super useful)
+        self.explorer_filter = QLineEdit(host)
+        self.explorer_filter.setPlaceholderText(self.tr("Filter open documents…"))
+        self.explorer_filter.textChanged.connect(self._explorer_apply_filter)
+        lay.addWidget(self.explorer_filter)
+
+        self.explorer = QTreeWidget(host)
+        self.explorer.setObjectName("ExplorerTree")
+        self.explorer.setColumnCount(3)
+        self.explorer.setHeaderLabels([self.tr("Document"), self.tr("Dims"), self.tr("Type")])
+
+        # Sorting
+        self.explorer.setSortingEnabled(True)
+        self.explorer.header().setSortIndicatorShown(True)
+        self.explorer.sortByColumn(0, Qt.SortOrder.AscendingOrder)
+
+        # Selection/activation behavior
+        self.explorer.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
         self.explorer.itemActivated.connect(self._activate_or_open_from_explorer)
-        # Double-click: same behavior
-        self.explorer.itemDoubleClicked.connect(self._activate_or_open_from_explorer)
+
+        # Inline rename support
+        self.explorer.setEditTriggers(
+            QAbstractItemView.EditTrigger.EditKeyPressed |
+            QAbstractItemView.EditTrigger.SelectedClicked
+        )
+        self.explorer.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.explorer.customContextMenuRequested.connect(self._on_explorer_context_menu)
+        self.explorer.itemChanged.connect(self._on_explorer_item_changed)
+
+        lay.addWidget(self.explorer)
 
         dock = QDockWidget(self.tr("Explorer"), self)
-        dock.setWidget(self.explorer)
+        dock.setWidget(host)
         dock.setObjectName("ExplorerDock")
         self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, dock)
 
@@ -243,22 +303,35 @@ class DockMixin:
             self.settings.setValue("ui/resource_monitor_visible", checked)
 
     def _update_monitor_position(self):
-        """Snap monitor to bottom-right corner."""
+        """Snap monitor to bottom-right corner or restore saved position."""
         if hasattr(self, 'resource_monitor') and self.resource_monitor:
             from PyQt6.QtCore import QPoint
-            m = 5 # margin
-            # Position relative to the main window geometry
-            w = self.resource_monitor.width()
-            h = self.resource_monitor.height()
             
-            # Anchor to bottom-right of the window
-            x = self.width() - w - m
-            y = self.height() - h - m
+            # 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)
             
-            # Map local MainWindow coordinates to Global Screen coordinates
-            # This is required because resource_monitor is a Top-Level Window (for transparency)
-            global_pos = self.mapToGlobal(QPoint(x, y))
-            self.resource_monitor.move(global_pos)
+            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.
@@ -290,12 +363,12 @@ 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
@@ -328,35 +401,196 @@ class DockMixin:
         base = self._normalize_base_doc(doc)
 
         # de-dupe by identity on base
-        for i in range(self.explorer.count()):
-            it = self.explorer.item(i)
-            if it.data(Qt.ItemDataRole.UserRole) is base:
-                # refresh text in case dims/name changed
-                it.setText(self._format_explorer_title(base))
+        for i in range(self.explorer.topLevelItemCount()):
+            it = self.explorer.topLevelItem(i)
+            if it.data(0, Qt.ItemDataRole.UserRole) is base:
+                self._refresh_explorer_row(it, base)
                 return
 
-        item = QListWidgetItem(self._format_explorer_title(base))
-        item.setData(Qt.ItemDataRole.UserRole, base)
+        it = QTreeWidgetItem()
+        it.setData(0, Qt.ItemDataRole.UserRole, base)
+
+        # Make name editable; other columns read-only
+        it.setFlags(it.flags() | Qt.ItemFlag.ItemIsEditable | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsEnabled)
+
+        self._refresh_explorer_row(it, base)
+
         fp = (base.metadata or {}).get("file_path")
         if fp:
-            item.setToolTip(fp)
-        self.explorer.addItem(item)
+            it.setToolTip(0, fp)
+
+        self.explorer.addTopLevelItem(it)
 
         # keep row label in sync with edits/resizes/renames
         try:
-            base.changed.connect(lambda *_: self._update_explorer_item_for_doc(base))
+            base.changed.connect(lambda *_, d=base: self._update_explorer_item_for_doc(d))
         except Exception:
             pass
 
+
     def _remove_doc_from_explorer(self, doc):
-        """
-        Remove either the exact doc or its base (handles ROI proxies).
-        """
         base = self._normalize_base_doc(doc)
-        for i in range(self.explorer.count()):
-            it = self.explorer.item(i)
-            d = it.data(Qt.ItemDataRole.UserRole)
+        for i in range(self.explorer.topLevelItemCount()):
+            it = self.explorer.topLevelItem(i)
+            d = it.data(0, Qt.ItemDataRole.UserRole)
             if d is doc or d is base:
-                self.explorer.takeItem(i)
+                self.explorer.takeTopLevelItem(i)
                 break
 
+
+    def _update_explorer_item_for_doc(self, doc):
+        for i in range(self.explorer.topLevelItemCount()):
+            it = self.explorer.topLevelItem(i)
+            if it.data(0, Qt.ItemDataRole.UserRole) is doc:
+                self._refresh_explorer_row(it, doc)
+                return
+
+    def _refresh_explorer_row(self, item, doc):
+        # Column 0: display name (NO glyph decorations)
+        name = _strip_ui_decorations(doc.display_name() or "Untitled")
+
+        name_no_ext, _ext = os.path.splitext(name)
+        if name_no_ext:
+            name = name_no_ext
+
+        item.setText(0, name)
+
+        # Column 1: dims
+        dims = ""
+        try:
+            import numpy as np
+            arr = getattr(doc, "image", None)
+            if isinstance(arr, np.ndarray) and arr.size:
+                h, w = arr.shape[:2]
+                c = arr.shape[2] if arr.ndim == 3 else 1
+                dims = f"{h}×{w}×{c}"
+        except Exception:
+            pass
+        item.setText(1, dims)
+
+        # Column 2: type/bit-depth (whatever you have available)
+        md = (doc.metadata or {})
+        bit = md.get("bit_depth") or md.get("dtype") or ""
+        kind = md.get("format") or md.get("doc_type") or ""
+        t = " / ".join([s for s in (str(kind), str(bit)) if s and s != "None"])
+        item.setText(2, t)
+
+    def _on_explorer_item_changed(self, item, col: int):
+        if col != 0:
+            return
+
+        doc = item.data(0, Qt.ItemDataRole.UserRole)
+        if doc is None:
+            return
+
+        new_name = (item.text(0) or "").strip()
+        if not new_name:
+            # revert to current doc name
+            self._refresh_explorer_row(item, doc)
+            return
+
+        # Avoid infinite loops: only apply if changed
+        cur = _strip_ui_decorations(doc.display_name() or "Untitled")
+        cur_no_ext, _ = os.path.splitext(cur)
+        cur = cur_no_ext or cur
+        if new_name == cur:
+            return
+
+        try:
+            doc.metadata["display_name"] = new_name
+        except Exception:
+            # if metadata missing or immutable, revert
+            self._refresh_explorer_row(item, doc)
+            return
+
+        try:
+            doc.changed.emit()
+        except Exception:
+            pass
+
+    def _on_explorer_context_menu(self, pos):
+        it = self.explorer.itemAt(pos)
+        if it is None:
+            return
+        doc = it.data(0, Qt.ItemDataRole.UserRole)
+        if doc is None:
+            return
+
+        menu = QMenu(self.explorer)
+        a_rename = menu.addAction(self.tr("Rename Document…"))
+        a_close  = menu.addAction(self.tr("Close Document"))
+        menu.addSeparator()
+        a_copy_path = menu.addAction(self.tr("Copy File Path"))
+        a_reveal = menu.addAction(self.tr("Reveal in File Manager"))
+        menu.addSeparator()
+        a_send_shelf = menu.addAction(self.tr("Send View to Shelf"))  # acts on active view for this doc
+
+        act = menu.exec(self.explorer.viewport().mapToGlobal(pos))
+        if act == a_rename:
+            # Start inline editing
+            self.explorer.editItem(it, 0)
+
+        elif act == a_close:
+            # close only if no other subwindows show it: you already do that in _on_view_about_to_close,
+            # but Explorer close is explicit; just close all views of this doc then docman.close_document.
+            try:
+                self._close_all_views_for_doc(doc)
+            except Exception:
+                pass
+
+        elif act == a_copy_path:
+            fp = (doc.metadata or {}).get("file_path", "")
+            if fp:
+                QGuiApplication.clipboard().setText(fp)
+
+        elif act == a_reveal:
+            fp = (doc.metadata or {}).get("file_path", "")
+            if fp:
+                self._reveal_in_file_manager(fp)
+
+        elif act == a_send_shelf:
+            sw = self._find_subwindow_for_doc(doc)
+            if sw and hasattr(sw.widget(), "_send_to_shelf"):
+                try:
+                    sw.widget()._send_to_shelf()
+                except Exception:
+                    pass
+
+    def _close_all_views_for_doc(self, doc):
+        base = self._normalize_base_doc(doc)
+        subs = list(self.mdi.subWindowList())
+        for sw in subs:
+            w = sw.widget()
+            if getattr(w, "base_document", None) is base:
+                try:
+                    sw.close()
+                except Exception:
+                    pass
+        # If none left (or even if close failed), try docman close defensively
+        try:
+            self.docman.close_document(base)
+        except Exception:
+            pass
+
+
+    def _reveal_in_file_manager(self, path: str):
+        import sys, os, subprocess
+        try:
+            if sys.platform.startswith("win"):
+                subprocess.Popen(["explorer", "/select,", os.path.normpath(path)])
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", "-R", path])
+            else:
+                # best-effort on Linux
+                subprocess.Popen(["xdg-open", os.path.dirname(path)])
+        except Exception:
+            pass
+
+    def _explorer_apply_filter(self, text: str):
+        t = (text or "").strip().lower()
+        for i in range(self.explorer.topLevelItemCount()):
+            it = self.explorer.topLevelItem(i)
+            name = (it.text(0) or "").lower()
+            fp = (it.toolTip(0) or "").lower()
+            hide = bool(t) and (t not in name) and (t not in fp)
+            it.setHidden(hide)

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

@@ -6,8 +6,9 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING
 
-from PyQt6.QtGui import QAction
+from PyQt6.QtGui import QAction, QKeySequence
 from PyQt6.QtWidgets import QMenu, QToolButton, QWidgetAction
+from PyQt6.QtCore import Qt
 
 if TYPE_CHECKING:
     pass
@@ -185,6 +186,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()
@@ -228,6 +230,7 @@ class MenuMixin:
 
 
         m_header = mb.addMenu(self.tr("&Header Mods && Misc"))
+        m_header.addAction(self.act_acv_exporter)        
         m_header.addAction(self.act_astrobin_exporter)
         m_header.addAction(self.act_batch_convert)
         m_header.addAction(self.act_batch_renamer)
@@ -265,6 +268,14 @@ class MenuMixin:
         m_view.addAction(self.act_tile_grid)        
         m_view.addSeparator()
 
+        # NEW: Minimize All Views
+        self.act_minimize_all_views = QAction(self.tr("Minimize All Views"), self)
+        self.act_minimize_all_views.setShortcut(QKeySequence("Ctrl+Shift+M"))
+        self.act_minimize_all_views.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
+        self.act_minimize_all_views.triggered.connect(self._minimize_all_views)
+        m_view.addAction(self.act_minimize_all_views)
+
+        m_view.addSeparator()
 
         # a button that shows current group & opens a drop-down
         self._link_btn = QToolButton(self)
@@ -387,3 +398,19 @@ class MenuMixin:
             if sub is not None:
                 yield from self._iter_menu_actions(sub)
 
+    def _minimize_all_views(self):
+        mdi = getattr(self, "mdi", None)
+        if mdi is None:
+            return
+
+        try:
+            for sw in mdi.subWindowList():
+                try:
+                    if not sw.isVisible():
+                        continue
+                    # Minimize each MDI child
+                    sw.showMinimized()
+                except Exception:
+                    pass
+        except Exception:
+            pass