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

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -12,6 +12,7 @@ from PyQt6.QtWidgets import QMenu, QToolButton
 
 from PyQt6.QtCore import QElapsedTimer
 
+import sys
 
 if TYPE_CHECKING:
     pass
@@ -203,16 +204,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 +362,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 +389,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 +400,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 +595,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 +660,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 +787,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)
@@ -767,6 +935,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 +955,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 +1276,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 +1534,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 +1837,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; }
+        """)