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

setiastro/saspro/gui/main_window.py

@@ -129,7 +129,7 @@ from PyQt6.QtGui import (QPixmap, QColor, QIcon, QKeySequence, QShortcut,
 
 # ----- QtCore -----
 from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker,  QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject,
-    QPropertyAnimation, QEasingCurve, QElapsedTimer
+    QPropertyAnimation, QEasingCurve, QElapsedTimer, QPoint
 )
 
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -193,9 +193,9 @@ from setiastro.saspro.resources import (
     nbtorgb_path, freqsep_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wrench_path, eye_icon_path,multiscale_decomp_path,
     disk_icon_path, nuke_path, hubble_path, collage_path, annotated_path,
-    colorwheel_path, font_path, csv_icon_path, spinner_path, wims_path,
+    colorwheel_path, font_path, csv_icon_path, spinner_path, wims_path, narrowbandnormalization_path,
     wimi_path, linearfit_path, debayer_path, aberration_path, acv_icon_path,
-    functionbundles_path, viewbundles_path, selectivecolor_path, rgbalign_path,
+    functionbundles_path, viewbundles_path, selectivecolor_path, rgbalign_path, planetarystacker_path,
     background_path, script_icon_path
 )
 
@@ -604,7 +604,10 @@ class AstroSuiteProMainWindow(
         self.docman.documentAdded.connect(self._on_document_added)
         self.mdi.viewStateDropped.connect(self._on_mdi_viewstate_drop)
         self.mdi.linkViewDropped.connect(self._on_linkview_drop)
-
+        self._mdi_open_batch = 0
+        self._mdi_place_mode = "cascade"   # or "tile"
+        self._mdi_next_pos = None          # QPoint in MDI coords
+        self._mdi_cascade_step = 28
         self.doc_manager.set_mdi_area(self.mdi)
         # Coalesce undo/redo label refreshes
         self._undo_redo_refresh_pending = False
@@ -2660,10 +2663,27 @@ class AstroSuiteProMainWindow(
         return f"{name}{dims}"
 
     def _update_explorer_item_for_doc(self, doc):
-        for i in range(self.explorer.count()):
-            it = self.explorer.item(i)
-            if it.data(Qt.ItemDataRole.UserRole) is doc:
-                it.setText(self._format_explorer_title(doc))
+        # Delegate to DockMixin implementation if present
+        try:
+            return super()._update_explorer_item_for_doc(doc)
+        except Exception:
+            pass
+
+        # Fallback: tree-safe implementation
+        if not hasattr(self, "explorer") or self.explorer is None:
+            return
+        try:
+            n = self.explorer.topLevelItemCount()
+        except Exception:
+            return
+
+        for i in range(n):
+            it = self.explorer.topLevelItem(i)
+            if it.data(0, Qt.ItemDataRole.UserRole) is doc:
+                try:
+                    self._refresh_explorer_row(it, doc)
+                except Exception:
+                    pass
                 return
     #-----------FUNCTIONS----------------
 
@@ -3888,6 +3908,19 @@ class AstroSuiteProMainWindow(
 
         dlg.show()
 
+    def _open_narrowband_normalization_tool(self):
+        # Correct module import
+        from setiastro.saspro.narrowband_normalization import NarrowbandNormalization
+
+        w = NarrowbandNormalization(doc_manager=self.docman, parent=self)
+        w.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        w.setWindowTitle("Narrowband Normalization")
+        try:
+            w.setWindowIcon(QIcon(narrowbandnormalization_path))
+        except Exception:
+            pass
+        w.show()
+
     def _open_ppp_tool(self):
         from setiastro.saspro.perfect_palette_picker import PerfectPalettePicker
         w = PerfectPalettePicker(doc_manager=self.docman)  # parent gives access to _spawn_subwindow_for
@@ -4239,6 +4272,14 @@ class AstroSuiteProMainWindow(
         dlg.setWindowIcon(QIcon(livestacking_path))
         dlg.show()
 
+    def _open_planetary_stacker(self):
+        # import locally to avoid startup cost / circular imports
+        from setiastro.saspro.serviewer import SERViewer
+        dlg = SERViewer(self)
+        dlg.setWindowFlag(Qt.WindowType.Window, True)
+        dlg.setWindowIcon(QIcon(planetarystacker_path))        
+        dlg.show()
+
     def _open_stacking_suite(self):
         # Reuse if we already have one
         dlg = getattr(self, "_stacking_suite", None)
@@ -4282,6 +4323,115 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
+    def _convert_mono_to_rgb_active(self):
+        """
+        Convert active mono document to RGB by duplicating the channel.
+        Updates the active document in-place (undoable).
+        """
+        dm = getattr(self, "docman", None)
+        if dm is None:
+            return
+
+        try:
+            doc = dm.get_active_document()
+        except Exception:
+            doc = None
+        if doc is None:
+            return
+
+        img = getattr(doc, "image", None)
+        if img is None:
+            return
+
+        import numpy as np
+
+        x = np.asarray(img)
+
+        # Already RGB?
+        if x.ndim == 3 and x.shape[-1] == 3:
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+            if hasattr(self, "_log"):
+                self._log(f"Mono → RGB: '{name}' is already RGB (shape={getattr(x,'shape',None)}).")
+            return
+
+        # Determine what we're converting FROM
+        src_desc = "unknown"
+        if x.ndim == 2:
+            mono = x
+            src_desc = "mono (H×W)"
+        elif x.ndim == 3 and x.shape[-1] == 1:
+            mono = x[..., 0]
+            src_desc = "mono (H×W×1)"
+        else:
+            # Unknown format (e.g., multi-channel >3)
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+            if hasattr(self, "_log"):
+                self._log(f"Mono → RGB: '{name}' not convertible (shape={getattr(x,'shape',None)}).")
+            return
+
+        before_shape = getattr(x, "shape", None)
+        before_dtype = getattr(x, "dtype", None)
+
+        mono = mono.astype(np.float32, copy=False)
+        rgb = np.stack([mono, mono, mono], axis=-1)
+
+        # metadata: preserve existing, but force "not mono"
+        try:
+            md = dict(getattr(doc, "metadata", None) or {})
+        except Exception:
+            md = {}
+
+        md["is_mono"] = False
+        md["color_model"] = "RGB"
+        md["channels"] = 3
+        md["source"] = (md.get("source") or "Edit")
+
+        # If you track op params for history explorer
+        md["__op_params__"] = {
+            "op": "mono_to_rgb",
+            "mode": "triplicate",
+            "from": str(src_desc),
+            "from_shape": tuple(before_shape) if before_shape is not None else None,
+            "to_shape": tuple(rgb.shape),
+        }
+
+        # name for logging
+        try:
+            name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+        except Exception:
+            name = "Active"
+
+        try:
+            dm.update_active_document(
+                rgb,
+                metadata=md,
+                step_name="Mono → RGB",
+                doc=doc,  # explicit is safer
+            )
+
+            if hasattr(self, "_log"):
+                self._log(
+                    f"Mono → RGB: '{name}' converted {src_desc} "
+                    f"(shape={before_shape}, dtype={before_dtype}) → "
+                    f"RGB (shape={rgb.shape}, dtype={rgb.dtype})."
+                )
+
+        except Exception:
+            import traceback
+            try:
+                from PyQt6.QtWidgets import QMessageBox
+                QMessageBox.critical(self, "Mono → RGB", traceback.format_exc())
+            except Exception:
+                pass
+
+
+
     def _on_stackingsuite_relaunch(self, old_dir: str, new_dir: str):
         # Optional: respond to dialog's relaunch request
         try:
@@ -7871,6 +8021,43 @@ class AstroSuiteProMainWindow(
 
         return t
 
+    def _mdi_begin_open_batch(self, mode: str = "cascade"):
+        self._mdi_open_batch += 1
+        self._mdi_place_mode = mode or "cascade"
+        self._mdi_next_pos = None
+
+    def _mdi_end_open_batch(self):
+        self._mdi_open_batch = max(0, self._mdi_open_batch - 1)
+        if self._mdi_open_batch == 0:
+            self._mdi_next_pos = None
+
+    def _mdi_compute_initial_pos(self) -> QPoint:
+        area = (self.mdi.viewport().geometry() if self.mdi.viewport() else self.mdi.contentsRect())
+        # Put first window a bit inset so titlebars don’t clip
+        return QPoint(area.left() + 18, area.top() + 18)
+
+    def _mdi_place_subwindow(self, sw, target_w: int, target_h: int):
+        """Deterministic placement. Uses a stable cursor during batch opens."""
+        vp = self.mdi.viewport()
+        area = vp.geometry() if vp else self.mdi.contentsRect()
+
+        if self._mdi_next_pos is None:
+            self._mdi_next_pos = self._mdi_compute_initial_pos()
+
+        x = self._mdi_next_pos.x()
+        y = self._mdi_next_pos.y()
+
+        # keep inside viewport; reset when we hit edge
+        if (x + target_w > area.right() - 10) or (y + 40 > area.bottom() - 10):
+            x = area.left() + 18
+            y = area.top() + 18
+
+        sw.move(x, y)
+
+        # advance cursor
+        step = int(self._mdi_cascade_step)
+        self._mdi_next_pos = QPoint(x + step, y + step)
+
     def _spawn_subwindow_for(self, doc, *, force_new: bool = False):
         """
         Open a subwindow for `doc`. If one already exists and force_new=False,
@@ -8044,52 +8231,22 @@ class AstroSuiteProMainWindow(
         target_h = max(200, target_h)
 
         sw.resize(target_w, target_h)
-        sw.showNormal()  # CRITICAL: clears any "maximized" flag from previous active window
+        sw.showNormal()  # clears any "maximized" flag from previous active window
 
-        # -------------------------------------------------------------------------
-        # Smart Cascade: Position relative to the *currently active* window
-        # (before we make the new one active).
-        # -------------------------------------------------------------------------
-        new_x, new_y = area.left(), area.top()
-        
-        # Get dominant/active window *before* we activate the new one
-        active = self.mdi.activeSubWindow()
-        if active and active.isVisible() and not (active.windowState() & Qt.WindowState.WindowMinimized):
-            # Cascade from the active window
-            geo = active.geometry()
-            new_x = geo.x() + 30
-            new_y = geo.y() + 30
-        else:
-            # Fallback: try to find the "last added" visible window to cascade from
-            # (useful if active is None but windows exist)
-            try:
-                subs = [s for s in self.mdi.subWindowList() if s.isVisible() and s is not sw]
-                if subs:
-                    # simplistic "last created" might be at end of list
-                    last = subs[-1]
-                    geo = last.geometry()
-                    new_x = geo.x() + 30
-                    new_y = geo.y() + 30
+        # Deterministic placement (batch-aware)
+        try:
+            self._mdi_place_subwindow(sw, target_w, target_h)
+        except Exception:
+            # absolute fallback: top-left-ish
+            try:
+                sw.move(area.left() + 18, area.top() + 18)
             except Exception:
                 pass
 
-        # 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)
-
-        # ❌ removed the "fill MDI viewport" block - we *don't* want full-monitor first window
-
         # Show / activate
         sw.show()
         sw.raise_()
         self.mdi.setActiveSubWindow(sw)
-        # (no second setWindowTitle() here)
 
         # Optional minimize/restore interceptor
         if hasattr(self, "_minimize_interceptor"):
@@ -8473,26 +8630,21 @@ class AstroSuiteProMainWindow(
 
 
     def _activate_or_open_from_explorer(self, item):
-        doc = item.data(Qt.ItemDataRole.UserRole)
-        base = self._normalize_base_doc(doc)
-
-        # 1) Try to focus an existing view for this base
-        for sw in self.mdi.subWindowList():
-            w = sw.widget()
-            if getattr(w, "base_document", None) is base:
-                try:
-                    sw.show(); w.show()
-                    st = sw.windowState()
-                    if st & Qt.WindowState.WindowMinimized:
-                        sw.setWindowState(st & ~Qt.WindowState.WindowMinimized)
-                    self.mdi.setActiveSubWindow(sw)
-                    sw.raise_()
-                except Exception:
-                    pass
-                return
-
-        # 2) None exists -> open one
-        self._open_subwindow_for_added_doc(base)
+        doc = item.data(0, Qt.ItemDataRole.UserRole)
+        if doc is None:
+            return
+        # you already have logic for this; typically:
+        sw = self._find_subwindow_for_doc(doc)
+        if sw:
+            self.mdi.setActiveSubWindow(sw)
+            sw.show()
+            sw.raise_()
+            return
+        # else open it (if your app supports opening closed docs, otherwise no-op)
+        try:
+            self._open_subwindow_for_added_doc(doc)
+        except Exception:
+            pass
 
     def _set_linked_stretch_from_action(self, checked: bool):
         # persist as the default for *new* views

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)
 
@@ -341,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)