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

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -229,6 +229,7 @@ class MenuMixin:
 
 
         m_header = mb.addMenu(self.tr("&Header Mods && Misc"))
+        m_header.addAction(self.act_acv_exporter)        
         m_header.addAction(self.act_astrobin_exporter)
         m_header.addAction(self.act_batch_convert)
         m_header.addAction(self.act_batch_renamer)

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
 

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -203,16 +203,16 @@ class ToolbarMixin:
         tb_fn.addAction(self.act_convo)
         tb_fn.addAction(self.act_extract_luma)
 
-        btn_luma = tb_fn.widgetForAction(self.act_extract_luma)
-        if isinstance(btn_luma, QToolButton):
-            luma_menu = QMenu(btn_luma)
-            luma_menu.addActions(self._luma_group.actions())
-            btn_luma.setMenu(luma_menu)
-            btn_luma.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
-            btn_luma.setStyleSheet("""
-                QToolButton { color: #dcdcdc; }
-                QToolButton:pressed, QToolButton:checked { color: #DAA520; font-weight: 600; }
-            """)
+        #btn_luma = tb_fn.widgetForAction(self.act_extract_luma)
+        #if isinstance(btn_luma, QToolButton):
+        #    luma_menu = QMenu(btn_luma)
+        #    luma_menu.addActions(self._luma_group.actions())
+        #    btn_luma.setMenu(luma_menu)
+        #    btn_luma.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        #    btn_luma.setStyleSheet("""
+        #        QToolButton { color: #dcdcdc; }
+        #        QToolButton:pressed, QToolButton:checked { color: #DAA520; font-weight: 600; }
+        #    """)
 
         tb_fn.addAction(self.act_recombine_luma)
         tb_fn.addAction(self.act_rgb_extract)
@@ -361,9 +361,25 @@ class ToolbarMixin:
         except Exception:
             pass
 
+
+        tb_hidden = DraggableToolBar(self.tr("Hidden"), self)
+        tb_hidden.setObjectName("Hidden")
+        tb_hidden.setSettingsKey("Toolbar/Hidden")
+        self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_hidden)
+        tb_hidden.setVisible(False)  # <- always hidden
+
         # This can move actions between toolbars, so do it after each toolbar has its base order restored.
         self._restore_toolbar_memberships()
 
+        # Migrate legacy per-toolbar Hidden lists into the new Hidden toolbar
+        self._migrate_old_hidden_sets_to_hidden_toolbar()
+
+        # (Optional) Re-apply per-toolbar order after migration (since we removed actions)
+        for _tb in self.findChildren(DraggableToolBar):
+            key = getattr(_tb, "_settings_key", None)
+            if key:
+                self._restore_toolbar_order(_tb, str(key))
+
         # Re-apply hidden state AFTER memberships (actions may have moved toolbars).
         # This also guarantees correctness even if any toolbar was rebuilt/adjusted internally.
         for _tb in self.findChildren(DraggableToolBar):
@@ -372,7 +388,9 @@ class ToolbarMixin:
             except Exception:
                 pass
 
+        # Rebind ALL dropdowns after reorder/membership moves
         self._rebind_view_dropdowns()
+        self._rebind_extract_luma_dropdown()
 
     def _toolbar_containing_action(self, action: QAction):
         from setiastro.saspro.shortcuts import DraggableToolBar
@@ -381,6 +399,140 @@ class ToolbarMixin:
                 return tb
         return None
 
+    def _rebind_extract_luma_dropdown(self):
+        from PyQt6.QtWidgets import QMenu, QToolButton
+        from setiastro.saspro.luminancerecombine import LUMA_PROFILES
+
+        tb = self._toolbar_containing_action(self.act_extract_luma)
+        if not tb:
+            return
+
+        btn = tb.widgetForAction(self.act_extract_luma)
+        if not isinstance(btn, QToolButton):
+            return
+
+        menu = QMenu(btn)
+
+        # Ensure cache exists (created in _create_actions(), but be defensive)
+        if not hasattr(self, "_luma_sensor_actions"):
+            self._luma_sensor_actions = {}  # key -> QAction
+
+        cur_method = str(getattr(self, "luma_method", "rec709"))
+
+        # ============================================================
+        # PATCH SITE #1 (Standard menu)  <-- THIS IS WHERE "C" GOES
+        # Find your old block:
+        #
+        #   # ---- Standard (use your QActionGroup, keep it simple) ----
+        #   if getattr(self, "_luma_group", None) is not None:
+        #       std_menu = QMenu(self.tr("Standard"), menu)
+        #       std_menu.addActions(self._luma_group.actions())
+        #       menu.addMenu(std_menu)
+        #
+        # Replace it with the block below.
+        # ============================================================
+        if getattr(self, "_luma_group", None) is not None:
+            # Sync standard checked states from self.luma_method
+            for a in self._luma_group.actions():
+                data = str(a.data() or "")
+                if data.startswith("sensor:"):
+                    continue  # standards only in Standard menu
+                a.blockSignals(True)
+                try:
+                    a.setChecked(data == cur_method)
+                finally:
+                    a.blockSignals(False)
+
+            # Add ONLY standard actions to the Standard menu (exclude sensors)
+            std_menu = QMenu(self.tr("Standard"), menu)
+            for a in self._luma_group.actions():
+                data = str(a.data() or "")
+                if data.startswith("sensor:"):
+                    continue
+                std_menu.addAction(a)
+            menu.addMenu(std_menu)
+
+        # ---- Sensors (nested by category path) ----
+        sensors_root = QMenu(self.tr("Sensors"), menu)
+
+        # Build tree of submenus keyed by "Sensors/<path>"
+        submenu_cache: dict[str, QMenu] = {}
+
+        def get_or_make_path(root_menu: QMenu, path: str) -> QMenu:
+            parts = [p for p in path.split("/") if p.strip()]
+            cur = root_menu
+            acc = ""
+            for part in parts:
+                acc = f"{acc}/{part}" if acc else part
+                if acc not in submenu_cache:
+                    sm = QMenu(self.tr(part), cur)
+                    cur.addMenu(sm)
+                    submenu_cache[acc] = sm
+                cur = submenu_cache[acc]
+            return cur
+
+        any_sensor = False
+        for key, prof in LUMA_PROFILES.items():
+            if not str(key).startswith("sensor:"):
+                continue
+
+            cat = str(prof.get("category", "Sensors/Other"))
+            group_path = cat.split("Sensors/", 1)[1] if "Sensors/" in cat else cat
+            parent_menu = get_or_make_path(sensors_root, group_path)
+
+            display_name = key.split("sensor:", 1)[1].strip()
+            desc = str(prof.get("description", display_name))
+            info = str(prof.get("info", "")).strip()
+
+            # ============================================================
+            # PATCH SITE #2 (Sensors become mutually exclusive with standards)
+            # - Cache the QAction so we don't pile up connections/actions
+            # - Add it to the SAME QActionGroup (exclusive) as standards
+            # - Do NOT use _pick_sensor; rely on QActionGroup.triggered
+            # ============================================================
+            act = self._luma_sensor_actions.get(key)
+            if act is None:
+                act = parent_menu.addAction(self.tr(display_name))
+                act.setCheckable(True)
+                act.setData(key)  # IMPORTANT: enables group.triggered to set luma_method
+
+                # Put sensors into the SAME exclusive group so selecting one
+                # deselects everything else (standards and other sensors).
+                if getattr(self, "_luma_group", None) is not None:
+                    self._luma_group.addAction(act)
+
+                self._luma_sensor_actions[key] = act
+            else:
+                # Reuse action, but re-add it to the correct submenu location
+                parent_menu.addAction(act)
+                act.setText(self.tr(display_name))
+
+            # Update UI info each bind (safe if translations change)
+            if info:
+                act.setStatusTip(info)
+                act.setToolTip(f"{desc}\n{info}")
+            else:
+                act.setToolTip(desc)
+
+            # Checked state reflects current selection
+            act.blockSignals(True)
+            try:
+                act.setChecked(cur_method == str(key))
+            finally:
+                act.blockSignals(False)
+
+            any_sensor = True
+
+        if any_sensor:
+            menu.addMenu(sensors_root)
+
+        btn.setMenu(menu)
+        btn.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        btn.setStyleSheet("""
+            QToolButton { color: #dcdcdc; }
+            QToolButton:pressed, QToolButton:checked { color: #DAA520; font-weight: 600; }
+        """)
+
 
     def _rebind_view_dropdowns(self):
         """
@@ -767,6 +919,7 @@ class ToolbarMixin:
         self.luma_method = getattr(self, "luma_method", "rec709")  # default
         self._luma_group = QActionGroup(self)
         self._luma_group.setExclusive(True)
+        self._luma_sensor_actions = {}  # key -> QAction
 
         def _mk(method_key, text):
             act = QAction(text, self, checkable=True)
@@ -786,8 +939,10 @@ class ToolbarMixin:
 
         # update method when user picks from the menu
         def _on_luma_pick(act):
-            self.luma_method = act.data()
-            # (optional) persist
+            key = act.data()
+            if key is None:
+                return
+            self.luma_method = str(key)
             try:
                 self.settings.setValue("ui/luminance_method", self.luma_method)
             except Exception:
@@ -1105,6 +1260,13 @@ class ToolbarMixin:
         self.act_copy_astrometry = QAction(self.tr("Copy Astrometric Solution..."), self)
         self.act_copy_astrometry.triggered.connect(self._open_copy_astrometry)
 
+        self.act_acv_exporter = QAction(self.tr("Astro Catalogue Viewer Exporter..."), self)
+        self.act_acv_exporter.setIconVisibleInMenu(True)
+        self.act_acv_exporter.setStatusTip(self.tr("Export current view into Astro Catalogue Viewer folders"))
+        self.act_acv_exporter.triggered.connect(self._open_acv_exporter)
+
+
+
         # Create Mask
         self.act_create_mask = QAction(QIcon(maskcreate_path), self.tr("Create Mask..."), self)
         self.act_create_mask.setIconVisibleInMenu(True)
@@ -1356,6 +1518,188 @@ class ToolbarMixin:
             if key:
                 self._restore_toolbar_order(tb, str(key))
 
+    def _hidden_toolbar(self):
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for tb in self.findChildren(DraggableToolBar):
+            if getattr(tb, "_settings_key", None) == "Toolbar/Hidden" or tb.objectName() == "Hidden":
+                return tb
+        return None
+
+    def _toolbar_by_settings_key(self, key: str):
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for tb in self.findChildren(DraggableToolBar):
+            if getattr(tb, "_settings_key", None) == key:
+                return tb
+        return None
+
+    def _action_cid(self, act):
+        return str(act.property("command_id") or act.objectName() or "")
+
+    def _hide_action_to_hidden_toolbar(self, act):
+        """
+        Move action to the Hidden toolbar, remembering where it came from.
+        """
+        tb_hidden = self._hidden_toolbar()
+        if not tb_hidden:
+            return
+
+        cid = self._action_cid(act)
+        if not cid:
+            return
+
+        # Find current toolbar (if any) and remember it
+        cur_tb = self._toolbar_containing_action(act)
+        if cur_tb and getattr(cur_tb, "_settings_key", None) and cur_tb is not tb_hidden:
+            prev_key = str(cur_tb._settings_key)
+
+            # Persist "previous toolbar" so unhide can restore
+            try:
+                raw = self.settings.value("Toolbar/HiddenPrev", "", type=str) or ""
+            except Exception:
+                raw = ""
+            try:
+                prev = json.loads(raw) if raw else {}
+            except Exception:
+                prev = {}
+            prev[cid] = prev_key
+            self.settings.setValue("Toolbar/HiddenPrev", json.dumps(prev))
+
+        # Remove from all toolbars, add to hidden
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for t in self.findChildren(DraggableToolBar):
+            if act in t.actions():
+                t.removeAction(act)
+
+        tb_hidden.addAction(act)
+
+        # Update assignment mapping so restore works on next launch
+        tb_hidden._update_assignment_for_action(act)
+
+        # Persist ordering (optional but nice)
+        try:
+            tb_hidden._persist_order()
+        except Exception:
+            pass
+        if cur_tb:
+            try:
+                cur_tb._persist_order()
+            except Exception:
+                pass
+
+    def _unhide_action_from_hidden_toolbar(self, act):
+        """
+        Move action out of Hidden toolbar back to its remembered toolbar.
+        Falls back to Toolbar/View if missing.
+        """
+        tb_hidden = self._hidden_toolbar()
+        if not tb_hidden:
+            return
+
+        cid = self._action_cid(act)
+        if not cid:
+            return
+
+        # Load prev mapping
+        try:
+            raw = self.settings.value("Toolbar/HiddenPrev", "", type=str) or ""
+        except Exception:
+            raw = ""
+        try:
+            prev = json.loads(raw) if raw else {}
+        except Exception:
+            prev = {}
+
+        target_key = prev.get(cid) or "Toolbar/View"
+        tb_target = self._toolbar_by_settings_key(target_key) or self._toolbar_by_settings_key("Toolbar/View")
+        if not tb_target:
+            return
+
+        tb_hidden.removeAction(act)
+        tb_target.addAction(act)
+
+        # Update assignment mapping
+        tb_target._update_assignment_for_action(act)
+
+        # Cleanup prev mapping (optional)
+        if cid in prev:
+            prev.pop(cid, None)
+            self.settings.setValue("Toolbar/HiddenPrev", json.dumps(prev))
+
+        try:
+            tb_target._persist_order()
+            tb_hidden._persist_order()
+        except Exception:
+            pass
+
+    def _migrate_old_hidden_sets_to_hidden_toolbar(self):
+        """
+        One-time migration:
+        Old system: per-toolbar QSettings lists at "<ToolbarKey>/Hidden" storing action IDs
+        New system: move those actions into the dedicated Hidden toolbar (Toolbar/Hidden)
+                    and persist membership via Toolbar/Assignments.
+        """
+        if not hasattr(self, "settings"):
+            return
+
+        # Run once
+        if self.settings.value("Toolbar/HiddenMigrationDone", False, type=bool):
+            return
+
+        tb_hidden = self._hidden_toolbar()
+        if not tb_hidden:
+            return
+
+        from setiastro.saspro.shortcuts import DraggableToolBar
+
+        # If Hidden toolbar already has actions, assume user is already on new system
+        # but we still can migrate any remaining old keys.
+        # (We won't early-return.)
+
+        for tb in self.findChildren(DraggableToolBar):
+            k = getattr(tb, "_settings_key", None)
+            if not k or str(k) == "Toolbar/Hidden":
+                continue
+
+            # Old storage key
+            old_key = f"{k}/Hidden"
+
+            # Read old hidden list (Qt backend may return list OR str)
+            try:
+                raw = self.settings.value(old_key, [], type=list)
+            except Exception:
+                raw = self.settings.value(old_key, [])  # fallback
+
+            if not raw:
+                continue
+
+            if isinstance(raw, str):
+                raw_list = [raw]
+            else:
+                try:
+                    raw_list = list(raw)
+                except Exception:
+                    raw_list = []
+
+            hidden_ids = {str(x) for x in raw_list if str(x).strip()}
+            if not hidden_ids:
+                # Clear junk so we don’t keep trying
+                self.settings.setValue(old_key, [])
+                continue
+
+            # Move matching actions into Hidden toolbar
+            for act in list(tb.actions()):
+                if act is None or act.isSeparator():
+                    continue
+                cid = str(act.property("command_id") or act.objectName() or "")
+                if cid and cid in hidden_ids:
+                    self._hide_action_to_hidden_toolbar(act)
+
+            # Clear old storage so you don't keep re-migrating
+            self.settings.setValue(old_key, [])
+
+        # Mark migration complete
+        self.settings.setValue("Toolbar/HiddenMigrationDone", True)
+
 
     def update_undo_redo_action_labels(self):
         if not hasattr(self, "act_undo"):  # not built yet