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

setiastro/saspro/subwindow.py

@@ -1,4 +1,4 @@
-# pro/subwindow.py
+# src/setiastro/saspro/subwindow.py
 from __future__ import annotations
 from PyQt6.QtCore import Qt, QPoint, pyqtSignal, QSize, QEvent, QByteArray, QMimeData, QSettings, QTimer, QRect, QPoint, QMargins
 from PyQt6.QtWidgets import QWidget, QVBoxLayout, QScrollArea, QLabel, QToolButton, QHBoxLayout, QMessageBox, QMdiSubWindow, QMenu, QInputDialog, QApplication, QTabWidget, QRubberBand
@@ -9,6 +9,7 @@ import json
 import math
 import weakref
 import os
+import re
 try:
     from PyQt6.QtCore import QSignalBlocker
 except Exception:
@@ -136,6 +137,22 @@ DECORATION_PREFIXES = (
     "Active View: ",            # legacy
 )
 
+_GLYPH_RE = re.compile(f"[{re.escape(GLYPHS)}]")
+
+def _strip_ui_decorations(title: str) -> str:
+    if not title:
+        return ""
+    s = str(title).strip()
+
+    # Remove common prefix tag(s)
+    s = s.replace("[LINK]", "").strip()
+
+    # Remove glyphs anywhere (often used as status markers in titles)
+    s = _GLYPH_RE.sub("", s)
+
+    # Collapse repeated whitespace
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
 
 from astropy.wcs import WCS as _AstroWCS
 from astropy.io.fits import Header as _FitsHeader
@@ -311,7 +328,35 @@ def _compute_cropped_wcs(parent_hdr_like, x, y, w, h):
     base["SASKIND"] = "ROI-CROP"
     return base
 
-
+def _dnd_dbg_dump_state(tag: str, state: dict):
+    try:
+        import json
+        # Keep it readable but complete
+        keys = sorted(state.keys())
+        print(f"\n[DNDDBG:{tag}] keys={keys}")
+        for k in keys:
+            v = state.get(k)
+            # avoid huge blobs
+            if isinstance(v, (dict, list)) and len(str(v)) > 400:
+                print(f"  {k} = <{type(v).__name__} len={len(v)}>")
+            else:
+                print(f"  {k} = {v!r}")
+        # show json size
+        raw = json.dumps(state).encode("utf-8")
+        print(f"[DNDDBG:{tag}] json_bytes={len(raw)} head={raw[:120]!r}")
+    except Exception as e:
+        print(f"[DNDDBG:{tag}] dump failed: {e}")
+
+_DEBUG_DND_DUP = False
+
+def _strip_ext_if_filename(s: str) -> str:
+    s = (s or "").strip()
+    if not s:
+        return s
+    base, ext = os.path.splitext(s)
+    if ext and len(ext) <= 10:
+        return base
+    return s
 
 class ImageSubWindow(QWidget):
     aboutToClose = pyqtSignal(object)
@@ -469,6 +514,32 @@ class ImageSubWindow(QWidget):
         row.addWidget(self._btn_wcs, 0, Qt.AlignmentFlag.AlignLeft)
         # ─────────────────────────────────────────────────────────────────
 
+        # ---- Inline view title (shown when the MDI subwindow is maximized) ----
+        self._inline_title = QLabel(self)
+        self._inline_title.setText("")
+        self._inline_title.setToolTip(self.tr("Active view"))
+        self._inline_title.setVisible(False)
+        self._inline_title.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        self._inline_title.setStyleSheet("""
+            QLabel {
+                padding-left: 8px;
+                padding-right: 6px;
+                font-size: 11px;
+                color: rgba(255,255,255,0.80);
+            }
+        """)
+        self._inline_title.setSizePolicy(
+            self._inline_title.sizePolicy().horizontalPolicy(),
+            self._inline_title.sizePolicy().verticalPolicy(),
+        )
+
+        # Push everything after this to the far right
+        row.addStretch(1)
+        row.addWidget(self._inline_title, 0, Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight)
+
+        # (optional) tiny spacing to the edge
+        row.addSpacing(6)
+
         row.addStretch(1)
         lyt.addLayout(row)
 
@@ -549,6 +620,9 @@ class ImageSubWindow(QWidget):
         self._history_doc = None
         self._install_history_watchers()
 
+        QTimer.singleShot(0, self._install_mdi_state_watch)
+        QTimer.singleShot(0, self._update_inline_title_and_buttons)
+
     # ----- link drag payload -----
     def _start_link_drag(self):
         """
@@ -680,7 +754,60 @@ class ImageSubWindow(QWidget):
         except Exception:
             pass
 
-    #------ Replay helpers------
+    # ------------------------------------------------------------
+    # MDI maximize handling: show inline title + avoid duplicate buttons
+    # ------------------------------------------------------------
+    def _mdi_subwindow(self) -> QMdiSubWindow | None:
+        w = self.parentWidget()
+        while w is not None and not isinstance(w, QMdiSubWindow):
+            w = w.parentWidget()
+        return w
+
+    def _install_mdi_state_watch(self):
+        sw = self._mdi_subwindow()
+        if sw is None:
+            return
+        # Watch maximize/restore changes on the hosting QMdiSubWindow
+        sw.installEventFilter(self)
+
+    def _is_mdi_maximized(self) -> bool:
+        sw = self._mdi_subwindow()
+        if sw is None:
+            return False
+        try:
+            return sw.isMaximized()
+        except Exception:
+            return False
+
+    def _set_mdi_minmax_buttons_enabled(self, enabled: bool):
+        return  # leave Qt default buttons alone
+
+    def _current_view_title_for_inline(self) -> str:
+        # Prefer your already-pretty title (strip decorations if needed).
+        try:
+            # If you have _current_view_title_for_drag already, reuse it:
+            return self._current_view_title_for_drag()
+        except Exception:
+            pass
+        try:
+            return (self.windowTitle() or "").strip()
+        except Exception:
+            return ""
+
+    def _update_inline_title_and_buttons(self):
+        maximized = self._is_mdi_maximized()
+
+        # Show inline title only when maximized (optional)
+        try:
+            self._inline_title.setVisible(maximized)
+            if maximized:
+                self._inline_title.setText(self._current_view_title_for_inline() or "Untitled")
+        except Exception:
+            pass
+
+        # IMPORTANT: do NOT change QMdiSubWindow window flags.
+        # Leaving them alone restores the default Qt "double button" behavior.
+
     #------ Replay helpers------
     def _update_replay_button(self):
         """
@@ -741,15 +868,6 @@ class ImageSubWindow(QWidget):
         enabled = bool(has_preview and (has_history or has_last))
         btn.setEnabled(enabled)
 
-        # DEBUG:
-        try:
-            print(
-                f"[Replay] _update_replay_button: view id={id(self)} "
-                f"enabled={enabled}, has_preview={has_preview}, "
-                f"history_len={len(history)}"
-            )
-        except Exception:
-            pass
 
     def _replay_history_index(self, index: int):
         """
@@ -809,11 +927,7 @@ class ImageSubWindow(QWidget):
         except Exception:
             pass
 
-        # Emit self so the main window can locate our QMdiSubWindow wrapper.
-        try:
-            print(f"[Replay] Emitting replayOnBaseRequested from view id={id(self)}")
-        except Exception:
-            pass
+
         self.replayOnBaseRequested.emit(self)
 
 
@@ -823,13 +937,20 @@ class ImageSubWindow(QWidget):
         self._emit_view_transform()
 
     def set_view_transform(self, scale, hval, vval, from_link=False):
-        # Avoid storms while we mutate scrollbars/scale
         self._suppress_link_emit = True
         try:
             scale = float(max(self._min_scale, min(scale, self._max_scale)))
-            if abs(scale - self.scale) > 1e-9:
+
+            scale_changed = (abs(scale - self.scale) > 1e-9)
+            if scale_changed:
                 self.scale = scale
-                self._render(rebuild=False)
+                self._render(rebuild=False)  # fast present for responsiveness
+
+                # ✅ NEW: schedule the final smooth redraw (same as main zoom path)
+                try:
+                    self._request_zoom_redraw()
+                except Exception:
+                    pass
 
             hbar = self.scroll.horizontalScrollBar()
             vbar = self.scroll.verticalScrollBar()
@@ -841,14 +962,14 @@ class ImageSubWindow(QWidget):
         finally:
             self._suppress_link_emit = False
 
-        # IMPORTANT: if this came from a linked peer, do NOT broadcast again.
         if not from_link:
             self._schedule_emit_view_transform()
 
+
     def _on_toggle_wcs_grid(self, on: bool):
         self._show_wcs_grid = bool(on)
         QSettings().setValue("display/show_wcs_grid", self._show_wcs_grid)
-        self._render(rebuild=False)  # repaint current frame
+        self._render(rebuild=True)  # repaint current frame
 
 
 
@@ -880,33 +1001,32 @@ class ImageSubWindow(QWidget):
         # make the buttons correct right now
         self._refresh_local_undo_buttons()
 
-    def _drag_identity_fields(self):
-        """
-        Returns a dict with identity hints for DnD:
-        doc_uid (preferred), base_doc_uid (parent/full), and file_path.
-        Falls back gracefully if fields are missing.
-        """
-        doc = getattr(self, "document", None)
-        base = getattr(self, "base_document", None) or doc
+    def _drag_identity_fields(self) -> dict:
+        st = {}
 
-        # If DocManager maps preview/ROI views, prefer the true backing doc as base
-        dm = getattr(self, "_docman", None)
+        # existing identity (whatever you already do)
         try:
-            if dm and hasattr(dm, "get_document_for_view"):
-                back = dm.get_document_for_view(self)
-                if back is not None:
-                    base = back
+            doc = getattr(self, "document", None)
+            st["doc_ptr"] = id(doc) if doc is not None else None
+            st["doc_uid"] = getattr(doc, "uid", None)
+            meta = getattr(doc, "metadata", {}) or {}
+            st["file_path"] = (meta.get("file_path") or "").strip()
+            st["base_doc_uid"] = meta.get("base_doc_uid") or st["doc_uid"]
+            st["source_kind"] = meta.get("source_kind") or "full"
         except Exception:
             pass
 
-        meta = (getattr(doc, "metadata", None) or {})
-        base_meta = (getattr(base, "metadata", None) or {})
+        # ✅ NEW: add the current user-visible view title
+        st["source_view_title"] = self._current_view_title_for_drag()
 
-        return {
-            "doc_uid": getattr(doc, "uid", None),
-            "base_doc_uid": getattr(base, "uid", None),
-            "file_path": meta.get("file_path") or base_meta.get("file_path") or "",
-        }
+        # (optional) also include the subwindow title raw, for debugging/forensics
+        try:
+            sw = self._mdi_subwindow()
+            st["source_sw_title_raw"] = (sw.windowTitle() if sw is not None else "")
+        except Exception:
+            st["source_sw_title_raw"] = ""
+
+        return st
 
 
     def _on_local_undo(self):
@@ -1188,18 +1308,6 @@ class ImageSubWindow(QWidget):
         except Exception as e:
             print("[ImageSubWindow] apply_layer_stack error:", e)      
 
-    # --- add to ImageSubWindow ---
-    def _collect_layer_docs(self):
-        docs = set()
-        for L in getattr(self, "_layers", []):
-            d = getattr(L, "src_doc", None)
-            if d is not None:
-                docs.add(d)
-            md = getattr(L, "mask_doc", None)
-            if md is not None:
-                docs.add(md)
-        return docs
-
     def keyPressEvent(self, ev):
         if ev.key() == Qt.Key.Key_Space:
             # only the first time we enter probe mode
@@ -1321,51 +1429,116 @@ class ImageSubWindow(QWidget):
         except Exception as e:
             print("[ImageSubWindow] _on_layer_source_changed error:", e)
 
+    def _collect_layer_docs(self):
+        """
+        Collect unique ImageDocument objects referenced by the layer stack:
+        - layer src_doc (if doc-backed)
+        - layer mask_doc (if any)
+        Raster/baked layers may have src_doc=None; those are ignored.
+        Returns a LIST in a stable order (bottom→top traversal order), de-duped.
+        """
+        out = []
+        seen = set()
+
+        layers = getattr(self, "_layers", None) or []
+        for L in layers:
+            # 1) source doc (may be None for raster/baked layers)
+            d = getattr(L, "src_doc", None)
+            if d is not None:
+                k = id(d)
+                if k not in seen:
+                    seen.add(k)
+                    out.append(d)
+
+            # 2) mask doc (also may be None)
+            md = getattr(L, "mask_doc", None)
+            if md is not None:
+                k = id(md)
+                if k not in seen:
+                    seen.add(k)
+                    out.append(md)
+
+        return out
+
+
     def _reinstall_layer_watchers(self):
+        """
+        Reconnect layer source/mask document watchers to trigger live layer recomposite.
+        Safe against:
+        - raster/baked layers (src_doc=None)
+        - deleted docs / partially-torn-down Qt objects
+        - repeated calls
+        """
+        # Previous watchers
+        olddocs = list(getattr(self, "_watched_docs", []) or [])
+
         # Disconnect old
-        for d in list(self._watched_docs):
+        for d in olddocs:
             try:
+                # Doc may already be deleted or signal gone
                 d.changed.disconnect(self._on_layer_source_changed)
             except Exception:
                 pass
-        # Connect new
+
+        # Collect new
         newdocs = self._collect_layer_docs()
+
+        # Connect new
         for d in newdocs:
             try:
                 d.changed.connect(self._on_layer_source_changed)
             except Exception:
                 pass
+
+        # Store as list (stable)
         self._watched_docs = newdocs
 
 
+
     def toggle_mask_overlay(self):
         self.show_mask_overlay = not self.show_mask_overlay
         self._render(rebuild=True)
 
     def _rebuild_title(self, *, base: str | None = None):
         sub = self._mdi_subwindow()
-        if not sub: return
+        if not sub:
+            return
+
         if base is None:
             base = self._effective_title() or self.tr("Untitled")
 
-        # ✅ strip any carried-over glyphs (🔗, ■, “Active View: ”) from overrides/doc names
+        # Strip badges (🔗, ■, etc) AND "Active View:" prefix
         core, _ = self._strip_decorations(base)
 
-        title = core
+        # ALSO strip file extensions if it looks like a filename
+        # (this prevents .tiff/.fit coming back via any fallback path)
+        try:
+            b, ext = os.path.splitext(core)
+            if ext and len(ext) <= 10 and not core.endswith("..."):
+                core = b
+        except Exception:
+            pass
+
+        # Build the displayed title with badges
+        shown = core
         if getattr(self, "_link_badge_on", False):
-            title = f"{LINK_PREFIX}{title}"
+            shown = f"{LINK_PREFIX}{shown}"
         if self._mask_dot_enabled:
-            title = f"{MASK_GLYPH} {title}"
+            shown = f"{MASK_GLYPH} {shown}"
+
+        # Update chrome
+        if shown != sub.windowTitle():
+            sub.setWindowTitle(shown)
+            sub.setToolTip(shown)
+
+        # IMPORTANT: emit ONLY the clean core (no badges, no extensions)
+        if core != self._last_title_for_emit:
+            self._last_title_for_emit = core
+            try:
+                self.viewTitleChanged.emit(self, core)
+            except Exception:
+                pass
 
-        if title != sub.windowTitle():
-            sub.setWindowTitle(title)
-            sub.setToolTip(title)
-            if title != self._last_title_for_emit:
-                self._last_title_for_emit = title
-                try: self.viewTitleChanged.emit(self, title)
-                except Exception as e:
-                    import logging
-                    logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
 
 
     def _strip_decorations(self, title: str) -> tuple[str, bool]:
@@ -1394,21 +1567,7 @@ class ImageSubWindow(QWidget):
     def set_active_highlight(self, on: bool):
         self._is_active_flag = bool(on)
         return
-        sub = self._mdi_subwindow()
-        if not sub:
-            return
-
-        core, had_glyph = self._strip_decorations(sub.windowTitle())
 
-        if on and not getattr(self, "_suppress_active_once", False):
-            core = ACTIVE_PREFIX + core
-        self._suppress_active_once = False
-
-        # recompose: glyph (from flag), then active prefix, then base/core
-        if getattr(self, "_mask_dot_enabled", False):
-            core = "■ " + core
-        #sub.setWindowTitle(core)
-        sub.setToolTip(core)
 
     def _set_mask_highlight(self, on: bool):
         self._mask_dot_enabled = bool(on)
@@ -1516,15 +1675,53 @@ class ImageSubWindow(QWidget):
     def is_hard_autostretch(self) -> bool:
         return self.autostretch_profile == "hard"
 
-    def _mdi_subwindow(self) -> QMdiSubWindow | None:
-        w = self.parent()
-        while w is not None and not isinstance(w, QMdiSubWindow):
-            w = w.parent()
-        return w
+    #def _mdi_subwindow(self) -> QMdiSubWindow | None:
+    #    w = self.parent()
+    #    while w is not None and not isinstance(w, QMdiSubWindow):
+    #        w = w.parent()
+    #    return w
 
     def _effective_title(self) -> str:
-        # Prefer a per-view override; otherwise doc display name
-        return self._view_title_override or self.document.display_name()
+        """
+        Returns the *core* title for this view (no UI badges like 🔗/■, and no file extension).
+        Badges are added later by _rebuild_title().
+        """
+        # 1) Prefer per-view override if set
+        t = (self._view_title_override or "").strip()
+
+        # 2) Else prefer metadata display_name (what duplicate/rename should set)
+        if not t:
+            try:
+                md = getattr(self.document, "metadata", {}) or {}
+                t = (md.get("display_name") or "").strip()
+            except Exception:
+                t = ""
+
+        # 3) Else fall back to doc.display_name()
+        if not t:
+            try:
+                t = (self.document.display_name() or "").strip()
+            except Exception:
+                t = ""
+
+        t = t or self.tr("Untitled")
+
+        # Strip UI decorations (🔗, ■, Active View:, etc.)
+        try:
+            t, _ = self._strip_decorations(t)
+        except Exception:
+            pass
+
+        # Strip extension if it looks like a filename
+        try:
+            base, ext = os.path.splitext(t)
+            if ext and len(ext) <= 10:
+                t = base
+        except Exception:
+            pass
+
+        return t
+
 
     def _show_ctx_menu(self, pos):
         menu = QMenu(self)
@@ -1603,13 +1800,20 @@ class ImageSubWindow(QWidget):
                     pass
 
     def set_scale(self, s: float):
+        # Programmatic scale changes must schedule final smooth redraw
         s = float(max(self._min_scale, min(s, self._max_scale)))
         if abs(s - self.scale) < 1e-9:
             return
         self.scale = s
-        self._render()                 # only scale needs a redraw
+        self._render()                 # fast present happens here
         self._schedule_emit_view_transform()
 
+        # ✅ NEW: ensure we do the final smooth redraw (same as manual zoom)
+        try:
+            self._request_zoom_redraw()
+        except Exception:
+            pass
+
 
 
     # ---- view state API (center in image coords + scale) ----
@@ -1634,20 +1838,19 @@ class ImageSubWindow(QWidget):
         vbar = self.scroll.verticalScrollBar()
 
         state = {
-            "doc_ptr": id(self.document),                      # legacy
+            "doc_ptr": id(self.document),
             "scale": float(self.scale),
             "hval": int(hbar.value()),
             "vval": int(vbar.value()),
             "autostretch": bool(self.autostretch_enabled),
             "autostretch_target": float(self.autostretch_target),
         }
-        state.update(self._drag_identity_fields())             # uid + base_uid + file_path
+        state.update(self._drag_identity_fields())
 
-        # --- NEW: annotate ROI/source_kind so drop knows this came from a Preview tab
         roi = None
         try:
             if hasattr(self, "has_active_preview") and self.has_active_preview():
-                r = self.current_preview_roi()  # (x,y,w,h) in full-image coords
+                r = self.current_preview_roi()
                 if r and len(r) == 4:
                     roi = tuple(map(int, r))
         except Exception:
@@ -1665,14 +1868,29 @@ class ImageSubWindow(QWidget):
         else:
             state["source_kind"] = "full"
 
+        if _DEBUG_DND_DUP:
+            _dnd_dbg_dump_state("DRAG_START:dragtab", state)
+
+
         md = QMimeData()
         md.setData(MIME_VIEWSTATE, QByteArray(json.dumps(state).encode("utf-8")))
 
         drag = QDrag(self)
         drag.setMimeData(md)
-        if self.label.pixmap():
-            drag.setPixmap(self.label.pixmap())
-        drag.exec()
+
+        pm = self.label.pixmap()
+        if pm and not pm.isNull():
+            drag.setPixmap(
+                pm.scaled(
+                    96, 96,
+                    Qt.AspectRatioMode.KeepAspectRatio,
+                    Qt.TransformationMode.SmoothTransformation,
+                )
+            )
+            drag.setHotSpot(QPoint(16, 16))  # optional, but feels nicer
+
+        drag.exec(Qt.DropAction.CopyAction)
+
 
 
 
@@ -1775,6 +1993,55 @@ class ImageSubWindow(QWidget):
 
 
     # ---- DnD 'view tab' -------------------------------------------------
+
+    def _mdi_subwindow(self):
+        """Return the QMdiSubWindow that hosts this view, or None."""
+        try:
+            from PyQt6.QtWidgets import QMdiSubWindow
+            p = self.parent()
+            while p is not None:
+                if isinstance(p, QMdiSubWindow):
+                    return p
+                p = p.parent()
+        except Exception:
+            pass
+        return None
+
+    def _current_view_title_for_drag(self) -> str:
+        """
+        The *actual* user-visible view title (what they renamed to),
+        NOT the document/file name.
+        """
+        title = ""
+        try:
+            sw = self._mdi_subwindow()
+            if sw is not None:
+                title = (sw.windowTitle() or "").strip()
+        except Exception:
+            title = ""
+
+        if not title:
+            try:
+                title = (self.windowTitle() or "").strip()
+            except Exception:
+                title = ""
+
+        if not title:
+            # absolute fallback
+            try:
+                title = (self.document.display_name() or "").strip()
+            except Exception:
+                title = ""
+
+        # Optional: strip [LINK], glyphs, etc if your title includes those
+        try:
+            title = _strip_ui_decorations(title)
+        except Exception:
+            pass
+
+        return title or "Untitled"
+
+
     def _install_view_tab(self):
         self._view_tab = QToolButton(self)
         self._view_tab.setText(self.tr("View"))
@@ -1794,19 +2061,28 @@ class ImageSubWindow(QWidget):
         if ev.button() != Qt.MouseButton.LeftButton:
             return QToolButton.mousePressEvent(self._view_tab, ev)
 
-        # build the SAME payload schema used by _start_viewstate_drag()
         hbar = self.scroll.horizontalScrollBar()
         vbar = self.scroll.verticalScrollBar()
+
+        # NEW: capture the *current view title* the user sees
+        view_title = self._current_view_display_name()
+
         state = {
             "doc_ptr": id(self.document),
+            "doc_uid": getattr(self.document, "uid", None),   # harmless even if None
+            "file_path": (getattr(self.document, "metadata", {}) or {}).get("file_path", ""),
             "scale": float(self.scale),
             "hval": int(hbar.value()),
             "vval": int(vbar.value()),
             "autostretch": bool(self.autostretch_enabled),
             "autostretch_target": float(self.autostretch_target),
+
+            # NEW: this is what we will use for naming duplicates
+            "source_view_title": view_title,
         }
         state.update(self._drag_identity_fields())
-
+        if _DEBUG_DND_DUP:
+            _dnd_dbg_dump_state("DRAG_START:viewtab", state)
         mime = QMimeData()
         mime.setData(MIME_VIEWSTATE, QByteArray(json.dumps(state).encode("utf-8")))
 
@@ -1815,10 +2091,13 @@ class ImageSubWindow(QWidget):
 
         pm = self.label.pixmap()
         if pm:
-            drag.setPixmap(pm.scaled(96, 96,
-                                    Qt.AspectRatioMode.KeepAspectRatio,
-                                    Qt.TransformationMode.SmoothTransformation))
+            drag.setPixmap(pm.scaled(
+                96, 96,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            ))
             drag.setHotSpot(QCursor.pos() - self.mapToGlobal(self._view_tab.pos()))
+
         drag.exec(Qt.DropAction.CopyAction)
 
     def _viewtab_mouse_double(self, _ev):
@@ -1924,6 +2203,42 @@ class ImageSubWindow(QWidget):
 
         ev.ignore()
 
+    def _current_view_display_name(self) -> str:
+        """
+        Best-effort: the exact title the user sees for THIS subwindow/view.
+        Prefer QMdiSubWindow title, fallback to document display_name.
+        """
+        # 1) QMdiSubWindow title (what user sees)
+        try:
+            sw = self._mdi_subwindow()
+            if sw is not None:
+                t = (sw.windowTitle() or "").strip()
+                if t:
+                    return t
+        except Exception:
+            pass
+
+        # 2) This widget's own windowTitle (sometimes used)
+        try:
+            t = (self.windowTitle() or "").strip()
+            if t:
+                return t
+        except Exception:
+            pass
+
+        # 3) Document display name fallback
+        try:
+            d = getattr(self, "document", None)
+            if d is not None and hasattr(d, "display_name"):
+                t = (d.display_name() or "").strip()
+                if t:
+                    return t
+        except Exception:
+            pass
+
+        return "Untitled"
+
+
     # keep the tab visible if the widget resizes
     def resizeEvent(self, ev):
         super().resizeEvent(ev)
@@ -2075,9 +2390,16 @@ class ImageSubWindow(QWidget):
 
     # ---------- rendering ----------
     def _render(self, rebuild: bool = False):
+        #print("[ImageSubWindow] _render called, rebuild =", rebuild)
         """
         Render the current view.
 
+        Fast path:
+        - rebuild=False: only rescale already-built pixmap/QImage (NO numpy work).
+        Slow path:
+        - rebuild=True: rebuild visualization (autostretch, 8-bit conversion, overlays),
+                        refresh QImage/QPixmap cache, then present.
+
         Rules:
         - If a Preview is active, FIRST sync that preview's stored arr from the
         DocManager's ROI document (the thing tools actually modify), then render.
@@ -2087,46 +2409,53 @@ class ImageSubWindow(QWidget):
         # ---- GUARD: widget/label may be deleted but document.changed still fires ----
         try:
             from PyQt6 import sip as _sip
-            # If the whole widget or its label is gone, bail immediately
             if _sip.isdeleted(self):
                 return
             lbl = getattr(self, "label", None)
             if lbl is None or _sip.isdeleted(lbl):
                 return
         except Exception:
-            # If sip or label is missing for any reason, play it safe
             if not hasattr(self, "label"):
                 return
-        # ---------------------------------------------------------------------------        
+        # ---------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------
+        # FAST PATH: if we're not rebuilding content and we already have a source pixmap,
+        # just present scaled (fast). This is the key to smooth zoom.
+        # ---------------------------------------------------------------------------
+        if (not rebuild) and getattr(self, "_pm_src", None) is not None:
+            self._present_scaled(interactive=True)
+            return
+
         # ---------------------------
         # 1) Choose & sync source arr
         # ---------------------------
         base_img = None
         if self._active_source_kind == "preview" and self._active_preview_id is not None:
             src = next((p for p in self._previews if p["id"] == self._active_preview_id), None)
-            #print("[ImageSubWindow] _render: preview mode, id =", self._active_preview_id, "src =", src is not None)
             if src is not None:
                 # Pull the *edited* ROI image from DocManager, if available
                 if hasattr(self, "_docman") and self._docman is not None:
-                    #print("[ImageSubWindow] _render: pulling edited ROI from DocManager")
                     try:
                         roi_doc = self._docman.get_document_for_view(self)
                         roi_img = getattr(roi_doc, "image", None)
+                        # IMPORTANT: only copy on rebuild; zoom should not trigger a copy
                         if roi_img is not None:
-                            # Replace the preview’s static copy with the edited ROI buffer
-                            src["arr"] = np.asarray(roi_img).copy()
+                            if rebuild or ("arr" not in src) or (src.get("arr") is None):
+                                src["arr"] = np.asarray(roi_img).copy()
                     except Exception:
                         print("[ImageSubWindow] _render: failed to pull edited ROI from DocManager")
-                        pass
                 base_img = src.get("arr", None)
         else:
-            #print("[ImageSubWindow] _render: full image mode")
             base_img = self._display_override if (self._display_override is not None) else (
                 getattr(self.document, "image", None)
             )
 
         if base_img is None:
             self._qimg_src = None
+            self._pm_src = None
+            self._pm_src_wcs = None
+            self._buf8 = None
             self.label.clear()
             return
 
@@ -2135,7 +2464,6 @@ class ImageSubWindow(QWidget):
         # ---------------------------------------
         # 2) Normalize dimensionality and dtype
         # ---------------------------------------
-        # Scalar → 1x1; 1D → 1xN; (H,W,1) → mono (H,W)
         if arr.ndim == 0:
             arr = arr.reshape(1, 1)
         elif arr.ndim == 1:
@@ -2156,7 +2484,7 @@ class ImageSubWindow(QWidget):
             else:
                 arr_f = arr.astype(np.float32, copy=False)
                 mx = float(arr_f.max()) if arr_f.size else 1.0
-                if mx > 5.0:  # compress absurdly large ranges
+                if mx > 5.0:
                     arr_f = arr_f / mx
 
             vis = autostretch(
@@ -2192,7 +2520,7 @@ class ImageSubWindow(QWidget):
             buf8 = np.stack([buf8.squeeze()] * 3, axis=-1)
 
         # ---------------------------------------
-        # 5) Optional mask overlay
+        # 5) Optional mask overlay (baked into buf8)
         # ---------------------------------------
         if getattr(self, "show_mask_overlay", False):
             m = self._active_mask_array()
@@ -2215,9 +2543,9 @@ class ImageSubWindow(QWidget):
         # ---------------------------------------
         if buf8.dtype != np.uint8:
             buf8 = buf8.astype(np.uint8)
+
         buf8 = ensure_contiguous(buf8)
         h, w, c = buf8.shape
-        # Be explicit. RGB888 means 3 bytes per pixel, full stop.
         bytes_per_line = int(w * 3)
 
         self._buf8 = buf8  # keep alive
@@ -2226,11 +2554,9 @@ class ImageSubWindow(QWidget):
             addr = int(self._buf8.ctypes.data)
             ptr  = sip.voidptr(addr)
             qimg = QImage(ptr, w, h, bytes_per_line, QImage.Format.Format_RGB888)
-            # Defensive: if Qt ever decides the buffer looks wrong, force-copy once
             if qimg is None or qimg.isNull():
                 raise RuntimeError("QImage null")
         except Exception:
-            # One safe fall-back copy (still fast, avoids crashes)
             buf8c = np.array(self._buf8, copy=True, order="C")
             self._buf8 = buf8c
             addr = int(self._buf8.ctypes.data)
@@ -2239,244 +2565,263 @@ class ImageSubWindow(QWidget):
 
         self._qimg_src = qimg
         if qimg is None or qimg.isNull():
+            self._pm_src = None
+            self._pm_src_wcs = None
             self.label.clear()
             return
 
-        # ---------------------------------------
-        # 7) Scale & present
-        # ---------------------------------------
-        sw = max(1, int(qimg.width() * self.scale))
-        sh = max(1, int(qimg.height() * self.scale))
-        scaled = qimg.scaled(
-            sw, sh,
-            Qt.AspectRatioMode.KeepAspectRatio,
-            Qt.TransformationMode.SmoothTransformation
-        )
+        # Cache unscaled pixmap ONCE per rebuild
+        self._pm_src = QPixmap.fromImage(self._qimg_src)
 
-        # ── NEW: WCS grid overlay (draw on the scaled pixmap so lines stay 1px) ──
-        if getattr(self, "_show_wcs_grid", False):
-            wcs2 = self._get_celestial_wcs()
-            if wcs2 is not None:
-                from PyQt6.QtGui import QPainter, QPen, QColor, QFont, QBrush
-                from PyQt6.QtCore import QSettings
-                from astropy.wcs.utils import proj_plane_pixel_scales
-                import numpy as _np
-
-                pm = QPixmap.fromImage(scaled)
-
-                # Read user prefs (fallback to defaults if not set)
-                _settings = getattr(self, "_settings", None) or QSettings()
-                pref_enabled   = _settings.value("wcs_grid/enabled", True, type=bool)
-                pref_mode      = _settings.value("wcs_grid/mode", "auto", type=str)      # "auto" | "fixed"
-                pref_step_unit = _settings.value("wcs_grid/step_unit", "deg", type=str)  # "deg" | "arcmin"
-                pref_step_val  = _settings.value("wcs_grid/step_value", 1.0, type=float)
-
-                if not pref_enabled:
-                    # User disabled the grid in Preferences — skip overlay
-                    self.label.setPixmap(QPixmap.fromImage(scaled))
-                    self.label.resize(scaled.size())
-                    return
+        # Invalidate any cached “WCS baked” pixmap on rebuild
+        self._pm_src_wcs = None
 
-                display_h, display_w = base_img.shape[:2]
+        # Present final-quality after rebuild
+        self._present_scaled(interactive=False)
 
-                # Pixel scales and FOV using celestial WCS
-                px_scales_deg = proj_plane_pixel_scales(wcs2)  # deg/pix for the two celestial axes
-                px_deg = float(max(px_scales_deg[0], px_scales_deg[1]))
+        rebuild = False  # done
 
-                H_full, W_full = display_h, display_w
-                fov_deg = px_deg * float(max(W_full, H_full))
 
-                # Choose grid spacing from prefs (or auto heuristic)
-                if pref_mode == "fixed":
-                    step_deg = float(pref_step_val if pref_step_unit == "deg" else (pref_step_val / 60.0))
-                    step_deg = max(1e-6, min(step_deg, 90.0))  # clamp to sane range
-                else:
-                    # Auto spacing (your previous logic)
-                    nice = [0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 15, 30]
-                    target_lines = 8
-                    desired = max(fov_deg / target_lines, px_deg * 100)
-                    step_deg = min((n for n in nice if n >= desired), default=30)
-
-                # World rect from image corners using celestial WCS
-                corners = _np.array([[0, 0], [W_full-1, 0], [0, H_full-1], [W_full-1, H_full-1]], dtype=float)
-                try:
-                    ra_c, dec_c = wcs2.pixel_to_world_values(corners[:,0], corners[:,1])
-                    ra_min = float(_np.nanmin(ra_c));  ra_max = float(_np.nanmax(ra_c))
-                    dec_min = float(_np.nanmin(dec_c)); dec_max = float(_np.nanmax(dec_c))
-                    if ra_max - ra_min > 300:
-                        ra_c_wrapped = _np.mod(ra_c + 180.0, 360.0)
-                        ra_min = float(_np.nanmin(ra_c_wrapped)); ra_max = float(_np.nanmax(ra_c_wrapped))
-                        ra_shift = 180.0
-                    else:
-                        ra_shift = 0.0
-                except Exception:
-                    ra_min, ra_max, dec_min, dec_max, ra_shift = 0.0, 360.0, -90.0, 90.0, 0.0
-
-                p = QPainter(pm)
-                pen = QPen(); pen.setWidth(1); pen.setColor(QColor(255, 255, 255, 140))
-                p.setPen(pen)
-                s = float(self.scale)
-                img_w = int(W_full * s)
-                img_h = int(H_full * s)
-                Wf, Hf = float(W_full), float(H_full)
-                margin = float(max(Wf, Hf) * 2.0)  # 2x image size margin                
-                def draw_world_poly(xs_world, ys_world):
-                    try:
-                        px, py = wcs2.world_to_pixel_values(xs_world, ys_world)
-                    except Exception:
-                        return
-
-                    px = _np.asarray(px, dtype=float)
-                    py = _np.asarray(py, dtype=float)
-
-                    # --- validity mask ---
-                    ok = _np.isfinite(px) & _np.isfinite(py)
-
-                    # Allow a margin around the image so near-edge lines still draw
-                    margin = float(max(Wf, Hf) * 2.0)  # 2x image size margin
-                    ok &= (px > -margin) & (px < (Wf - 1.0 + margin))
-                    ok &= (py > -margin) & (py < (Hf - 1.0 + margin))
-
-                    for i in range(1, len(px)):
-                        if not (ok[i-1] and ok[i]):
-                            continue
-
-                        x0 = float(px[i-1]) * s
-                        y0 = float(py[i-1]) * s
-                        x1 = float(px[i])   * s
-                        y1 = float(py[i])   * s
-
-                        # Final sanity gate before int() -> Qt 32-bit
-                        if max(abs(x0), abs(y0), abs(x1), abs(y1)) > 2.0e9:
-                            continue
-
-                        p.drawLine(int(x0), int(y0), int(x1), int(y1))
-
-
-                ra_samples = _np.linspace(ra_min, ra_max, 512, dtype=float)
-                ra_samples_wrapped = _np.mod(ra_samples + ra_shift, 360.0) if ra_shift else ra_samples
-                dec_samples = _np.linspace(dec_min, dec_max, 512, dtype=float)
-
-                # DEC lines (horiz-ish)
-                def _frange(a,b,s):
-                    out=[]; x=a
-                    while x <= b + 1e-9:
-                        out.append(x); x += s
-                    return out
-                def _round_to(x,s): return s * round(x/s)
-
-                ra_start  = _round_to(ra_min, step_deg)
-                dec_start = _round_to(dec_min, step_deg)
-                for dec in _frange(dec_start, dec_max, step_deg):
-                    dec_arr = _np.full_like(ra_samples_wrapped, dec)
-                    draw_world_poly(ra_samples_wrapped, dec_arr)
-
-                # RA lines (vert-ish)
-                for ra in _frange(ra_start, ra_max, step_deg):
-                    ra_arr = _np.full_like(dec_samples, (ra + ra_shift) % 360.0)
-                    draw_world_poly(ra_arr, dec_samples)
-
-                # ── LABELS for RA/Dec lines ─────────────────────────────────
-                # Font & box style
-                font = QFont(); font.setPixelSize(11)  # screen-consistent
-                p.setFont(font)
-                text_pen  = QPen(QColor(255, 255, 255, 230))
-                box_brush = QBrush(QColor(0, 0, 0, 140))
-                p.setPen(text_pen)
-
-                def _draw_label(x, y, txt, anchor="lt"):
-                    if not _np.isfinite([x, y]).all():
-                        return
-                    fm = p.fontMetrics()
-                    wtxt = fm.horizontalAdvance(txt) + 6
-                    htxt = fm.height() + 4
-
-                    # initial placement with a little padding
-                    if anchor == "lt":      # left-top
-                        rx, ry = int(x) + 4, int(y) + 3
-                    elif anchor == "rt":    # right-top
-                        rx, ry = int(x) - wtxt - 4, int(y) + 3
-                    elif anchor == "lb":    # left-bottom
-                        rx, ry = int(x) + 4, int(y) - htxt - 3
-                    else:                   # center-top
-                        rx, ry = int(x) - wtxt // 2, int(y) + 3
-
-                    # clamp entirely inside the image
-                    rx = max(0, min(rx, img_w - wtxt - 1))
-                    ry = max(0, min(ry, img_h - htxt - 1))
-
-                    rect = QRect(rx, ry, wtxt, htxt)
-                    p.save()
-                    p.setBrush(box_brush)
-                    p.setPen(Qt.PenStyle.NoPen)
-                    p.drawRoundedRect(rect, 4, 4)
-                    p.restore()
-                    p.drawText(rect.adjusted(3, 2, -3, -2),
-                            Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, txt)
-
-
-                # DEC labels on left edge
-                for dec in _frange(dec_start, dec_max, step_deg):
-                    try:
-                        x_pix, y_pix = wcs2.world_to_pixel_values((ra_min + ra_shift) % 360.0, dec)
-                        if not _np.isfinite([x_pix, y_pix]).all():
-                            continue
-                        # clamp to image bounds before scaling
-                        x_pix = min(max(x_pix, 0.0), Wf - 1.0)
-                        y_pix = min(max(y_pix, 0.0), Hf - 1.0)
-                        _draw_label(x_pix * s, y_pix * s, self._deg_to_dms(dec), anchor="lt")
-                    except Exception:
-                        pass
+    def _present_scaled(self, interactive: bool):
+        """
+        Present the cached source pixmap scaled to current self.scale.
+
+        interactive=True:
+        - Fast scaling
+        - No WCS draw
+        interactive=False:
+        - Smooth scaling
+        - Optionally draw WCS overlay once
+        """
+        if getattr(self, "_pm_src", None) is None:
+            return
 
-                # RA labels on top edge
-                for ra in _frange(ra_start, ra_max, step_deg):
-                    ra_wrapped = (ra + ra_shift) % 360.0
-                    try:
-                        x_pix, y_pix = wcs2.world_to_pixel_values(ra_wrapped, dec_min)
-                        if not _np.isfinite([x_pix, y_pix]).all():
-                            continue
-                        x_pix = min(max(x_pix, 0.0), Wf - 1.0)
-                        y_pix = min(max(y_pix, 0.0), Hf - 1.0)
-                        _draw_label(x_pix * s, y_pix * s, self._deg_to_hms(ra_wrapped), anchor="ct")
-                    except Exception:
-                        pass
+        pm_base = self._pm_src
 
-                p.end()
-                scaled = pm.toImage()
+        sw = max(1, int(pm_base.width() * self.scale))
+        sh = max(1, int(pm_base.height() * self.scale))
 
-        # ── end WCS grid overlay ────────────────────────────────────────────────
+        mode = Qt.TransformationMode.FastTransformation if interactive else Qt.TransformationMode.SmoothTransformation
+        pm_scaled = pm_base.scaled(sw, sh, Qt.AspectRatioMode.KeepAspectRatio, mode)
 
-        self.label.setPixmap(QPixmap.fromImage(scaled))
-        self.label.resize(scaled.size())
+        # If interactive, skip WCS overlay entirely (this is the biggest speed win)
+        if interactive:
+            self.label.setPixmap(pm_scaled)
+            self.label.resize(pm_scaled.size())
+            return
 
+        # Non-interactive: (optionally) draw WCS grid.
+        if getattr(self, "_show_wcs_grid", False):
+            # Cache a baked WCS pixmap at *this* scale to avoid re-drawing
+            # if _present_scaled(False) is called multiple times at same scale.
+            cache_key = (sw, sh, float(self.scale))
+            if getattr(self, "_pm_src_wcs_key", None) != cache_key or getattr(self, "_pm_src_wcs", None) is None:
+                pm_scaled = self._draw_wcs_grid_on_pixmap(pm_scaled)
+                self._pm_src_wcs = pm_scaled
+                self._pm_src_wcs_key = cache_key
+            else:
+                pm_scaled = self._pm_src_wcs
 
+        self.label.setPixmap(pm_scaled)
+        self.label.resize(pm_scaled.size())
 
-    def has_active_preview(self) -> bool:
-        return self._active_source_kind == "preview" and self._active_preview_id is not None
 
-    def current_preview_roi(self) -> tuple[int,int,int,int] | None:
+    def _draw_wcs_grid_on_pixmap(self, pm_scaled: QPixmap) -> QPixmap:
         """
-        Returns (x, y, w, h) in FULL image coordinates if a preview tab is active, else None.
+        Your existing WCS painter logic, moved to operate on a QPixmap (already scaled).
+        Runs ONLY on non-interactive redraw.
         """
-        if not self.has_active_preview():
-            return None
-        src = next((p for p in self._previews if p["id"] == self._active_preview_id), None)
-        return None if src is None else tuple(src["roi"])
+        wcs2 = self._get_celestial_wcs()
+        if wcs2 is None:
+            return pm_scaled
+
+        from PyQt6.QtGui import QPainter, QPen, QColor, QFont, QBrush
+        from PyQt6.QtCore import QSettings, QRect
+        from astropy.wcs.utils import proj_plane_pixel_scales
+        import numpy as _np
+
+        _settings = getattr(self, "_settings", None) or QSettings()
+        pref_enabled   = _settings.value("wcs_grid/enabled", True, type=bool)
+        pref_mode      = _settings.value("wcs_grid/mode", "auto", type=str)
+        pref_step_unit = _settings.value("wcs_grid/step_unit", "deg", type=str)
+        pref_step_val  = _settings.value("wcs_grid/step_value", 1.0, type=float)
+
+        if not pref_enabled:
+            return pm_scaled
+
+        # Determine full image geometry from the CURRENT SOURCE buffer (not pm_scaled)
+        # We can infer W/H from qimg src (original)
+        if getattr(self, "_qimg_src", None) is None:
+            return pm_scaled
+        H_full = int(self._qimg_src.height())
+        W_full = int(self._qimg_src.width())
+
+        # Pixel scales/FOV
+        px_scales_deg = proj_plane_pixel_scales(wcs2)
+        px_deg = float(max(px_scales_deg[0], px_scales_deg[1]))
+        fov_deg = px_deg * float(max(W_full, H_full))
+
+        if pref_mode == "fixed":
+            step_deg = float(pref_step_val if pref_step_unit == "deg" else (pref_step_val / 60.0))
+            step_deg = max(1e-6, min(step_deg, 90.0))
+        else:
+            nice = [0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 15, 30]
+            target_lines = 8
+            desired = max(fov_deg / target_lines, px_deg * 100)
+            step_deg = min((n for n in nice if n >= desired), default=30)
 
-    def current_preview_name(self) -> str | None:
-        if not self.has_active_preview():
-            return None
-        src = next((p for p in self._previews if p["id"] == self._active_preview_id), None)
-        return None if src is None else src["name"]
+        # World bounds from corners
+        corners = _np.array([[0, 0], [W_full-1, 0], [0, H_full-1], [W_full-1, H_full-1]], dtype=float)
+        try:
+            ra_c, dec_c = wcs2.pixel_to_world_values(corners[:,0], corners[:,1])
+            ra_min = float(_np.nanmin(ra_c));  ra_max = float(_np.nanmax(ra_c))
+            dec_min = float(_np.nanmin(dec_c)); dec_max = float(_np.nanmax(dec_c))
+            if ra_max - ra_min > 300:
+                ra_c_wrapped = _np.mod(ra_c + 180.0, 360.0)
+                ra_min = float(_np.nanmin(ra_c_wrapped)); ra_max = float(_np.nanmax(ra_c_wrapped))
+                ra_shift = 180.0
+            else:
+                ra_shift = 0.0
+        except Exception:
+            ra_min, ra_max, dec_min, dec_max, ra_shift = 0.0, 360.0, -90.0, 90.0, 0.0
+
+        pm = QPixmap(pm_scaled)  # copy so we don’t mutate caller
+        p = QPainter(pm)
+        pen = QPen(QColor(255, 255, 255, 140))
+        pen.setWidth(1)
+        p.setPen(pen)
+
+        # Scale factor between full-res image and pm_scaled
+        s = float(pm.width()) / float(max(1, W_full))
+
+        Wf, Hf = float(W_full), float(H_full)
+
+        def draw_world_poly(xs_world, ys_world):
+            try:
+                px, py = wcs2.world_to_pixel_values(xs_world, ys_world)
+            except Exception:
+                return
+
+            px = _np.asarray(px, dtype=float)
+            py = _np.asarray(py, dtype=float)
+
+            ok = _np.isfinite(px) & _np.isfinite(py)
+            margin = float(max(Wf, Hf) * 2.0)
+            ok &= (px > -margin) & (px < (Wf - 1.0 + margin))
+            ok &= (py > -margin) & (py < (Hf - 1.0 + margin))
+
+            for i in range(1, len(px)):
+                if not (ok[i-1] and ok[i]):
+                    continue
+                x0 = float(px[i-1]) * s
+                y0 = float(py[i-1]) * s
+                x1 = float(px[i])   * s
+                y1 = float(py[i])   * s
+                if max(abs(x0), abs(y0), abs(x1), abs(y1)) > 2.0e9:
+                    continue
+                p.drawLine(int(x0), int(y0), int(x1), int(y1))
+
+        ra_samples = _np.linspace(ra_min, ra_max, 512, dtype=float)
+        ra_samples_wrapped = _np.mod(ra_samples + ra_shift, 360.0) if ra_shift else ra_samples
+        dec_samples = _np.linspace(dec_min, dec_max, 512, dtype=float)
+
+        def _frange(a, b, sstep):
+            out = []
+            x = a
+            while x <= b + 1e-9:
+                out.append(x)
+                x += sstep
+            return out
+
+        def _round_to(x, sstep):
+            return sstep * round(x / sstep)
+
+        ra_start  = _round_to(ra_min, step_deg)
+        dec_start = _round_to(dec_min, step_deg)
+
+        for dec in _frange(dec_start, dec_max, step_deg):
+            dec_arr = _np.full_like(ra_samples_wrapped, dec)
+            draw_world_poly(ra_samples_wrapped, dec_arr)
+
+        for ra in _frange(ra_start, ra_max, step_deg):
+            ra_arr = _np.full_like(dec_samples, (ra + ra_shift) % 360.0)
+            draw_world_poly(ra_arr, dec_samples)
+
+        # Labels
+        font = QFont()
+        font.setPixelSize(11)
+        p.setFont(font)
+        text_pen  = QPen(QColor(255, 255, 255, 230))
+        box_brush = QBrush(QColor(0, 0, 0, 140))
+        p.setPen(text_pen)
+
+        img_w = pm.width()
+        img_h = pm.height()
+
+        def _draw_label(x, y, txt, anchor="lt"):
+            if not _np.isfinite([x, y]).all():
+                return
+            fm = p.fontMetrics()
+            wtxt = fm.horizontalAdvance(txt) + 6
+            htxt = fm.height() + 4
+
+            if anchor == "lt":
+                rx, ry = int(x) + 4, int(y) + 3
+            elif anchor == "rt":
+                rx, ry = int(x) - wtxt - 4, int(y) + 3
+            elif anchor == "lb":
+                rx, ry = int(x) + 4, int(y) - htxt - 3
+            else:
+                rx, ry = int(x) - wtxt // 2, int(y) + 3
+
+            rx = max(0, min(rx, img_w - wtxt - 1))
+            ry = max(0, min(ry, img_h - htxt - 1))
+
+            rect = QRect(rx, ry, wtxt, htxt)
+            p.save()
+            p.setBrush(box_brush)
+            p.setPen(Qt.PenStyle.NoPen)
+            p.drawRoundedRect(rect, 4, 4)
+            p.restore()
+            p.drawText(rect.adjusted(3, 2, -3, -2),
+                    Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, txt)
+
+        # DEC labels on left edge
+        for dec in _frange(dec_start, dec_max, step_deg):
+            try:
+                x_pix, y_pix = wcs2.world_to_pixel_values((ra_min + ra_shift) % 360.0, dec)
+                if not _np.isfinite([x_pix, y_pix]).all():
+                    continue
+                x_pix = min(max(x_pix, 0.0), Wf - 1.0)
+                y_pix = min(max(y_pix, 0.0), Hf - 1.0)
+                _draw_label(x_pix * s, y_pix * s, self._deg_to_dms(dec), anchor="lt")
+            except Exception:
+                pass
+
+        # RA labels on top edge
+        for ra in _frange(ra_start, ra_max, step_deg):
+            ra_wrapped = (ra + ra_shift) % 360.0
+            try:
+                x_pix, y_pix = wcs2.world_to_pixel_values(ra_wrapped, dec_min)
+                if not _np.isfinite([x_pix, y_pix]).all():
+                    continue
+                x_pix = min(max(x_pix, 0.0), Wf - 1.0)
+                y_pix = min(max(y_pix, 0.0), Hf - 1.0)
+                _draw_label(x_pix * s, y_pix * s, self._deg_to_hms(ra_wrapped), anchor="ct")
+            except Exception:
+                pass
+
+        p.end()
+        return pm
 
 
     # ---------- interaction ----------
     def _zoom_at_anchor(self, factor: float):
-        if self._qimg_src is None:
+        if getattr(self, "_qimg_src", None) is None and getattr(self, "_pm_src", None) is None:
             return
-        old_scale = self.scale
-        # clamp with new max
-        new_scale = max(self._min_scale, min(old_scale * factor, self._max_scale))
+
+        old_scale = float(self.scale)
+        new_scale = max(self._min_scale, min(old_scale * float(factor), self._max_scale))
         if abs(new_scale - old_scale) < 1e-8:
             return
 
@@ -2484,7 +2829,6 @@ class ImageSubWindow(QWidget):
         hbar = self.scroll.horizontalScrollBar()
         vbar = self.scroll.verticalScrollBar()
 
-        # Anchor in viewport coordinates via global cursor (robust)
         try:
             anchor_vp = vp.mapFromGlobal(QCursor.pos())
         except Exception:
@@ -2493,34 +2837,77 @@ class ImageSubWindow(QWidget):
         if (anchor_vp is None) or (not vp.rect().contains(anchor_vp)):
             anchor_vp = QPoint(vp.width() // 2, vp.height() // 2)
 
-        # Current label coords under the anchor
         x_label_pre = hbar.value() + anchor_vp.x()
         y_label_pre = vbar.value() + anchor_vp.y()
 
-        # Convert to image coords at old scale
         xi = x_label_pre / max(old_scale, 1e-12)
         yi = y_label_pre / max(old_scale, 1e-12)
 
-        # Apply scale and redraw (updates label size + scrollbar ranges)
+        # Apply new scale
         self.scale = new_scale
-        self._render(rebuild=False)
 
-        # Reproject that image point to label coords at new scale
+        # FAST present (no rebuild)
+        self._present_scaled(interactive=True)
+
+        # Keep anchor stable
         x_label_post = xi * new_scale
         y_label_post = yi * new_scale
 
-        # Desired scrollbar values to keep point under the cursor
         new_h = int(round(x_label_post - anchor_vp.x()))
         new_v = int(round(y_label_post - anchor_vp.y()))
 
-        # Clamp to valid range
         new_h = max(hbar.minimum(), min(new_h, hbar.maximum()))
         new_v = max(vbar.minimum(), min(new_v, vbar.maximum()))
 
-        # Apply
         hbar.setValue(new_h)
         vbar.setValue(new_v)
-        self._schedule_emit_view_transform()
+
+        # Defer one final smooth redraw (and WCS overlay) after the burst
+        self._request_zoom_redraw()
+
+
+    def _request_zoom_redraw(self):
+        if getattr(self, "_zoom_timer", None) is None:
+            self._zoom_timer = QTimer(self)
+            self._zoom_timer.setSingleShot(True)
+            self._zoom_timer.timeout.connect(self._apply_zoom_redraw)
+
+        # 60–120ms feels better than 16ms for “zoom burst collapse”
+        # but keep your 16ms if you prefer.
+        self._zoom_timer.start(90)
+
+
+    def _apply_zoom_redraw(self):
+        """
+        Final “settled” redraw:
+        - SmoothTransformation
+        - Optional WCS grid overlay
+        """
+        if getattr(self, "_pm_src", None) is None:
+            return
+        self._present_scaled(interactive=False)
+
+
+
+    def has_active_preview(self) -> bool:
+        return self._active_source_kind == "preview" and self._active_preview_id is not None
+
+    def current_preview_roi(self) -> tuple[int,int,int,int] | None:
+        """
+        Returns (x, y, w, h) in FULL image coordinates if a preview tab is active, else None.
+        """
+        if not self.has_active_preview():
+            return None
+        src = next((p for p in self._previews if p["id"] == self._active_preview_id), None)
+        return None if src is None else tuple(src["roi"])
+
+    def current_preview_name(self) -> str | None:
+        if not self.has_active_preview():
+            return None
+        src = next((p for p in self._previews if p["id"] == self._active_preview_id), None)
+        return None if src is None else src["name"]
+
+
 
     def _find_main_window(self):
         p = self.parent()
@@ -2653,37 +3040,76 @@ class ImageSubWindow(QWidget):
                 return True
             return False
 
+        sw = self._mdi_subwindow()
+        if sw is not None and obj is sw:
+            et = ev.type()
+            if et in (QEvent.Type.WindowStateChange, QEvent.Type.Show, QEvent.Type.Resize):
+                QTimer.singleShot(0, self._update_inline_title_and_buttons)
+
         return super().eventFilter(obj, ev)
 
+    def _viewport_pos_to_image_xy(self, vp_pos: QPoint) -> tuple[int, int] | None:
+        """
+        Convert a point in viewport coordinates to FULL image pixel coordinates.
+        Returns None if the point is outside the displayed pixmap (in margins).
+        """
+        pm = self.label.pixmap()
+        if pm is None:
+            return None
+
+        # Convert viewport point into label coordinates
+        p_label = self.label.mapFrom(self.scroll.viewport(), vp_pos)
+
+        # If label is larger than pixmap, pixmap may be centered inside label.
+        pm_w, pm_h = pm.width(), pm.height()
+        lbl_w, lbl_h = self.label.width(), self.label.height()
+
+        off_x = max(0, (lbl_w - pm_w) // 2)
+        off_y = max(0, (lbl_h - pm_h) // 2)
+
+        px = p_label.x() - off_x
+        py = p_label.y() - off_y
+
+        # Outside the drawn pixmap area → clamp
+        px = max(0, min(px, pm_w - 1))
+        py = max(0, min(py, pm_h - 1))
+
+        s = max(float(self.scale), 1e-12)
+
+        # pixmap pixels -> image pixels (pm = image * scale)
+        xi = int(round(px / s))
+        yi = int(round(py / s))
+        return xi, yi
+
 
     def _finish_preview_rect(self, vp_rect: QRect):
-        # Map viewport rectangle into image coordinates
         if vp_rect.width() < 4 or vp_rect.height() < 4:
             self._cancel_rubber()
             return
 
-        hbar = self.scroll.horizontalScrollBar()
-        vbar = self.scroll.verticalScrollBar()
+        # Convert the two corners from viewport space to image space
+        p0 = self._viewport_pos_to_image_xy(vp_rect.topLeft())
+        p1 = self._viewport_pos_to_image_xy(vp_rect.bottomRight())
 
-        # Upper-left in label coords
-        x_label0 = hbar.value() + vp_rect.left()
-        y_label0 = vbar.value() + vp_rect.top()
-        x_label1 = hbar.value() + vp_rect.right()
-        y_label1 = vbar.value() + vp_rect.bottom()
+        if p0 is None or p1 is None:
+            # User dragged into margins; you can either cancel or clamp.
+            # Cancel is simplest:
+            self._cancel_rubber()
+            return
 
-        s = max(self.scale, 1e-12)
+        x0, y0 = p0
+        x1, y1 = p1
 
-        x0 = int(round(x_label0 / s))
-        y0 = int(round(y_label0 / s))
-        x1 = int(round(x_label1 / s))
-        y1 = int(round(y_label1 / s))
+        x = min(x0, x1)
+        y = min(y0, y1)
+        w = abs(x1 - x0)
+        h = abs(y1 - y0)
 
-        if x1 <= x0 or y1 <= y0:
+        if w < 1 or h < 1:
             self._cancel_rubber()
             return
 
-        roi = (x0, y0, x1 - x0, y1 - y0)
-        self._create_preview_from_roi(roi)
+        self._create_preview_from_roi((x, y, w, h))
         self._cancel_rubber()
 
     def _create_preview_from_roi(self, roi: tuple[int,int,int,int]):