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

setiastro/saspro/gui/mixins/dock_mixin.py

@@ -12,13 +12,43 @@ from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtWidgets import (
     QDockWidget, QPlainTextEdit, QTreeWidget, QTreeWidgetItem,
     QVBoxLayout, QWidget, QTextEdit, QListWidget, QListWidgetItem,
-    QAbstractItemView, QApplication
+    QAbstractItemView, QApplication, QLineEdit, QMenu
 )
-from PyQt6.QtGui import QTextCursor, QAction
+from PyQt6.QtGui import QTextCursor, QAction, QGuiApplication
 
 if TYPE_CHECKING:
     from PyQt6.QtWidgets import QAction
 
+import os
+
+GLYPHS = "■●◆▲▪▫•◼◻◾◽🔗"
+
+def _strip_ui_decorations(text: str) -> str:
+    """
+    Strip UI-only decorations from titles:
+    - Qt mnemonics (&)
+    - link badges like "[LINK]"
+    - your glyph badges
+    - file extension (optional, but nice for Explorer)
+    """
+    if not text:
+        return ""
+    s = str(text)
+
+    # remove mnemonics
+    s = s.replace("&", "")
+
+    # remove common prefixes/badges
+    s = s.replace("[LINK]", "").strip()
+
+    # remove glyph badges
+    s = s.translate({ord(ch): None for ch in GLYPHS})
+
+    # collapse whitespace
+    s = " ".join(s.split())
+
+    return s
+
 
 class DockMixin:
     """
@@ -105,14 +135,44 @@ class DockMixin:
         self._view_panels_menu.removeAction(action)
     
     def _init_explorer_dock(self):
-        self.explorer = QListWidget()
-        # Enter/Return or single-activation: focus if open, else open
+        host = QWidget(self)
+        lay = QVBoxLayout(host)
+        lay.setContentsMargins(4, 4, 4, 4)
+        lay.setSpacing(4)
+
+        # Optional filter box (super useful)
+        self.explorer_filter = QLineEdit(host)
+        self.explorer_filter.setPlaceholderText(self.tr("Filter open documents…"))
+        self.explorer_filter.textChanged.connect(self._explorer_apply_filter)
+        lay.addWidget(self.explorer_filter)
+
+        self.explorer = QTreeWidget(host)
+        self.explorer.setObjectName("ExplorerTree")
+        self.explorer.setColumnCount(3)
+        self.explorer.setHeaderLabels([self.tr("Document"), self.tr("Dims"), self.tr("Type")])
+
+        # Sorting
+        self.explorer.setSortingEnabled(True)
+        self.explorer.header().setSortIndicatorShown(True)
+        self.explorer.sortByColumn(0, Qt.SortOrder.AscendingOrder)
+
+        # Selection/activation behavior
+        self.explorer.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
         self.explorer.itemActivated.connect(self._activate_or_open_from_explorer)
-        # Double-click: same behavior
-        self.explorer.itemDoubleClicked.connect(self._activate_or_open_from_explorer)
+
+        # Inline rename support
+        self.explorer.setEditTriggers(
+            QAbstractItemView.EditTrigger.EditKeyPressed |
+            QAbstractItemView.EditTrigger.SelectedClicked
+        )
+        self.explorer.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.explorer.customContextMenuRequested.connect(self._on_explorer_context_menu)
+        self.explorer.itemChanged.connect(self._on_explorer_item_changed)
+
+        lay.addWidget(self.explorer)
 
         dock = QDockWidget(self.tr("Explorer"), self)
-        dock.setWidget(self.explorer)
+        dock.setWidget(host)
         dock.setObjectName("ExplorerDock")
         self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, dock)
 
@@ -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)

setiastro/saspro/gui/mixins/file_mixin.py

@@ -7,7 +7,7 @@ import os
 from typing import TYPE_CHECKING
 
 from PyQt6.QtCore import Qt
-from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog
+from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog, QApplication
 
 if TYPE_CHECKING:
     pass
@@ -85,7 +85,6 @@ class FileMixin:
         self._save_recent_lists()
         if hasattr(self, "_rebuild_recent_menus"):
             self._rebuild_recent_menus()
-# Extracted FILE methods
 
     def open_files(self):
         # One-stop "All Supported" plus focused groups the user can switch to
@@ -114,21 +113,41 @@ class FileMixin:
         except Exception:
             pass
 
-        # open each path (doc_manager should emit documentAdded; no manual spawn)
-        for p in paths:
-            try:
-                doc = self.docman.open_path(p)   # this emits documentAdded
-                self._log(f"Opened: {p}")
-                self._add_recent_image(p)        # âœ... track in MRU
-                
-                # Increment statistics
+        # ---- BEGIN batch open (stable placement) ----
+        try:
+            self._mdi_begin_open_batch(mode="cascade")
+        except Exception:
+            pass
+
+        QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+        try:
+            # open each path (doc_manager should emit documentAdded; no manual spawn)
+            for p in paths:
                 try:
-                    count = self.settings.value("stats/opened_images_count", 0, type=int)
-                    self.settings.setValue("stats/opened_images_count", count + 1)
-                except Exception:
-                    pass
-            except Exception as e:
-                QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    _ = self.docman.open_path(p)   # emits documentAdded; spawn will happen
+                    self._log(f"Opened: {p}")
+                    self._add_recent_image(p)      # track MRU
+
+                    # Increment statistics
+                    try:
+                        count = self.settings.value("stats/opened_images_count", 0, type=int)
+                        self.settings.setValue("stats/opened_images_count", count + 1)
+                    except Exception:
+                        pass
+
+                    # Let Qt paint newly spawned subwindows as we go
+                    QApplication.processEvents()
+
+                except Exception as e:
+                    QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    QApplication.processEvents()
+        finally:
+            QApplication.restoreOverrideCursor()
+            try:
+                self._mdi_end_open_batch()
+            except Exception:
+                pass
+
 
     def save_active(self):
         from setiastro.saspro.main_helpers import (

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -6,8 +6,9 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING
 
-from PyQt6.QtGui import QAction
+from PyQt6.QtGui import QAction, QKeySequence
 from PyQt6.QtWidgets import QMenu, QToolButton, QWidgetAction
+from PyQt6.QtCore import Qt
 
 if TYPE_CHECKING:
     pass
@@ -120,6 +121,9 @@ class MenuMixin:
         m_edit = mb.addMenu(self.tr("&Edit"))
         m_edit.addAction(self.act_undo)
         m_edit.addAction(self.act_redo)
+        m_edit.addSeparator()
+        m_edit.addAction(self.act_mono_to_rgb)
+
 
         # Functions
         m_fn = mb.addMenu(self.tr("&Functions"))
@@ -169,6 +173,7 @@ class MenuMixin:
         m_tools.addAction(self.act_freqsep)
         m_tools.addAction(self.act_image_combine)
         m_tools.addAction(self.act_multiscale_decomp)
+        m_tools.addAction(self.act_narrowband_normalization)
         m_tools.addAction(self.act_nbtorgb)
         m_tools.addAction(self.act_ppp)
         m_tools.addAction(self.act_selective_color)
@@ -199,6 +204,7 @@ class MenuMixin:
         m_star.addAction(self.act_isophote)
         m_star.addAction(self.act_live_stacking)
         m_star.addAction(self.act_mosaic_master)
+        m_star.addAction(self.act_planetary_stacker)
         m_star.addAction(self.act_plate_solve)
         m_star.addAction(self.act_psf_viewer)
         m_star.addAction(self.act_rgb_align)
@@ -267,6 +273,14 @@ class MenuMixin:
         m_view.addAction(self.act_tile_grid)        
         m_view.addSeparator()
 
+        # NEW: Minimize All Views
+        self.act_minimize_all_views = QAction(self.tr("Minimize All Views"), self)
+        self.act_minimize_all_views.setShortcut(QKeySequence("Ctrl+Shift+M"))
+        self.act_minimize_all_views.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
+        self.act_minimize_all_views.triggered.connect(self._minimize_all_views)
+        m_view.addAction(self.act_minimize_all_views)
+
+        m_view.addSeparator()
 
         # a button that shows current group & opens a drop-down
         self._link_btn = QToolButton(self)
@@ -389,3 +403,19 @@ class MenuMixin:
             if sub is not None:
                 yield from self._iter_menu_actions(sub)
 
+    def _minimize_all_views(self):
+        mdi = getattr(self, "mdi", None)
+        if mdi is None:
+            return
+
+        try:
+            for sw in mdi.subWindowList():
+                try:
+                    if not sw.isVisible():
+                        continue
+                    # Minimize each MDI child
+                    sw.showMinimized()
+                except Exception:
+                    pass
+        except Exception:
+            pass

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