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

setiastro/saspro/shortcuts.py

@@ -209,6 +209,17 @@ class DraggableToolBar(QToolBar):
         s.setValue(self._settings_key, ids)
 
 
+    def _is_locked(self) -> bool:
+        """Check if toolbar icon movement is locked globally."""
+        s = self._settings()
+        # Default to False (unlocked)
+        return s.value("UI/ToolbarLocked", False, type=bool)
+
+    def _set_locked(self, locked: bool):
+        """Set the global lock state."""
+        s = self._settings()
+        s.setValue("UI/ToolbarLocked", locked)
+
     # install/remove our event filter when actions are added/removed
     def actionEvent(self, e):
         super().actionEvent(e)
@@ -259,6 +270,7 @@ class DraggableToolBar(QToolBar):
                     if delta.manhattanLength() > QApplication.startDragDistance():
                         mods_now = QApplication.keyboardModifiers()
                         had_mod  = self._press_had_mod.get(obj, False)
+                        
                         # CASE 1: had/has modifiers → create desktop shortcut / function-bundle drag (existing behavior)
                         if had_mod or self._mods_ok(mods_now):
                             act = self._find_action_for_button(obj)
@@ -270,6 +282,20 @@ class DraggableToolBar(QToolBar):
                             return True  # consume
                         else:
                             # CASE 2: plain drag (no modifiers) → reorder within this toolbar
+                            # CHECK LOCK STATE FIRST
+                            if self._is_locked():
+                                # Lock is active: DO NOT start drag.
+                                # Should we consume the event? 
+                                # If we consume it, the button won't feel "pressed" anymore if the user keeps dragging?
+                                # Actually, if we just return False, standard QToolButton behavior applies (it might think it's being pressed).
+                                # However, we want to prevent the *reorder* logic.
+                                # So simply doing nothing here is enough to prevent the reorder drag from starting.
+                                
+                                # But we might want to let the user know, or just silently fail distinctively?
+                                # Silently failing distinctively is what the user asked for (prevent involuntary move).
+                                # If we return False, the button keeps tracking the mouse, which is fine (it won't click unless released inside).
+                                return False 
+
                             self._start_reorder_drag_for_button(obj)
                             self._suppress_release.add(obj)
                             self._press_pos.pop(obj, None)
@@ -461,50 +487,73 @@ class DraggableToolBar(QToolBar):
     def _show_toolbutton_context_menu(self, btn: QToolButton, act: QAction, gpos: QPoint):
         m = QMenu(btn)
 
-        m.addAction("Create Desktop Shortcut", lambda: self._add_shortcut_for_action(act))
+        m.addAction(self.tr("Create Desktop Shortcut"), lambda: self._add_shortcut_for_action(act))
 
         # Hide this icon
         cid = self._action_id(act)
         if cid:
             m.addSeparator()
-            m.addAction("Hide this icon", lambda: self._set_action_hidden(act, True))
+            m.addAction(self.tr("Hide this icon"), lambda: self.window()._hide_action_to_hidden_toolbar(act))
+
 
         # (Optional) teach users about Alt+Drag:
         m.addSeparator()
-        tip = m.addAction("Tip: Alt+Drag to create")
+        tip = m.addAction(self.tr("Tip: Alt+Drag to create"))
         tip.setEnabled(False)
 
         m.exec(gpos)
 
+
     def contextMenuEvent(self, ev):
         # Right-click on empty toolbar area
         m = QMenu(self)
 
+        # 1. Lock/Unlock Action
+        is_locked = self._is_locked()
+        act_lock = m.addAction(self.tr("Lock Toolbar Icons"))
+        act_lock.setCheckable(True)
+        act_lock.setChecked(is_locked)
+        
+        def _toggle_lock(checked):
+            self._set_locked(checked)
+            
+        act_lock.triggered.connect(_toggle_lock)
+        
+        m.addSeparator()
+
         # Submenu listing hidden actions for this toolbar
-        hidden = self._load_hidden_set()
-        sub = m.addMenu("Show hidden…")
+        sub = m.addMenu(self.tr("Show hidden…"))
 
-        # Build list from actions that are currently invisible
+        mw = self.window()
+        tb_hidden = getattr(mw, "_hidden_toolbar", lambda: None)()
         any_hidden = False
-        for act in self.actions():
-            cid = self._action_id(act)
-            if cid and (cid in hidden) and (not act.isVisible()):
+        if tb_hidden:
+            for act in tb_hidden.actions():
+                # Skip separators
+                if act.isSeparator():
+                    continue
                 any_hidden = True
-                sub.addAction(act.text() or cid, lambda a=act: self._set_action_hidden(a, False))
+                sub.addAction(act.text() or (act.property("command_id") or act.objectName() or "item"),
+                              lambda a=act: mw._unhide_action_from_hidden_toolbar(a))
 
         if not any_hidden:
             sub.setEnabled(False)
 
         m.addSeparator()
-        m.addAction("Reset hidden icons", self._reset_hidden_icons)
+        m.addAction(self.tr("Reset hidden icons"), self._reset_hidden_icons)
 
         m.exec(ev.globalPos())
 
     def _reset_hidden_icons(self):
-        # Show everything and clear hidden list
-        for act in self.actions():
-            act.setVisible(True)
-        self._save_hidden_set(set())
+        mw = self.window()
+        tb_hidden = getattr(mw, "_hidden_toolbar", lambda: None)()
+        if not tb_hidden:
+            return
+        # copy list because we'll mutate
+        acts = [a for a in tb_hidden.actions() if not a.isSeparator()]
+        for a in acts:
+            mw._unhide_action_from_hidden_toolbar(a)
+
 
 
 _PRESET_UI_IDS = {
@@ -515,7 +564,7 @@ _PRESET_UI_IDS = {
     "remove_green","star_align","background_neutral","white_balance","clahe",
     "morphology","pixel_math","rgb_align","signature_insert","signature_adder",
     "signature","halo_b_gon","geom_rescale","rescale","debayer","image_combine",
-    "star_spikes","diffraction_spikes", "multiscale_decomp",
+    "star_spikes","diffraction_spikes", "multiscale_decomp","geom_rotate_any",
 }
 
 def _has_preset_editor_for_command(command_id: str) -> bool:
@@ -548,6 +597,12 @@ def _open_preset_editor_for_command(parent, command_id: str, initial: dict | Non
         })
         return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
 
+    if command_id == "geom_rotate_any":
+        dlg = _GeomRotateAnyPresetDialog(parent, initial=cur or {
+            "angle_deg": 0.0,
+        })
+        return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
+
     if command_id == "curves":
         dlg = _CurvesPresetDialog(parent, initial=cur or {"shape":"linear","amount":0.5,"mode":"K (Brightness)"})
         return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
@@ -741,18 +796,18 @@ class ShortcutButton(QToolButton):
     # --- Context menu (run / preset / delete) ----------------------------
     def _context_menu(self, pos):
         m = QMenu(self)
-        m.addAction("Run", lambda: self._mgr.trigger(self.command_id))
+        m.addAction(self.tr("Run"), lambda: self._mgr.trigger(self.command_id))
         m.addSeparator()
-        m.addAction("Edit Preset…", self._edit_preset_ui)
-        m.addAction("Clear Preset", lambda: self._save_preset(None))
-        m.addAction("Rename…", self._rename)                    # ← NEW
+        m.addAction(self.tr("Edit Preset…"), self._edit_preset_ui)
+        m.addAction(self.tr("Clear Preset"), lambda: self._save_preset(None))
+        m.addAction(self.tr("Rename…"), self._rename)                    # ← NEW
         m.addSeparator()
-        m.addAction("Delete", self._delete)
+        m.addAction(self.tr("Delete"), self._delete)
         m.exec(self.mapToGlobal(pos))
 
     def _rename(self):
         current = self.text()
-        new_name, ok = QInputDialog.getText(self, "Rename Shortcut", "Name:", text=current)
+        new_name, ok = QInputDialog.getText(self, self.tr("Rename Shortcut"), self.tr("Name:"), text=current)
         if not ok or not new_name.strip():
             return
         self.setText(new_name.strip())
@@ -764,21 +819,21 @@ class ShortcutButton(QToolButton):
         result = _open_preset_editor_for_command(self, cid, cur)
         if result is not None:
             self._save_preset(result)
-            QMessageBox.information(self, "Preset saved", "Preset stored on shortcut.")
+            QMessageBox.information(self, self.tr("Preset saved"), self.tr("Preset stored on shortcut."))
             return
 
         # Fallback: JSON editor
         raw = json.dumps(cur or {}, indent=2)
-        text, ok = QInputDialog.getMultiLineText(self, "Edit Preset (JSON)", "Preset:", raw)
+        text, ok = QInputDialog.getMultiLineText(self, self.tr("Edit Preset (JSON)"), self.tr("Preset:"), raw)
         if ok:
             try:
                 preset = json.loads(text or "{}")
                 if not isinstance(preset, dict):
-                    raise ValueError("Preset must be a JSON object")
+                    raise ValueError(self.tr("Preset must be a JSON object"))
                 self._save_preset(preset)
-                QMessageBox.information(self, "Preset saved", "Preset stored on shortcut.")
+                QMessageBox.information(self, self.tr("Preset saved"), self.tr("Preset stored on shortcut."))
             except Exception as e:
-                QMessageBox.warning(self, "Invalid JSON", str(e))
+                QMessageBox.warning(self, self.tr("Invalid JSON"), str(e))
 
 
     def _start_command_drag(self):
@@ -978,17 +1033,14 @@ class ShortcutCanvas(QWidget):
             return False
         sw = self._top_subwindow_at(e.position().toPoint())
         if sw is None:
-            print("[ShortcutCanvas] _forward_command_drop: no subwindow under cursor", flush=True)
-            QApplication.processEvents()
+
             return False
         try:
             raw = bytes(md.data(MIME_CMD))
             payload = _unpack_cmd_payload(raw)  # your existing helper
-            print(f"[ShortcutCanvas] _forward_command_drop → subwin={sw}, payload={payload!r}", flush=True)
-            QApplication.processEvents()
+
         except Exception as ex:
-            print(f"[ShortcutCanvas] _forward_command_drop: failed to unpack payload: {ex!r}", flush=True)
-            QApplication.processEvents()
+
             return False
         self._mgr.apply_command_to_subwindow(sw, payload)
         e.acceptProposedAction()
@@ -1066,11 +1118,11 @@ class ShortcutCanvas(QWidget):
     def contextMenuEvent(self, e):
         menu = QMenu(self)
         has_sel = bool(self._mgr.selected)
-        a_del = menu.addAction("Delete Selected", self._mgr.delete_selected); a_del.setEnabled(has_sel)
-        a_clr = menu.addAction("Clear Selection", self._mgr.clear_selection); a_clr.setEnabled(has_sel)
+        a_del = menu.addAction(self.tr("Delete Selected"), self._mgr.delete_selected); a_del.setEnabled(has_sel)
+        a_clr = menu.addAction(self.tr("Clear Selection"), self._mgr.clear_selection); a_clr.setEnabled(has_sel)
         menu.addSeparator()
-        a_vb = menu.addAction("View Bundles…", lambda: _open_view_bundles_from_canvas(self))
-        a_fb = menu.addAction("Function Bundles…", lambda: _open_function_bundles_from_canvas(self))
+        a_vb = menu.addAction(self.tr("View Bundles…"), lambda: _open_view_bundles_from_canvas(self))
+        a_fb = menu.addAction(self.tr("Function Bundles…"), lambda: _open_function_bundles_from_canvas(self))
         menu.exec(e.globalPos())
 
 
@@ -1490,6 +1542,7 @@ class ShortcutManager:
 
     # ---- persistence (QSettings JSON blob) ----
     def save_shortcuts(self):
+       
         data = []
         for sid, w in list(self.widgets.items()):
             if _is_dead(w):
@@ -1790,6 +1843,7 @@ class ShortcutManager:
 
 
     def clear(self):
+      
         for sid, w in list(self.widgets.items()):
             try:
                 if not _is_dead(w):
@@ -1864,50 +1918,173 @@ class ShortcutManager:
         # legacy single-remove (kept for callers)
         self.delete_by_id(sid, persist=True)
 
-
 class _StatStretchPresetDialog(QDialog):
+    """
+    Preset editor for headless replay: command_id="stat_stretch"
+
+    Keys supported:
+      target_median: float
+      linked: bool
+      normalize: bool
+      apply_curves: bool
+      curves_boost: float            # 0..1
+      blackpoint_sigma: float        # 0..1 (matches your slider/100)
+      no_black_clip: bool
+      hdr_compress: bool
+      hdr_amount: float              # 0..1
+      hdr_knee: float                # 0..1
+      luma_only: bool
+      luma_mode: str                 # e.g. "rec709"
+      luma_blend: float              #0..1 (0=normal linked, 1=pure luma-only)
+    """
     def __init__(self, parent=None, initial: dict | None = None):
         super().__init__(parent)
         self.setWindowTitle("Statistical Stretch — Preset")
         init = dict(initial or {})
 
+        # --- Target median ---
         self.spin_target = QDoubleSpinBox()
-        self.spin_target.setRange(0.0, 1.0); self.spin_target.setDecimals(3)
+        self.spin_target.setRange(0.0, 1.0)
+        self.spin_target.setDecimals(3)
         self.spin_target.setSingleStep(0.01)
         self.spin_target.setValue(float(init.get("target_median", 0.25)))
 
+        # --- Linked / Normalize ---
         self.chk_linked = QCheckBox("Linked RGB channels")
         self.chk_linked.setChecked(bool(init.get("linked", False)))
 
         self.chk_normalize = QCheckBox("Normalize to [0..1]")
         self.chk_normalize.setChecked(bool(init.get("normalize", False)))
 
+        # --- Curves ---
+        self.chk_curves = QCheckBox("Apply Curves")
+        self.chk_curves.setChecked(bool(init.get("apply_curves", False)))
+
         self.spin_curves = QDoubleSpinBox()
-        self.spin_curves.setRange(0.0, 1.0); self.spin_curves.setDecimals(2)
+        self.spin_curves.setRange(0.0, 1.0)
+        self.spin_curves.setDecimals(2)
         self.spin_curves.setSingleStep(0.05)
-        self.spin_curves.setValue(float(init.get("curves_boost", 0.0 if not init.get("apply_curves") else 0.20)))
+        self.spin_curves.setValue(float(init.get("curves_boost", 0.0)))
+        self.spin_curves.setEnabled(self.chk_curves.isChecked())
+        self.chk_curves.toggled.connect(self.spin_curves.setEnabled)
+
+        # --- Blackpoint sigma ---
+        self.spin_bp = QDoubleSpinBox()
+        self.spin_bp.setRange(0.0, 1.0)
+        self.spin_bp.setDecimals(2)
+        self.spin_bp.setSingleStep(0.05)
+        self.spin_bp.setValue(float(init.get("blackpoint_sigma", 0.0)))
+
+        self.chk_no_black_clip = QCheckBox("No black clip")
+        self.chk_no_black_clip.setChecked(bool(init.get("no_black_clip", False)))
+
+        # --- HDR compress ---
+        self.chk_hdr = QCheckBox("HDR compression")
+        self.chk_hdr.setChecked(bool(init.get("hdr_compress", False)))
+
+        self.spin_hdr_amt = QDoubleSpinBox()
+        self.spin_hdr_amt.setRange(0.0, 1.0)
+        self.spin_hdr_amt.setDecimals(2)
+        self.spin_hdr_amt.setSingleStep(0.05)
+        self.spin_hdr_amt.setValue(float(init.get("hdr_amount", 0.0)))
+
+        self.spin_hdr_knee = QDoubleSpinBox()
+        self.spin_hdr_knee.setRange(0.0, 1.0)
+        self.spin_hdr_knee.setDecimals(2)
+        self.spin_hdr_knee.setSingleStep(0.05)
+        self.spin_hdr_knee.setValue(float(init.get("hdr_knee", 0.5)))
+
+        def _set_hdr_enabled(on: bool):
+            on = bool(on)
+            self.spin_hdr_amt.setEnabled(on)
+            self.spin_hdr_knee.setEnabled(on)
+
+        _set_hdr_enabled(self.chk_hdr.isChecked())
+        self.chk_hdr.toggled.connect(_set_hdr_enabled)
+
+        # --- Luma only ---
+        self.chk_luma_only = QCheckBox("Luma-only mode")
+        self.chk_luma_only.setChecked(bool(init.get("luma_only", False)))
+
+        self.cmb_luma = QComboBox()
+        # keep in sync with your tool’s supported modes
+        self.cmb_luma.addItems(["rec709", "avg", "hsp", "max"])
+        init_mode = str(init.get("luma_mode", "rec709") or "rec709")
+        idx = self.cmb_luma.findText(init_mode)
+        if idx >= 0:
+            self.cmb_luma.setCurrentIndex(idx)
+
+        self.spin_luma_blend = QDoubleSpinBox()
+        self.spin_luma_blend.setRange(0.0, 1.0)
+        self.spin_luma_blend.setDecimals(2)
+        self.spin_luma_blend.setSingleStep(0.05)
+        self.spin_luma_blend.setValue(float(init.get("luma_blend", 0.70)))
+
+        def _set_luma_enabled(on: bool):
+            on = bool(on)
+            self.cmb_luma.setEnabled(on)
+            self.spin_luma_blend.setEnabled(on)
+
+        _set_luma_enabled(self.chk_luma_only.isChecked())
+        self.chk_luma_only.toggled.connect(_set_luma_enabled)
+
+        # --- Layout ---
+        form = QFormLayout()
 
-        form = QFormLayout(self)
         form.addRow("Target median:", self.spin_target)
         form.addRow("", self.chk_linked)
         form.addRow("", self.chk_normalize)
+
+        form.addRow("", QLabel("— Tone shaping —"))
+        form.addRow("", self.chk_curves)
         form.addRow("Curves boost (0–1):", self.spin_curves)
-        form.addRow(QLabel("Curves are applied only if boost > 0."))
 
-        btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self)
-        btns.accepted.connect(self.accept); btns.rejected.connect(self.reject)
+        form.addRow("", QLabel("— Blackpoint / HDR —"))
+        form.addRow("Blackpoint σ (0–1):", self.spin_bp)
+        form.addRow("", self.chk_no_black_clip)
+
+        form.addRow("", self.chk_hdr)
+        form.addRow("HDR amount (0–1):", self.spin_hdr_amt)
+        form.addRow("HDR knee (0–1):", self.spin_hdr_knee)
+
+        form.addRow("", QLabel("— Luma mode —"))
+        form.addRow("", self.chk_luma_only)
+        form.addRow("Luma mode:", self.cmb_luma)
+        form.addRow("Luma blend (0–1):", self.spin_luma_blend)
+        btns = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            parent=self
+        )
+        btns.accepted.connect(self.accept)
+        btns.rejected.connect(self.reject)
         form.addRow(btns)
 
+        self.setLayout(form)
+
     def result_dict(self) -> dict:
-        boost = float(self.spin_curves.value())
+        hdr_on = bool(self.chk_hdr.isChecked())
+        curves_on = bool(self.chk_curves.isChecked())
+        luma_on = bool(self.chk_luma_only.isChecked())
+
         return {
             "target_median": float(self.spin_target.value()),
             "linked": bool(self.chk_linked.isChecked()),
             "normalize": bool(self.chk_normalize.isChecked()),
-            "apply_curves": bool(boost > 0.0),
-            "curves_boost": boost,
+
+            "apply_curves": curves_on,
+            "curves_boost": float(self.spin_curves.value()) if curves_on else 0.0,
+
+            "blackpoint_sigma": float(self.spin_bp.value()),
+            "no_black_clip": bool(self.chk_no_black_clip.isChecked()),
+
+            "hdr_compress": hdr_on,
+            "hdr_amount": float(self.spin_hdr_amt.value()) if hdr_on else 0.0,
+            "hdr_knee": float(self.spin_hdr_knee.value()) if hdr_on else 0.0,
+
+            "luma_only": luma_on,
+            "luma_mode": str(self.cmb_luma.currentText()) if luma_on else "rec709",
+            "luma_blend": float(self.spin_luma_blend.value()) if luma_on else 0.0,
         }
-    
 
 class _StarStretchPresetDialog(QDialog):
     def __init__(self, parent=None, initial: dict | None = None):
@@ -3041,3 +3218,30 @@ class _RGBAlignPresetDialog(QDialog):
             "new_doc": bool(self.chk_new.isChecked()),
         }
 
+class _GeomRotateAnyPresetDialog(QDialog):
+    def __init__(self, parent=None, initial: dict | None = None):
+        super().__init__(parent)
+        self.setWindowTitle("Arbitrary Rotation — Preset")
+        init = dict(initial or {})
+
+        self.spin_angle = QDoubleSpinBox()
+        self.spin_angle.setRange(-360.0, 360.0)
+        self.spin_angle.setDecimals(2)
+        self.spin_angle.setSingleStep(0.25)
+        self.spin_angle.setValue(float(init.get("angle_deg", init.get("angle", 0.0))))
+
+        form = QFormLayout(self)
+        form.addRow("Angle (degrees):", self.spin_angle)
+
+        btns = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            parent=self
+        )
+        btns.accepted.connect(self.accept)
+        btns.rejected.connect(self.reject)
+        form.addRow(btns)
+
+    def result_dict(self) -> dict:
+        return {
+            "angle_deg": float(self.spin_angle.value()),
+        }