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

setiastro/saspro/shortcuts.py

@@ -493,7 +493,8 @@ class DraggableToolBar(QToolBar):
         cid = self._action_id(act)
         if cid:
             m.addSeparator()
-            m.addAction(self.tr("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()
@@ -502,7 +503,6 @@ class DraggableToolBar(QToolBar):
 
         m.exec(gpos)
 
-
     def contextMenuEvent(self, ev):
         # Right-click on empty toolbar area
         m = QMenu(self)
@@ -512,25 +512,29 @@ class DraggableToolBar(QToolBar):
         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(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():
+                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)
@@ -538,13 +542,25 @@ class DraggableToolBar(QToolBar):
         m.addSeparator()
         m.addAction(self.tr("Reset hidden icons"), self._reset_hidden_icons)
 
+        # ✅ NEW: Factory reset for all toolbars
+        m.addSeparator()
+        reset_all = m.addAction(self.tr("Reset ALL Toolbars (Factory Layout)"))
+        reset_all.setStatusTip(self.tr("Clears saved toolbar positions/orders/hidden state and restores defaults"))
+        reset_all.triggered.connect(lambda: getattr(self.window(), "_reset_all_toolbars_to_factory", lambda: None)())
+
         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 = {
@@ -1024,17 +1040,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()
@@ -1536,6 +1549,7 @@ class ShortcutManager:
 
     # ---- persistence (QSettings JSON blob) ----
     def save_shortcuts(self):
+       
         data = []
         for sid, w in list(self.widgets.items()):
             if _is_dead(w):
@@ -1836,6 +1850,7 @@ class ShortcutManager:
 
 
     def clear(self):
+      
         for sid, w in list(self.widgets.items()):
             try:
                 if not _is_dead(w):
@@ -1910,50 +1925,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):