setiastrosuitepro 1.6.7__py3-none-any.whl → 1.6.10__py3-none-any.whl

setiastro/saspro/gui/main_window.py

@@ -361,6 +361,69 @@ class UiStallDetector(QObject):
             print(f"[UI STALL] tick late by {late_ms:.0f} ms (elapsed={elapsed_ms:.0f} ms)", flush=True)
             self._dump_all_threads_print()
 
+def _strip_filename_ext(title: str) -> str:
+    t = (title or "").strip()
+    if not t:
+        return t
+    base, ext = os.path.splitext(t)
+    # treat as extension only if it looks like one: .fit .fits .tif .tiff .xisf etc
+    if ext and 1 <= len(ext) <= 10 and all(ch.isalnum() for ch in ext[1:]):
+        return base
+    return t
+
+
+
+_DECOR_GLYPHS = "■●◆▲▪▫•◼◻◾◽🔗"
+
+def normalize_doc_title(s: str) -> str:
+    s = (s or "").strip()
+
+    # remove our textual prefix too
+    if s.startswith("[LINK] "):
+        s = s[len("[LINK] "):].strip()
+
+    # strip common UI decorations if you already have this helper
+    try:
+        s = _strip_ui_decorations(s)
+    except Exception:
+        pass
+
+    # remove any leading decorator glyphs repeatedly: "🔗 ", "■ ", etc.
+    while len(s) >= 2 and s[0] in _DECOR_GLYPHS and s[1] == " ":
+        s = s[2:].lstrip()
+
+    # also remove any stray decorator glyphs that got embedded (rare but happens)
+    s = re.sub(rf"[{re.escape(_DECOR_GLYPHS)}]", "", s).strip()
+
+    return s
+
+_VIEW_SUFFIX_RE = re.compile(r"\s+\[View\s+\d+\]\s*$")
+
+def _normalize_title_for_compare(t: str) -> str:
+    t = (t or "").strip()
+    if not t:
+        return ""
+
+    # strip UI decorations (🔗, ■, etc)
+    try:
+        t = _strip_ui_decorations(t)
+    except Exception:
+        pass
+
+    # strip trailing "[View N]" if present
+    t = _VIEW_SUFFIX_RE.sub("", t).strip()
+
+    # strip filename-like extension
+    try:
+        t = _strip_filename_ext(t)
+    except Exception:
+        # fallback: only strip if it looks like an ext
+        base, ext = os.path.splitext(t)
+        if ext and len(ext) <= 10:
+            t = base
+
+    return t.strip()
+
 class AstroSuiteProMainWindow(
     DockMixin, MenuMixin, ToolbarMixin, FileMixin,
     ThemeMixin, GeometryMixin, ViewMixin, HeaderMixin, MaskMixin, UpdateMixin,
@@ -7779,12 +7842,8 @@ class AstroSuiteProMainWindow(
                 return cand
             n += 1
 
+    
     def _doc_window_title(self, doc) -> str:
-        """
-        Best-effort human title for a subwindow.
-        Prefer metadata['display_name'] (what duplication sets),
-        then doc.display_name(), then basename(file_path).
-        """
         md = getattr(doc, "metadata", {}) or {}
 
         t = (md.get("display_name") or "").strip()
@@ -7797,8 +7856,7 @@ class AstroSuiteProMainWindow(
         if not t:
             fp = (md.get("file_path") or "").strip()
             if fp:
-                import os
-                t = os.path.basename(fp)
+                t = os.path.splitext(os.path.basename(fp))[0]   # ✅ strip ext here too
 
         t = t or "Untitled"
 
@@ -7807,8 +7865,11 @@ class AstroSuiteProMainWindow(
             t = _strip_ui_decorations(t)
         except Exception:
             pass
-        return t
 
+        # ✅ ALWAYS strip filename-like extension at the very end
+        t = _strip_filename_ext(t)
+
+        return t
 
     def _spawn_subwindow_for(self, doc, *, force_new: bool = False):
         """
@@ -7945,7 +8006,8 @@ class AstroSuiteProMainWindow(
         # We target ~60% of the viewport height, clamped to sane bounds.
         # -------------------------------------------------------------------------
         vp = self.mdi.viewport()
-        area = vp.rect() if vp else self.mdi.rect()
+        # Use viewport geometry in MDI coordinates (NOT viewport-local rect)
+        area = vp.geometry() if vp else self.mdi.contentsRect()
         
         # Determine aspect ratio
         img_w = img_h = None
@@ -7988,7 +8050,7 @@ class AstroSuiteProMainWindow(
         # Smart Cascade: Position relative to the *currently active* window
         # (before we make the new one active).
         # -------------------------------------------------------------------------
-        new_x, new_y = 0, 0
+        new_x, new_y = area.left(), area.top()
         
         # Get dominant/active window *before* we activate the new one
         active = self.mdi.activeSubWindow()
@@ -8011,15 +8073,13 @@ class AstroSuiteProMainWindow(
             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)
+        # Bounds check: keep titlebar visible and stay inside viewport
+        if (new_x + target_w > area.right() - 10) or (new_y + 40 > area.bottom() - 10):
+            new_x = area.left()
+            new_y = area.top()
+
+        new_x = max(area.left(), new_x)
+        new_y = max(area.top(), new_y)
 
         sw.move(new_x, new_y)
 
@@ -8114,6 +8174,11 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
+        try:
+            self._fix_mdi_titlebar_emboss("#dcdcdc" if self._theme_mode()=="dark" else "#f0f0f0")
+        except Exception:
+            pass
+
         # -- 11) If this is the first window and it's an image, mimic "Cascade Views"
         try:
             if first_window and not is_table:
@@ -8208,25 +8273,57 @@ class AstroSuiteProMainWindow(
             "autostretch_target": float(getattr(source_view, "autostretch_target", 0.25)),
         }
 
-        # 2) New name (strip UI decorations if any)
-        base_name = ""
+        # 2) New name (normalized: NO decorators like 🔗■●◆▲▪▫•◼◻◾◽)
         try:
-            base_name = base_doc.display_name() or "Untitled"
+            base_name = self._doc_window_title(base_doc)  # might include decorations
         except Exception:
             base_name = "Untitled"
 
+        # Normalize it so uniqueness checks don't miss decorated titles
+        try:
+            base_name = normalize_doc_title(base_name)
+        except Exception:
+            base_name = (base_name or "Untitled").strip()
+
+        # Build a set of existing document names (normalized)
+        existing = set()
         try:
-            base_name = _strip_ui_decorations(base_name)
+            dm = getattr(self, "doc_manager", None) or getattr(self, "docman", None)
+            docs = []
+
+            # Prefer an official accessor if you have one
+            if dm is not None:
+                if hasattr(dm, "documents"):
+                    docs = list(dm.documents())
+                elif hasattr(dm, "_docs"):
+                    docs = list(dm._docs)
+
+            for d in docs:
+                try:
+                    dn = ""
+                    md = getattr(d, "metadata", {}) or {}
+                    dn = (md.get("display_name") or "").strip() or (d.display_name() or "").strip()
+                    dn = normalize_doc_title(dn)
+                    if dn:
+                        existing.add(dn)
+                except Exception:
+                    pass
         except Exception:
-            # minimal fallback: remove our known prefix/glyphs
-            while len(base_name) >= 2 and base_name[1] == " " and base_name[0] in "â- â--â--†â-²â-ªâ-«â€¢â--¼â--»â--¾â--½":
-                base_name = base_name[2:]
-            if base_name.startswith("Active View: "):
-                base_name = base_name[len("Active View: "):]
+            pass
+
+        # Pick a unique duplicate name: base_duplicate, base_duplicate2, ...
+        candidate = f"{base_name}_duplicate"
+        if candidate in existing:
+            n = 2
+            while True:
+                cand = f"{base_name}_duplicate{n}"
+                if cand not in existing:
+                    candidate = cand
+                    break
+                n += 1
 
         # 3) Duplicate the *base* document (not the ROI proxy)
-        #    NOTE: your project uses `self.docman` elsewhere for duplication.
-        new_doc = self.docman.duplicate_document(base_doc, new_name=f"{base_name}_duplicate")
+        new_doc = self.docman.duplicate_document(base_doc, new_name=candidate)
         print(f"  Duplicated document ID {id(base_doc)} -> {id(new_doc)}")
 
         # 4) Ensure the duplicate starts mask-free (so we don't inherit mask UI state)
@@ -8521,7 +8618,10 @@ class AstroSuiteProMainWindow(
             self._refresh_mask_action_states()
         except Exception:
             pass
-
+        try:
+            self._fix_mdi_titlebar_emboss("#dcdcdc" if self._theme_mode()=="dark" else "#f0f0f0")
+        except Exception:
+            pass
 
     def _sync_docman_active(self, doc):
         dm = self.doc_manager

setiastro/saspro/gui/mixins/theme_mixin.py

@@ -9,12 +9,30 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from PyQt6.QtCore import Qt, QTimer
-from PyQt6.QtGui import QBrush, QColor, QFont, QPalette
-from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QBrush, QColor, QFont, QPalette, QPainter, QPixmap, QIcon
+from PyQt6.QtWidgets import QApplication, QLabel, QWidget
 
 if TYPE_CHECKING:
     pass
 
+def _force_mdi_subwindow_flags(sw):
+    f = sw.windowFlags()
+
+    # Clear only the *window type* bits (NOT random low bits)
+    f &= ~Qt.WindowType.WindowType_Mask
+
+    # Force true MDI child type
+    f |= Qt.WindowType.SubWindow
+
+    # Add desired buttons/hints
+    f |= (Qt.WindowType.CustomizeWindowHint |
+          Qt.WindowType.WindowTitleHint |
+          Qt.WindowType.WindowSystemMenuHint |
+          Qt.WindowType.WindowMinimizeButtonHint |
+          Qt.WindowType.WindowMaximizeButtonHint |
+          Qt.WindowType.WindowCloseButtonHint)
+
+    sw.setWindowFlags(f)
 
 class ThemeMixin:
     """
@@ -88,7 +106,7 @@ class ThemeMixin:
             app.setPalette(self._gray_palette())
             app.setStyleSheet(
                 "QToolTip { color: #f0f0f0; background-color: #3a3a3a; border: 1px solid #5a5a5a; }"
-            )
+            )            
         elif mode == "light":
             app.setPalette(self._light_palette())
             app.setStyleSheet(
@@ -119,6 +137,11 @@ class ThemeMixin:
         self._repolish_top_levels()
         self._apply_workspace_theme()
         self._style_mdi_titlebars()
+
+        try:
+            self._retint_zoom_icons()
+        except Exception:
+            pass        
         self._menu_view_panels = None
 
         try:
@@ -139,26 +162,149 @@ class ThemeMixin:
             w.setUpdatesEnabled(True)
 
     def _style_mdi_titlebars(self):
-        """Apply theme-specific styles to MDI subwindow titlebars."""
         mode = self._theme_mode()
+
         if mode == "dark":
-            base = "#1b1b1b"   # inactive titlebar
-            active = "#242424"  # active titlebar
+            base = "#1b1b1b"
+            active = "#242424"
             fg = "#dcdcdc"
         elif mode in ("gray", "custom"):
             base = "#3a3a3a"
             active = "#454545"
             fg = "#f0f0f0"
         else:
-            # No override in light / system modes
-            self.mdi.setStyleSheet("")
-            return
+            base = "#eaeaea"
+            active = "#ffffff"
+            fg = "#141414"
 
+        # style *our* titlebar only
         self.mdi.setStyleSheet(f"""
-            QMdiSubWindow::titlebar        {{ background: {base};  color: {fg}; }}
-            QMdiSubWindow::titlebar:active {{ background: {active}; color: {fg}; }}
+            QWidget#sas_mdi_titlebar {{
+                background: {base};
+            }}
+            QWidget#sas_mdi_titlebar[active="true"] {{
+                background: {active};
+            }}
+            QLabel#sas_mdi_title_label {{
+                color: {fg};
+                background: transparent;
+            }}
+            QWidget#sas_mdi_titlebar QToolButton {{
+                color: {fg};
+                background: transparent;
+            }}
+            QWidget#sas_mdi_titlebar QToolButton:hover {{
+                background: rgba(255,255,255,0.10);
+            }}
         """)
 
+
+    def _fix_mdi_titlebar_emboss(self, fg_hex: str):
+        """
+        Fusion/Windows style can draw embossed title text (two-pass).
+        In dark themes that can become white-on-white -> 'double text'.
+        Force the shadow/emboss colors on the *titlebar widget only*.
+        """
+        try:
+            fg = QColor(fg_hex)
+        except Exception:
+            fg = QColor(240, 240, 240)
+
+        for sw in self.mdi.subWindowList():
+            try:
+                tb = sw.findChild(QWidget, "qt_mdi_titlebar")
+                if tb is None:
+                    continue
+
+                pal = tb.palette()
+
+                # Main text
+                pal.setColor(QPalette.ColorRole.WindowText, fg)
+                pal.setColor(QPalette.ColorRole.Text, fg)
+                pal.setColor(QPalette.ColorRole.ButtonText, fg)
+
+                # Critical: make the embossed/shadow pass dark
+                dark = QColor(0, 0, 0)
+                pal.setColor(QPalette.ColorRole.Light, dark)
+                pal.setColor(QPalette.ColorRole.Midlight, dark)
+                pal.setColor(QPalette.ColorRole.Dark, dark)
+                pal.setColor(QPalette.ColorRole.Shadow, dark)
+
+                tb.setPalette(pal)
+
+                # Also push to the label if present (some styles read it from label)
+                lbl = tb.findChild(QLabel)
+                if lbl is not None:
+                    lbl.setPalette(pal)
+            except Exception:
+                pass
+
+    def _tint_icon(self, icon: QIcon, color: QColor) -> QIcon:
+        """
+        Take an existing icon (often fromTheme) and force a single-color glyph.
+        Sets Normal and Active to the same tinted pixmaps to prevent hover flipping.
+        """
+        if icon.isNull():
+            return icon
+
+        out = QIcon()
+        sizes = [16, 20, 24, 32, 48, 64]
+
+        for sz in sizes:
+            pm = icon.pixmap(sz, sz, QIcon.Mode.Normal, QIcon.State.Off)
+            if pm.isNull():
+                continue
+
+            tinted = QPixmap(pm.size())
+            tinted.fill(Qt.GlobalColor.transparent)
+
+            p = QPainter(tinted)
+            p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+            p.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
+
+            # Use the original alpha as a mask, fill with our color
+            p.drawPixmap(0, 0, pm)
+            p.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+            p.fillRect(tinted.rect(), color)
+            p.end()
+
+            # Normal + Active -> same pixmap (prevents hover flip)
+            out.addPixmap(tinted, QIcon.Mode.Normal, QIcon.State.Off)
+            out.addPixmap(tinted, QIcon.Mode.Active, QIcon.State.Off)
+
+            # Disabled: slightly dimmer (optional)
+            dis = QColor(color)
+            dis.setAlphaF(0.45)
+            dispm = QPixmap(tinted.size())
+            dispm.fill(Qt.GlobalColor.transparent)
+            p2 = QPainter(dispm)
+            p2.drawPixmap(0, 0, tinted)
+            p2.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+            p2.fillRect(dispm.rect(), dis)
+            p2.end()
+            out.addPixmap(dispm, QIcon.Mode.Disabled, QIcon.State.Off)
+
+        return out
+
+    def _retint_zoom_icons(self):
+        """
+        Retint only the zoom actions (the ones built from QIcon.fromTheme).
+        Call after app palette is applied.
+        """
+        pal = QApplication.palette()
+        glyph = pal.color(QPalette.ColorRole.ButtonText)  # or Text; ButtonText tends to match toolbars well
+
+        for name in ("act_zoom_out", "act_zoom_in", "act_zoom_1_1", "act_zoom_fit"):
+            act = getattr(self, name, None)
+            if act is None:
+                continue
+
+            # stash original once so repeated theme flips don't re-tint a tinted icon
+            if not hasattr(act, "_base_icon"):
+                act._base_icon = act.icon()
+
+            act.setIcon(self._tint_icon(act._base_icon, glyph))
+
     def _dark_palette(self) -> QPalette:
         """Create a dark theme palette."""
         p = QPalette()
@@ -172,7 +318,7 @@ class ThemeMixin:
         hi = QColor(30, 144, 255)    # highlight (dodger blue)
 
         p.setColor(QPalette.ColorRole.Window, panel)
-        p.setColor(QPalette.ColorRole.WindowText, text)
+        p.setColor(QPalette.ColorRole.WindowText, QColor(255, 255, 255))
         p.setColor(QPalette.ColorRole.Base, bg)
         p.setColor(QPalette.ColorRole.AlternateBase, altbase)
         p.setColor(QPalette.ColorRole.ToolTipBase, panel)
@@ -270,7 +416,7 @@ class ThemeMixin:
         link = QColor(120, 170, 255)
         linkv = QColor(180, 150, 255)
         hi = QColor(95, 145, 230)
-        hitxt = QColor(255, 255, 255)
+        hitxt = QColor(20, 20, 20)
 
         # Core roles
         p.setColor(QPalette.ColorRole.Window, window)
@@ -300,7 +446,7 @@ class ThemeMixin:
         p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.WindowText, dis)
         p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Base, QColor(58, 58, 58))
         p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Highlight, QColor(80, 80, 80))
-        p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.HighlightedText, QColor(210, 210, 210))
+        p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.HighlightedText, QColor(20, 20, 20))
 
         return p