setiastrosuitepro 1.6.4__py3-none-any.whl → 1.7.1.post2__py3-none-any.whl

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -12,13 +12,15 @@ from PyQt6.QtWidgets import QMenu, QToolButton
 
 from PyQt6.QtCore import QElapsedTimer
 
+import sys
+import os
 
 if TYPE_CHECKING:
     pass
 
 # Import icon paths - these are needed at runtime
 from setiastro.saspro.resources import (
-    icon_path, green_path, neutral_path, whitebalance_path,
+    icon_path, green_path, neutral_path, whitebalance_path, texture_clarity_path,
     morpho_path, clahe_path, starnet_path, staradd_path, LExtract_path,
     LInsert_path, rgbcombo_path, rgbextract_path, graxperticon_path,
     cropicon_path, openfile_path, abeicon_path, undoicon_path, redoicon_path,
@@ -30,10 +32,10 @@ from setiastro.saspro.resources import (
     stacking_path, pedestal_icon_path, starspike_path, astrospike_path,
     signature_icon_path, livestacking_path, convoicon_path, spcc_icon_path,
     exoicon_path, peeker_icon, dse_icon_path, isophote_path, statstretch_path,
-    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path,
+    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path, narrowbandnormalization_path,
     nbtorgb_path, freqsep_path, multiscale_decomp_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wims_path, wimi_path, linearfit_path,
-    debayer_path, aberration_path, functionbundles_path, viewbundles_path,
+    debayer_path, aberration_path, functionbundles_path, viewbundles_path, planetarystacker_path,
     selectivecolor_path, rgbalign_path,
 )
 
@@ -203,16 +205,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)
@@ -221,6 +223,7 @@ class ToolbarMixin:
         tb_fn.addAction(self.act_wavescale_hdr)
         tb_fn.addAction(self.act_wavescale_de)
         tb_fn.addAction(self.act_clahe)
+        tb_fn.addAction(self.act_texture_clarity)
         tb_fn.addAction(self.act_morphology)
         tb_fn.addAction(self.act_pixelmath)
         tb_fn.addAction(self.act_signature)
@@ -255,6 +258,8 @@ class ToolbarMixin:
         tb_tl.addAction(self.act_blink)  # Tools start here; Blink shows with QIcon(blink_path)
         tb_tl.addAction(self.act_ppp)    # Perfect Palette Picker
         tb_tl.addAction(self.act_nbtorgb)
+        tb_tl.addAction(self.act_narrowband_normalization)
+        
         tb_tl.addAction(self.act_selective_color)
         tb_tl.addAction(self.act_freqsep)
         tb_tl.addAction(self.act_multiscale_decomp)
@@ -301,6 +306,7 @@ class ToolbarMixin:
         tb_star.addAction(self.act_psf_viewer)
         tb_star.addAction(self.act_stacking_suite)
         tb_star.addAction(self.act_live_stacking)
+        tb_star.addAction(self.act_planetary_stacker)
         tb_star.addAction(self.act_plate_solve)
         tb_star.addAction(self.act_star_align)
         tb_star.addAction(self.act_star_register)
@@ -361,9 +367,26 @@ 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.addAction(self.act_narrowband_normalization)
+        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 +395,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 +406,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):
         """
@@ -442,7 +601,16 @@ class ToolbarMixin:
                 fit_menu.addAction(self.act_auto_fit_resize)  # use the real action
                 btn_fit.setMenu(fit_menu)
                 btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        tb = self._toolbar_containing_action(self.act_autostretch)
+        if tb:
+            btn = tb.widgetForAction(self.act_autostretch)
+            if isinstance(btn, QToolButton):
+                # ... build menu ...
+                btn.setMenu(menu)
+                btn.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+                # IMPORTANT: re-apply style after action moves / rebind
+                self._style_toggle_toolbutton(btn)
 
     def _bind_view_toolbar_menus(self, tb: DraggableToolBar):
         # --- Display-Stretch menu ---
@@ -498,6 +666,12 @@ class ToolbarMixin:
             btn_fit.setMenu(fit_menu)
             btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+    def _linux_force_text_action(self, act: QAction, text: str) -> None:
+        """On Linux, show text-only for this action (no theme icon)."""
+        if not sys.platform.startswith("linux"):
+            return
+        act.setIcon(QIcon())   # remove whatever theme icon got assigned
+        act.setText(text)      # show the glyph/text
 
     def _create_actions(self):
         # File actions
@@ -619,30 +793,30 @@ class ToolbarMixin:
         self.act_bake_display_stretch.triggered.connect(self._bake_display_stretch)
 
         # --- Zoom controls ---
-        # --- Zoom controls (themed icons) ---
         self.act_zoom_out = QAction(QIcon.fromTheme("zoom-out"), self.tr("Zoom Out"), self)
         self.act_zoom_out.setStatusTip(self.tr("Zoom out"))
         self.act_zoom_out.setShortcuts([QKeySequence("Ctrl+-")])
         self.act_zoom_out.triggered.connect(lambda: self._zoom_step_active(-1))
+        self._linux_force_text_action(self.act_zoom_out, "−")   # true minus
 
         self.act_zoom_in = QAction(QIcon.fromTheme("zoom-in"), self.tr("Zoom In"), self)
         self.act_zoom_in.setStatusTip(self.tr("Zoom in"))
-        self.act_zoom_in.setShortcuts([
-            QKeySequence("Ctrl++"),   # Ctrl + (Shift + = on many keyboards)
-            QKeySequence("Ctrl+="),   # fallback
-        ])
+        self.act_zoom_in.setShortcuts([QKeySequence("Ctrl++"), QKeySequence("Ctrl+=")])
         self.act_zoom_in.triggered.connect(lambda: self._zoom_step_active(+1))
+        self._linux_force_text_action(self.act_zoom_in, "+")
 
         self.act_zoom_1_1 = QAction(QIcon.fromTheme("zoom-original"), self.tr("1:1"), self)
         self.act_zoom_1_1.setStatusTip(self.tr("Zoom to 100% (pixel-for-pixel)"))
         self.act_zoom_1_1.setShortcut(QKeySequence("Ctrl+1"))
         self.act_zoom_1_1.triggered.connect(self._zoom_active_1_1)
+        self._linux_force_text_action(self.act_zoom_1_1, "1:1")
 
         self.act_zoom_fit = QAction(QIcon.fromTheme("zoom-fit-best"), self.tr("Fit"), self)
         self.act_zoom_fit.setStatusTip(self.tr("Fit image to current window"))
         self.act_zoom_fit.setShortcut(QKeySequence("Ctrl+0"))
         self.act_zoom_fit.triggered.connect(self._zoom_active_fit)
         self.act_zoom_fit.setCheckable(True)
+        self._linux_force_text_action(self.act_zoom_fit, "Fit")
 
         self.act_auto_fit_resize = QAction(self.tr("Auto-fit on Resize"), self)
         self.act_auto_fit_resize.setCheckable(True)
@@ -661,7 +835,13 @@ class ToolbarMixin:
         self.act_paste_view.setShortcut("Ctrl+Shift+V")
         self.act_copy_view.triggered.connect(self._copy_active_view)
         self.act_paste_view.triggered.connect(self._paste_active_view)
-
+        # --- Edit: Mono -> RGB (triplicate channels) ---
+        self.act_mono_to_rgb = QAction(self.tr("Convert Mono to RGB"), self)
+        self.act_mono_to_rgb.setStatusTip(self.tr("Convert a mono image to RGB by duplicating the channel"))
+        self.act_mono_to_rgb.triggered.connect(self._convert_mono_to_rgb_active)
+        self.act_swap_rb = QAction(self.tr("Swap R and B Channels"), self)
+        self.act_swap_rb.setStatusTip(self.tr("Swap red and blue channels on the active RGB image"))
+        self.act_swap_rb.triggered.connect(self._swap_rb_active)
         # Functions
         self.act_crop = QAction(QIcon(cropicon_path), self.tr("Crop..."), self)
         self.act_crop.setStatusTip(self.tr("Crop / rotate with handles"))
@@ -725,11 +905,17 @@ class ToolbarMixin:
         self.act_linear_fit.setShortcut("Ctrl+L")
         self.act_linear_fit.triggered.connect(self._open_linear_fit)
 
-        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green..."), self)
+        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green (SCNR)..."), self)
         self.act_remove_green.setToolTip(self.tr("SCNR-style green channel removal."))
         self.act_remove_green.setIconVisibleInMenu(True)
         self.act_remove_green.triggered.connect(self._open_remove_green)
 
+        # Texture and Clarity
+        self.act_texture_clarity = QAction(QIcon(texture_clarity_path), self.tr("Texture and Clarity..."), self)
+        self.act_texture_clarity.setToolTip(self.tr("Enhance texture and clarity using Unsharp Masking"))
+        self.act_texture_clarity.setIconVisibleInMenu(True)
+        self.act_texture_clarity.triggered.connect(self._open_texture_clarity)
+
         self.act_background_neutral = QAction(QIcon(neutral_path), self.tr("Background Neutralization..."), self)
         self.act_background_neutral.setStatusTip(self.tr("Neutralize background color balance using a sampled region"))
         self.act_background_neutral.setIconVisibleInMenu(True)
@@ -767,6 +953,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 +973,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:
@@ -947,6 +1136,13 @@ class ToolbarMixin:
         self.act_ppp.setStatusTip(self.tr("Pick the perfect palette for your image"))
         self.act_ppp.triggered.connect(self._open_ppp_tool) 
 
+        self.act_narrowband_normalization = QAction(QIcon(narrowbandnormalization_path), self.tr("Narrowband Normalization..."), self)
+        self.act_narrowband_normalization.setStatusTip(
+            self.tr("Normalize HOO/SHO/HSO/HOS (PixelMath port by Bill Blanshan and Mike Cranfield)")
+        )
+
+        self.act_narrowband_normalization.triggered.connect(self._open_narrowband_normalization_tool)
+
         self.act_nbtorgb = QAction(QIcon(nbtorgb_path), self.tr("NB->RGB Stars..."), self)
         self.act_nbtorgb.setStatusTip(self.tr("Combine narrowband to RGB with optional OSC stars"))
         self.act_nbtorgb.setIconVisibleInMenu(True)
@@ -994,6 +1190,11 @@ class ToolbarMixin:
         self.act_live_stacking.setStatusTip(self.tr("Live monitor and stack incoming frames"))
         self.act_live_stacking.triggered.connect(self._open_live_stacking)
 
+        self.act_planetary_stacker = QAction(QIcon(planetarystacker_path), self.tr("Planetary Stacker..."), self)
+        self.act_planetary_stacker.setIconVisibleInMenu(True)
+        self.act_planetary_stacker.setStatusTip(self.tr("Stack SER videos (planetary/solar/lunar)"))
+        self.act_planetary_stacker.triggered.connect(self._open_planetary_stacker)
+
         self.act_plate_solve = QAction(QIcon(platesolve_path), self.tr("Plate Solver..."), self)
         self.act_plate_solve.setIconVisibleInMenu(True)
         self.act_plate_solve.setStatusTip(self.tr("Solve WCS/SIP for the active image or a file"))
@@ -1105,6 +1306,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)
@@ -1183,6 +1391,7 @@ class ToolbarMixin:
         reg("nbtorgb",       self.act_nbtorgb)
         reg("freqsep",       self.act_freqsep)
         reg("selective_color", self.act_selective_color)
+        reg("narrowband_normalization", self.act_narrowband_normalization)
         reg("contsub",      self.act_contsub)
         reg("abe",          self.act_abe)
         reg("create_mask", self.act_create_mask)
@@ -1191,6 +1400,7 @@ class ToolbarMixin:
         reg("add_stars", self.act_add_stars)
         reg("pedestal",       self.act_pedestal)
         reg("remove_green",   self.act_remove_green)
+        reg("texture_clarity", self.act_texture_clarity)
         reg("background_neutral", self.act_background_neutral)
         reg("white_balance", self.act_white_balance)
         reg("sfcc",    self.act_sfcc)
@@ -1207,7 +1417,7 @@ class ToolbarMixin:
         reg("pixel_math", self.act_pixelmath)
         reg("signature_insert", self.act_signature) 
         reg("halo_b_gon", self.act_halobgon)
-
+        reg("planetary_stacker", self.act_planetary_stacker)
         reg("multiscale_decomp", self.act_multiscale_decomp)        
         reg("geom_invert",                 self.act_geom_invert)
         reg("geom_flip_horizontal",        self.act_geom_flip_h)
@@ -1245,6 +1455,83 @@ class ToolbarMixin:
         reg("view_bundles", self.act_view_bundles)
         reg("function_bundles", self.act_function_bundles)
 
+    def _reset_all_toolbars_to_factory(self):
+        """
+        Clears all persisted toolbar membership/order/hidden state so the UI
+        returns to the factory layout defined in code.
+        """
+        if not hasattr(self, "settings"):
+            return
+
+        # 1) Clear global toolbar persistence
+        keys_to_clear = [
+            "Toolbar/Assignments",
+            "Toolbar/HiddenPrev",
+            "Toolbar/HiddenMigrationDone",
+
+            # Per-toolbar order lists
+            "Toolbar/View",
+            "Toolbar/Functions",
+            "Toolbar/Cosmic",
+            "Toolbar/Tools",
+            "Toolbar/Geometry",
+            "Toolbar/StarStuff",
+            "Toolbar/Masks",
+            "Toolbar/WhatsInMy",
+            "Toolbar/Bundles",
+            "Toolbar/Hidden",
+        ]
+
+        for k in keys_to_clear:
+            try:
+                self.settings.remove(k)
+            except Exception:
+                pass
+
+        # 2) Clear legacy hidden lists (old system) if they exist
+        # (These are the ones like "Toolbar/Tools/Hidden")
+        try:
+            # brute-force remove known ones
+            legacy_hidden = [
+                "Toolbar/View/Hidden",
+                "Toolbar/Functions/Hidden",
+                "Toolbar/Cosmic/Hidden",
+                "Toolbar/Tools/Hidden",
+                "Toolbar/Geometry/Hidden",
+                "Toolbar/StarStuff/Hidden",
+                "Toolbar/Masks/Hidden",
+                "Toolbar/WhatsInMy/Hidden",
+                "Toolbar/Bundles/Hidden",
+            ]
+            for k in legacy_hidden:
+                self.settings.remove(k)
+        except Exception:
+            pass
+
+        try:
+            self.settings.sync()
+        except Exception:
+            pass
+
+        # 3) Rebuild toolbars from code defaults
+        # Safest approach: remove existing toolbars and rebuild.
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for tb in self.findChildren(DraggableToolBar):
+            try:
+                self.removeToolBar(tb)
+                tb.deleteLater()
+            except Exception:
+                pass
+
+        # Build fresh
+        self._init_toolbar()
+
+        # Optional: ensure Hidden stays hidden
+        tb_hidden = self._hidden_toolbar()
+        if tb_hidden:
+            tb_hidden.setVisible(False)
+
+
     def _restore_toolbar_order(self, tb, settings_key: str):
         """
         Restore toolbar action order from QSettings, using command_id/objectName.
@@ -1356,6 +1643,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
@@ -1477,4 +1946,10 @@ class ToolbarMixin:
         if hasattr(self, "act_hide_mask"):
             self.act_hide_mask.setEnabled(has_mask and overlay_on)
 
-
+    def _style_toggle_toolbutton(self, btn: QToolButton):
+        # Make sure the action visually shows "on" state
+        btn.setCheckable(True)  # safe even if already
+        btn.setStyleSheet("""
+            QToolButton { color: #dcdcdc; }
+            QToolButton:checked { color: #DAA520; font-weight: 600; }
+        """)