setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/shortcuts.py

@@ -31,6 +31,7 @@ import os  # ← NEW
 SASS_KIND   = "sas.shortcuts"
 SASS_VER    = 1
 
+TOOLBAR_REORDER_MIME = "application/x-saspro-toolbar-reorder"
 # Accept these endings (case-insensitive)
 OPENABLE_ENDINGS = (
     ".png", ".jpg", ".jpeg",
@@ -115,11 +116,7 @@ class DraggableToolBar(QToolBar):
         self._press_had_mod: dict[QToolButton, bool] = {}
         self._suppress_release: set[QToolButton] = set()
         self._settings_key: str | None = None
-
-    # NEW: called by main window / mixin
-    def setSettingsKey(self, key: str):
-        """Set the settings key for persisting toolbar state."""
-        self._settings_key = str(key)
+        self.setAcceptDrops(True)
 
     def _mods_ok(self, mods: Qt.KeyboardModifiers) -> bool:
         return bool(mods & (
@@ -128,6 +125,101 @@ class DraggableToolBar(QToolBar):
             Qt.KeyboardModifier.ShiftModifier
         ))
 
+    # NEW: called by main window / mixin
+    def setSettingsKey(self, key: str):
+        self._settings_key = str(key)
+
+    def _settings(self):
+        mw = self.window()
+        s = getattr(mw, "settings", None)
+        if s is None:
+            from PyQt6.QtCore import QSettings
+            s = QSettings()
+        return s
+
+    def _action_id(self, act: QAction) -> str | None:
+        cid = act.property("command_id") or act.objectName()
+        return str(cid) if cid else None
+
+    def _hidden_key(self) -> str | None:
+        if not self._settings_key:
+            return None
+        return f"{self._settings_key}/Hidden"
+
+    def _load_hidden_set(self) -> set[str]:
+        k = self._hidden_key()
+        if not k:
+            return set()
+        s = self._settings()
+        raw = s.value(k, [], type=list)
+        # QSettings sometimes returns strings instead of list depending on backend
+        if isinstance(raw, str):
+            return {raw}
+        return {str(x) for x in (raw or [])}
+
+    def _save_hidden_set(self, hidden: set[str]):
+        k = self._hidden_key()
+        if not k:
+            return
+        s = self._settings()
+        s.setValue(k, sorted(hidden))
+
+    def _set_action_hidden(self, act: QAction, hide: bool):
+        cid = self._action_id(act)
+        if not cid:
+            return
+        hidden = self._load_hidden_set()
+        if hide:
+            hidden.add(cid)
+            act.setVisible(False)
+        else:
+            hidden.discard(cid)
+            act.setVisible(True)
+        self._save_hidden_set(hidden)
+
+    def apply_hidden_state(self):
+        """Call after toolbar is populated / order restored."""
+        hidden = self._load_hidden_set()
+        if not hidden:
+            return
+        for act in self.actions():
+            cid = self._action_id(act)
+            if cid and cid in hidden:
+                act.setVisible(False)
+
+
+    def _persist_order(self):
+        """Persist current action order (by command_id/objectName) to QSettings."""
+        if not self._settings_key:
+            return
+
+        # Prefer main-window settings if available
+        mw = self.window()
+        s = getattr(mw, "settings", None)
+        if s is None:
+            from PyQt6.QtCore import QSettings
+            s = QSettings()
+
+        ids: list[str] = []
+        for act in self.actions():
+            cid = act.property("command_id") or act.objectName()
+            if cid:
+                ids.append(str(cid))
+
+        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)
@@ -163,32 +255,56 @@ class DraggableToolBar(QToolBar):
                     self._show_toolbutton_context_menu(obj, act, ev.globalPos())
                     return True
                 return False            
+
             # L-press: remember start + whether a drag-modifier was held
             if ev.type() == QEvent.Type.MouseButtonPress and ev.button() == Qt.MouseButton.LeftButton:
                 self._press_pos[obj] = ev.globalPosition().toPoint()
                 self._press_had_mod[obj] = self._mods_ok(QApplication.keyboardModifiers())
                 return False  # allow normal press visuals
 
-            # Move with L held: if (had-mod at press OR has-mod now) AND moved enough → start drag
+            # Move with L held:
             if ev.type() == QEvent.Type.MouseMove and (ev.buttons() & Qt.MouseButton.LeftButton):
                 start = self._press_pos.get(obj)
                 if start is not None:
                     delta = ev.globalPosition().toPoint() - start
-                    if ((self._press_had_mod.get(obj, False) or self._mods_ok(QApplication.keyboardModifiers()))
-                        and delta.manhattanLength() > QApplication.startDragDistance()):
-                        # find the QAction backing this button
-                        act = next((a for a in self.actions() if self.widgetForAction(a) is obj), None)
-                        if act:
-                            self._start_drag_for_action(act)
-                            # eat subsequent release so the action doesn't trigger
+                    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)
+                            if act:
+                                self._start_drag_for_action(act)
+                                self._suppress_release.add(obj)
+                            self._press_pos.pop(obj, None)
+                            self._press_had_mod.pop(obj, None)
+                            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)
-                        # clear press tracking
-                        self._press_pos.pop(obj, None)
-                        self._press_had_mod.pop(obj, None)
-                        return True  # consume the move (prevents click)
+                            self._press_pos.pop(obj, None)
+                            self._press_had_mod.pop(obj, None)
+                            return True  # consume
+
                 return False
 
-            # Release: if we started a drag, swallow the release so click won't fire
+            # Release: if we started any drag, swallow the release so click won't fire
             if ev.type() == QEvent.Type.MouseButtonRelease and ev.button() == Qt.MouseButton.LeftButton:
                 self._press_pos.pop(obj, None)
                 self._press_had_mod.pop(obj, None)
@@ -199,6 +315,7 @@ class DraggableToolBar(QToolBar):
 
         return super().eventFilter(obj, ev)
 
+
     def _start_drag_for_action(self, act: QAction):
         act_id = act.property("command_id") or act.objectName()
         if not act_id:
@@ -235,6 +352,31 @@ class DraggableToolBar(QToolBar):
         drag.setHotSpot(pm.rect().center())
         drag.exec(Qt.DropAction.CopyAction)
 
+    def _start_reorder_drag_for_button(self, btn: QToolButton):
+        """
+        Start a drag whose only purpose is to reorder actions within THIS toolbar.
+        No presets, no desktop shortcuts.
+        """
+        act = self._find_action_for_button(btn)
+        if act is None:
+            return
+
+        md = QMimeData()
+        # Tag this as an internal toolbar-reorder drag
+        md.setData(TOOLBAR_REORDER_MIME, b"1")
+
+        drag = QDrag(btn)
+        drag.setMimeData(md)
+
+        pm = act.icon().pixmap(32, 32) if not act.icon().isNull() else QPixmap(32, 32)
+        if pm.isNull():
+            pm = QPixmap(32, 32)
+            pm.fill(Qt.GlobalColor.darkGray)
+        drag.setPixmap(pm)
+        drag.setHotSpot(pm.rect().center())
+        drag.exec(Qt.DropAction.MoveAction)
+
+
     def _find_action_for_button(self, btn: QToolButton) -> QAction | None:
         # Find the QAction that owns this toolbutton
         for a in self.actions():
@@ -242,6 +384,85 @@ class DraggableToolBar(QToolBar):
                 return a
         return None
 
+    def dragEnterEvent(self, e):
+        # Accept toolbar-reorder drags from any DraggableToolBar
+        if e.mimeData().hasFormat(TOOLBAR_REORDER_MIME):
+            src = e.source()
+            if isinstance(src, QToolButton) and isinstance(src.parent(), DraggableToolBar):
+                e.acceptProposedAction()
+                return
+        super().dragEnterEvent(e)
+
+    def dragMoveEvent(self, e):
+        if e.mimeData().hasFormat(TOOLBAR_REORDER_MIME):
+            src = e.source()
+            if isinstance(src, QToolButton) and isinstance(src.parent(), DraggableToolBar):
+                e.acceptProposedAction()
+                return
+        super().dragMoveEvent(e)
+
+    def dropEvent(self, e):
+        if e.mimeData().hasFormat(TOOLBAR_REORDER_MIME):
+            src_btn = e.source()
+            if isinstance(src_btn, QToolButton):
+                src_tb = src_btn.parent()
+                if isinstance(src_tb, DraggableToolBar):
+                    # Find the QAction that belongs to the dragged button
+                    src_act = src_tb._find_action_for_button(src_btn)
+                    if src_act is None:
+                        e.ignore()
+                        return
+
+                    pos = e.position().toPoint()
+                    target_act = self.actionAt(pos)
+
+                    # Remove from source toolbar and insert into this one
+                    src_tb.removeAction(src_act)
+                    if target_act is None:
+                        self.addAction(src_act)
+                    else:
+                        self.insertAction(target_act, src_act)
+
+                    # Persist order for both toolbars
+                    self._persist_order()
+                    if src_tb is not self:
+                        src_tb._persist_order()
+                        # Also persist the cross-toolbar assignment
+                        self._update_assignment_for_action(src_act)
+
+                    e.acceptProposedAction()
+                    return
+
+        super().dropEvent(e)
+
+
+    def _update_assignment_for_action(self, act: QAction):
+        """
+        Persist that this action now belongs to this toolbar (cross-toolbar move).
+        Stored as: Toolbar/Assignments → JSON {command_id: settings_key}.
+        """
+        if not self._settings_key:
+            return
+
+        cid = act.property("command_id") or act.objectName()
+        if not cid:
+            return
+
+        mw = self.window()
+        s = getattr(mw, "settings", None)
+        if s is None:
+            s = QSettings()
+
+        raw = s.value("Toolbar/Assignments", "", type=str) or ""
+        try:
+            mapping = json.loads(raw) if raw else {}
+        except Exception:
+            mapping = {}
+
+        mapping[str(cid)] = self._settings_key
+        s.setValue("Toolbar/Assignments", json.dumps(mapping))
+
+
     def _add_shortcut_for_action(self, act: QAction):
         # Resolve command id
         act_id = act.property("command_id") or act.objectName()
@@ -265,12 +486,67 @@ 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(self.tr("Hide this icon"), lambda: self._set_action_hidden(act, True))
+
         # (Optional) teach users about Alt+Drag:
         m.addSeparator()
-        m.addAction("Tip: Alt+Drag to create", lambda: None).setEnabled(False)
+        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(self.tr("Show hidden…"))
+
+        # Build list from actions that are currently invisible
+        any_hidden = False
+        for act in self.actions():
+            cid = self._action_id(act)
+            if cid and (cid in hidden) and (not act.isVisible()):
+                any_hidden = True
+                sub.addAction(act.text() or cid, lambda a=act: self._set_action_hidden(a, False))
+
+        if not any_hidden:
+            sub.setEnabled(False)
+
+        m.addSeparator()
+        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())
+
+
 _PRESET_UI_IDS = {
     "stat_stretch","star_stretch","crop","curves","ghs","abe","graxpert",
     "remove_stars","cosmic_clarity","cosmic","cosmicclarity",
@@ -279,7 +555,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:
@@ -312,6 +588,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
@@ -505,18 +787,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())
@@ -528,21 +810,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):
@@ -830,11 +1112,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())
 
 
@@ -2805,3 +3087,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()),
+        }

setiastro/saspro/signature_insert.py

@@ -362,7 +362,10 @@ class SignatureInsertDialogPro(QDialog):
     """
     def __init__(self, parent, doc, icon: QIcon | None = None):
         super().__init__(parent)
-        self.setWindowTitle("Signature / Insert")
+        self.setWindowTitle(self.tr("Signature / Insert"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e: