struct2ui 0.2.0__tar.gz → 0.3.0__tar.gz

{struct2ui-0.2.0/src/struct2ui.egg-info → struct2ui-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct2ui
-Version: 0.2.0
+Version: 0.3.0
 Summary: Render C struct / JSON schema as editable PySide6 UI, export to C/JSON/bin
 Author: Jay
 License: MIT License
@@ -265,6 +265,62 @@ class MyWindow(QtWidgets.QMainWindow):
 | `appearance` | Button appearance overrides, `{key: {'mode': ..., 'icon': ..., 'text': ...}}` |
 | `settings_org` | QSettings organization name, defaults to `'struct2ui'` |
 | `settings_app` | QSettings application name, defaults to `'StructEditor'` |
+| `toolbar_orientation` | Toolbar layout, `'horizontal'` (default) or `'vertical'` |
+| `custom_button_position` | Where `add_custom_button()` drops buttons relative to the built-ins: `'end'` (after, default) or `'start'` (before / far left) |
+
+## Custom Toolbar Buttons
+
+Host applications can add their own buttons to the top path bar via
+`add_custom_button()`. All custom buttons form a single group, separated from
+the built-in buttons by a divider that is added automatically — you only choose
+which side they sit on (once, via the `custom_button_position` constructor arg).
+
+```python
+editor = StructEditor("abc.json", "cfg_t", custom_button_position="end")
+
+def on_send():
+    print(editor.current_values())
+
+btn = editor.add_custom_button(
+    "Send",                 # tooltip / accessible label (shown when no icon)
+    on_send,                # callable invoked on click (no arguments)
+    icon="icons/send.png",  # optional; falls back to text when missing
+    checkable=False,        # optional; make the button toggleable
+)
+# `btn` is the created QPushButton, returned so you can tweak it further.
+```
+
+| Parameter | Description |
+| --- | --- |
+| `text` | Tooltip / accessible label, also shown when no icon is given. **Required.** |
+| `on_click` | Callable invoked on click, takes no arguments. **Required.** |
+| `icon` | Path to an icon file; falls back to `text` when the path is missing/empty. |
+| `checkable` | Make the button toggleable, defaults to `False`. |
+
+Returns the created `QPushButton`.
+
+## Programmatic API
+
+Beyond the UI, `StructEditor` exposes methods to read state and drive exports
+from code (e.g. wired to a custom button):
+
+| Method | Description |
+| --- | --- |
+| `current_values() -> dict` | Live editor values of the active section, keyed by field name (empty dict when no parameter section is shown). |
+| `current_paths() -> dict` | Current `{'modules', 'pipeline', 'elf'}` file paths; an empty string means that slot is unset. |
+| `export_bin(path, show_dialogs=False) -> bool` | Write the current pipeline to a `.bin` at `path` — the programmatic equivalent of clicking Export → Binary. Returns `True` when there are no ELF layout errors (or no ELF is selected), `False` otherwise. |
+
+`export_bin` verifies the ELF layout first when an ELF is selected (the file is
+still written, matching the UI flow). With `show_dialogs=True` it pops the same
+success / ELF-mismatch / failure dialogs the UI shows; with the default
+`show_dialogs=False` no dialogs appear and render/write failures are raised as
+exceptions for the caller to handle.
+
+```python
+paths = editor.current_paths()           # {'modules': ..., 'pipeline': ..., 'elf': ...}
+name = paths['pipeline']                  # derive an output name from the pipeline
+ok = editor.export_bin("out/speech.bin")  # True when ELF layout is clean
+```
 
 ## Export API
 

{struct2ui-0.2.0 → struct2ui-0.3.0}/README.md

@@ -212,6 +212,62 @@ class MyWindow(QtWidgets.QMainWindow):
 | `appearance` | Button appearance overrides, `{key: {'mode': ..., 'icon': ..., 'text': ...}}` |
 | `settings_org` | QSettings organization name, defaults to `'struct2ui'` |
 | `settings_app` | QSettings application name, defaults to `'StructEditor'` |
+| `toolbar_orientation` | Toolbar layout, `'horizontal'` (default) or `'vertical'` |
+| `custom_button_position` | Where `add_custom_button()` drops buttons relative to the built-ins: `'end'` (after, default) or `'start'` (before / far left) |
+
+## Custom Toolbar Buttons
+
+Host applications can add their own buttons to the top path bar via
+`add_custom_button()`. All custom buttons form a single group, separated from
+the built-in buttons by a divider that is added automatically — you only choose
+which side they sit on (once, via the `custom_button_position` constructor arg).
+
+```python
+editor = StructEditor("abc.json", "cfg_t", custom_button_position="end")
+
+def on_send():
+    print(editor.current_values())
+
+btn = editor.add_custom_button(
+    "Send",                 # tooltip / accessible label (shown when no icon)
+    on_send,                # callable invoked on click (no arguments)
+    icon="icons/send.png",  # optional; falls back to text when missing
+    checkable=False,        # optional; make the button toggleable
+)
+# `btn` is the created QPushButton, returned so you can tweak it further.
+```
+
+| Parameter | Description |
+| --- | --- |
+| `text` | Tooltip / accessible label, also shown when no icon is given. **Required.** |
+| `on_click` | Callable invoked on click, takes no arguments. **Required.** |
+| `icon` | Path to an icon file; falls back to `text` when the path is missing/empty. |
+| `checkable` | Make the button toggleable, defaults to `False`. |
+
+Returns the created `QPushButton`.
+
+## Programmatic API
+
+Beyond the UI, `StructEditor` exposes methods to read state and drive exports
+from code (e.g. wired to a custom button):
+
+| Method | Description |
+| --- | --- |
+| `current_values() -> dict` | Live editor values of the active section, keyed by field name (empty dict when no parameter section is shown). |
+| `current_paths() -> dict` | Current `{'modules', 'pipeline', 'elf'}` file paths; an empty string means that slot is unset. |
+| `export_bin(path, show_dialogs=False) -> bool` | Write the current pipeline to a `.bin` at `path` — the programmatic equivalent of clicking Export → Binary. Returns `True` when there are no ELF layout errors (or no ELF is selected), `False` otherwise. |
+
+`export_bin` verifies the ELF layout first when an ELF is selected (the file is
+still written, matching the UI flow). With `show_dialogs=True` it pops the same
+success / ELF-mismatch / failure dialogs the UI shows; with the default
+`show_dialogs=False` no dialogs appear and render/write failures are raised as
+exceptions for the caller to handle.
+
+```python
+paths = editor.current_paths()           # {'modules': ..., 'pipeline': ..., 'elf': ...}
+name = paths['pipeline']                  # derive an output name from the pipeline
+ok = editor.export_bin("out/speech.bin")  # True when ELF layout is clean
+```
 
 ## Export API
 

{struct2ui-0.2.0 → struct2ui-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "struct2ui"
-version = "0.2.0"
+version = "0.3.0"
 description = "Render C struct / JSON schema as editable PySide6 UI, export to C/JSON/bin"
 readme = "README.md"
 requires-python = ">=3.9"

{struct2ui-0.2.0 → struct2ui-0.3.0}/src/struct2ui/__init__.py

@@ -1,4 +1,4 @@
 from .editor import StructEditor
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 __all__ = ["StructEditor"]

{struct2ui-0.2.0 → struct2ui-0.3.0}/src/struct2ui/editor.py

@@ -53,6 +53,12 @@ class _OverflowBar(QtWidgets.QWidget):
         # Buttons in display order; overflow removes them from the right end
         # (end of this list) first.
         self._buttons: list[tuple[QtWidgets.QPushButton, str, object]] = []
+        # Group separators keyed by the button they sit to the LEFT of.
+        # Keying on the button (not its index) keeps the mapping valid when
+        # buttons are prepended/appended. A separator follows its button's
+        # visibility so a collapsed group never leaves a dangling divider, and
+        # the layout itself suppresses any leading divider.
+        self._separators: dict[QtWidgets.QWidget, QtWidgets.QWidget] = {}
 
         self.overflow_btn = QtWidgets.QToolButton(self)
         self.overflow_btn.setText('\u00bb')
@@ -63,11 +69,26 @@ class _OverflowBar(QtWidgets.QWidget):
         self.overflow_btn.hide()
         self._tail: QtWidgets.QWidget = None  # type: ignore[assignment]
 
-    def set_buttons(self, buttons, tail):
-        """buttons: list of (button, overflow_label, callback)."""
+    def _make_separator(self):
+        line = QtWidgets.QFrame(self)
+        line.setFrameShape(QtWidgets.QFrame.VLine)
+        line.setFrameShadow(QtWidgets.QFrame.Sunken)
+        return line
+
+    def set_buttons(self, buttons, tail, separators=None):
+        """buttons: list of (button, overflow_label, callback).
+
+        separators: optional set of button indices that should have a group
+        divider drawn to their left.
+        """
         self._buttons = list(buttons)
         self._tail = tail
-        for btn, _label, _cb in self._buttons:
+        sep_idx = set(separators or ())
+        for idx, (btn, _label, _cb) in enumerate(self._buttons):
+            if idx in sep_idx and idx > 0:
+                sep = self._make_separator()
+                self._separators[btn] = sep
+                self._layout.addWidget(sep)
             self._layout.addWidget(btn)
         self._layout.addStretch(1)
         self._layout.addWidget(self.overflow_btn)
@@ -75,6 +96,51 @@ class _OverflowBar(QtWidgets.QWidget):
             self._layout.addWidget(tail)
         self._relayout()
 
+    def add_button(self, button, overflow_label, callback, separator=False,
+                   at_index=None):
+        """Insert one button into the bar.
+
+        at_index=None (default): append to the end (before overflow/tail).
+        at_index=N: insert at logical button position N (0 = far left).
+
+        separator=True draws a group divider to the LEFT of this button,
+        unless it would land first (no leading divider).
+        """
+        n = len(self._buttons)
+        pos = n if at_index is None else max(0, min(at_index, n))
+        self._buttons.insert(pos, (button, overflow_label, callback))
+
+        # Map logical position to a layout index. The layout holds, in order:
+        # [maybe sep, btn] * n, stretch, overflow, [tail]. We anchor on the
+        # widget currently at logical position `pos`; if that button owns a
+        # divider, anchor on the divider so the new button lands before it
+        # (keeping the divider attached to its original button).
+        if pos < n:
+            anchor = self._buttons[pos + 1][0]
+            anchor_sep = self._separators.get(anchor)
+            anchor_widget = anchor_sep if anchor_sep is not None else anchor
+            layout_at = self._layout.indexOf(anchor_widget)
+        else:
+            layout_at = self._layout.indexOf(self.overflow_btn) - 1
+            layout_at = max(layout_at, 0)
+
+        if separator and pos > 0:
+            sep = self._make_separator()
+            self._separators[button] = sep
+            self._layout.insertWidget(layout_at, sep)
+            layout_at += 1
+        self._layout.insertWidget(layout_at, button)
+        self._relayout()
+
+    def ensure_separator_before(self, button):
+        """Add a group divider to the LEFT of `button` if it lacks one."""
+        if button in self._separators:
+            return
+        sep = self._make_separator()
+        self._separators[button] = sep
+        self._layout.insertWidget(self._layout.indexOf(button), sep)
+        self._relayout()
+
     def minimumSizeHint(self):
         # Report a small minimum so the parent layout can shrink the bar to
         # any width; overflow logic (not the layout) decides what stays.
@@ -117,12 +183,22 @@ class _OverflowBar(QtWidgets.QWidget):
         self.overflow_menu.clear()
         any_hidden = False
         for idx, (btn, label, callback) in enumerate(self._buttons):
+            has_sep = btn in self._separators
             if idx < visible_count:
                 btn.show()
             else:
                 btn.hide()
+                # Carry the group divider into the menu: a collapsed button
+                # that starts a group gets a menu separator before it (never
+                # as the very first menu item).
+                if has_sep and any_hidden:
+                    self.overflow_menu.addSeparator()
                 any_hidden = True
                 self.overflow_menu.addAction(label, callback)
+            if has_sep:
+                # Show the inline divider only when its button stays visible
+                # and is not the first visible item (no leading divider).
+                self._separators[btn].setVisible(0 < idx < visible_count)
         self.overflow_btn.setVisible(any_hidden)
 
 
@@ -159,8 +235,17 @@ class StructEditor(QtWidgets.QWidget):
                  appearance: Dict[str, Dict[str, Any]] = None,
                  settings_org: str = 'struct2ui',
                  settings_app: str = 'StructEditor',
-                 toolbar_orientation: str = 'horizontal'):
+                 toolbar_orientation: str = 'horizontal',
+                 custom_button_position: str = 'end'):
         super().__init__(parent)
+        # Where add_custom_button() drops new buttons relative to the built-in
+        # ones: 'end' (after, default) or 'start' (before / far left).
+        self._custom_button_position = (
+            'start' if custom_button_position == 'start' else 'end')
+        # How many custom buttons have been added; only the first one in the
+        # group draws the dividing line, and 'start' mode keeps them in
+        # add-order by inserting each after the previous custom button.
+        self._custom_button_count = 0
         # Per-button appearance config (for embedding as a standalone module).
         # Shape: {key: {'mode': 'text'|'default'|'custom', 'icon': path,
         # 'text': label}}. Unspecified keys fall back to _BUTTON_DEFAULTS
@@ -317,7 +402,11 @@ class StructEditor(QtWidgets.QWidget):
         ]
 
         bar = _OverflowBar(self)
-        bar.set_buttons(buttons, tail=self.settings_btn)
+        # Group dividers: [sources] | [actions] | [tools]
+        #   sources: Modules, Pipeline, ELF, Reload (0..3)
+        #   actions: Save, Save As, Export          (4..6)
+        #   tools:   C2J, Report                    (7..8)
+        bar.set_buttons(buttons, tail=self.settings_btn, separators={4, 7})
 
         self._refresh_path_tooltips()
         return bar
@@ -367,6 +456,114 @@ class StructEditor(QtWidgets.QWidget):
             btn.setText(text)  # last-resort fallback
         return btn
 
+    # ---- public API: custom buttons ------------------------------------- #
+    def add_custom_button(self, text: str, on_click, icon: str = None,
+                          checkable: bool = False) -> QtWidgets.QPushButton:
+        """Add a custom button to the top path bar.
+
+        text     : tooltip / accessible label (also shown when no icon).
+        on_click : callable invoked on click (no arguments).
+        icon     : optional path to an icon file; falls back to text when the
+                   path is missing or empty.
+        checkable: make the button toggleable.
+
+        Custom buttons form a single group. Their placement relative to the
+        built-in buttons is set once via the ``custom_button_position``
+        constructor argument ('end', default, or 'start'). A divider between
+        the custom group and the built-in buttons is added automatically.
+
+        Returns the created QPushButton so the host can tweak it further.
+        """
+        btn = QtWidgets.QPushButton(self)
+        btn.setToolTip(text)
+        btn.setCheckable(checkable)
+        if icon and os.path.exists(icon):
+            btn.setIcon(QtGui.QIcon(icon))
+        else:
+            btn.setText(text)
+        btn.clicked.connect(lambda _checked=False: on_click())
+
+        # The overflow-menu action reuses the same no-arg callback.
+        menu_cb = lambda: on_click()
+        first = self._custom_button_count == 0
+        if self._custom_button_position == 'start':
+            # Keep add-order at the far left: button N lands at index N.
+            self.path_bar.add_button(
+                btn, text, menu_cb, at_index=self._custom_button_count)
+            if first:
+                # Divide the custom group from the built-ins that follow it.
+                builtin = self.path_bar._buttons[1][0]
+                self.path_bar.ensure_separator_before(builtin)
+        else:
+            # Append; the first custom button starts the trailing group.
+            self.path_bar.add_button(btn, text, menu_cb, separator=first)
+
+        self._custom_button_count += 1
+        return btn
+
+    # ---- public API: programmatic export / paths ------------------------ #
+    def export_bin(self, path: str, show_dialogs: bool = False) -> bool:
+        """Export the current pipeline to a .bin file at ``path``.
+
+        This is the programmatic equivalent of clicking Export and choosing
+        the Binary (*.bin) format. When an ELF is selected its layout is
+        verified first (the file is still written, matching the UI flow).
+
+        path        : destination .bin file path.
+        show_dialogs : when True, behaves like clicking Export: success, ELF
+                       mismatch and failure all pop the same QMessageBox the UI
+                       shows (and a mismatch jumps to the Report panel). When
+                       False (default) no dialogs appear and errors are raised
+                       as exceptions for the caller to handle.
+
+        Returns True when the export has no ELF layout errors (or no ELF is
+        selected), False when ELF layout errors were detected.
+
+        Raises on render or write failure when show_dialogs is False.
+        """
+        elf_ok = True
+        if self.elf_path:
+            self._verify_elf()
+            elf_ok = not (self._elf_report is not None and
+                          self._elf_report.has_errors)
+
+        try:
+            content = self._render_export('bin')
+            with open(path, 'wb') as f:
+                f.write(content)
+        except Exception as exc:
+            if show_dialogs:
+                QtWidgets.QMessageBox.critical(
+                    self, 'Export failed', f'Could not export {path}:\n{exc}')
+                return False
+            raise
+
+        if show_dialogs:
+            if not elf_ok:
+                n = len(self._elf_report.errors)
+                self._show_report()
+                QtWidgets.QMessageBox.warning(
+                    self, 'Exported with ELF mismatch',
+                    f'Exported (bin) to:\n{path}\n\n'
+                    f'WARNING: {n} ELF layout error'
+                    f"{'s' if n != 1 else ''} detected. See the Report panel.")
+            else:
+                QtWidgets.QMessageBox.information(
+                    self, 'Exported', f'Exported (bin) to:\n{path}')
+
+        return elf_ok
+
+    def current_paths(self) -> Dict[str, str]:
+        """Return the current Modules / Pipeline / ELF file paths.
+
+        Empty strings mean nothing is selected for that slot.
+        """
+        return {
+            'modules': self.struct_dir,
+            'pipeline': self.speech_path,
+            'elf': self.elf_path,
+        }
+
     def _refresh_path_tooltips(self) -> None:
         modules_text = self._appearance.get('modules', {}).get('text', 'Modules')
         pipeline_text = self._appearance.get('pipeline', {}).get('text', 'Pipeline')

{struct2ui-0.2.0 → struct2ui-0.3.0}/src/struct2ui/ui/widgets.py

@@ -50,6 +50,42 @@ _CHANGE_SIGNALS: Dict[type, str] = {
 }
 
 
+# Widget types whose value changes on mouse wheel; we only allow that while
+# the widget has focus (i.e. it is "selected").
+_WHEEL_GUARDED = (
+    QtWidgets.QAbstractSpinBox,
+    QtWidgets.QSlider,
+    QtWidgets.QDial,
+)
+
+
+class _WheelGuard(QtCore.QObject):
+    """Event filter: swallow wheel events unless the widget has focus.
+
+    Lets the user scroll the page over a numeric editor without accidentally
+    changing its value; the value only reacts to the wheel once the editor is
+    focused (clicked/tab-selected). The unfocused wheel event is re-posted to
+    the parent so the surrounding scroll area still scrolls.
+    """
+
+    def eventFilter(self, obj: QtCore.QObject, ev: QtCore.QEvent) -> bool:
+        if ev.type() == QtCore.QEvent.Wheel and not obj.hasFocus():
+            ev.ignore()
+            return True
+        return super().eventFilter(obj, ev)
+
+
+_WHEEL_GUARD = _WheelGuard()
+
+
+def _install_wheel_guard(w: QtWidgets.QWidget) -> None:
+    """Apply the focus-only-wheel policy to a value editor (and inner slider)."""
+    target = getattr(w, 'slider', w)
+    if isinstance(target, _WHEEL_GUARDED):
+        target.setFocusPolicy(QtCore.Qt.StrongFocus)
+        target.installEventFilter(_WHEEL_GUARD)
+
+
 def _lookup(mapping: Dict[type, Any], w: QtWidgets.QWidget) -> Any:
     """Find a mapping entry honouring isinstance (so subclasses are matched).
 
@@ -75,6 +111,12 @@ class WidgetFactory:
 
     @staticmethod
     def build(f: Field, value: Any) -> QtWidgets.QWidget:
+        w = WidgetFactory._build(f, value)
+        _install_wheel_guard(w)
+        return w
+
+    @staticmethod
+    def _build(f: Field, value: Any) -> QtWidgets.QWidget:
         if isinstance(f, ArrayField):
             return _build_array_value(f, value)
         if isinstance(f, EnumField):

{struct2ui-0.2.0 → struct2ui-0.3.0/src/struct2ui.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct2ui
-Version: 0.2.0
+Version: 0.3.0
 Summary: Render C struct / JSON schema as editable PySide6 UI, export to C/JSON/bin
 Author: Jay
 License: MIT License
@@ -265,6 +265,62 @@ class MyWindow(QtWidgets.QMainWindow):
 | `appearance` | Button appearance overrides, `{key: {'mode': ..., 'icon': ..., 'text': ...}}` |
 | `settings_org` | QSettings organization name, defaults to `'struct2ui'` |
 | `settings_app` | QSettings application name, defaults to `'StructEditor'` |
+| `toolbar_orientation` | Toolbar layout, `'horizontal'` (default) or `'vertical'` |
+| `custom_button_position` | Where `add_custom_button()` drops buttons relative to the built-ins: `'end'` (after, default) or `'start'` (before / far left) |
+
+## Custom Toolbar Buttons
+
+Host applications can add their own buttons to the top path bar via
+`add_custom_button()`. All custom buttons form a single group, separated from
+the built-in buttons by a divider that is added automatically — you only choose
+which side they sit on (once, via the `custom_button_position` constructor arg).
+
+```python
+editor = StructEditor("abc.json", "cfg_t", custom_button_position="end")
+
+def on_send():
+    print(editor.current_values())
+
+btn = editor.add_custom_button(
+    "Send",                 # tooltip / accessible label (shown when no icon)
+    on_send,                # callable invoked on click (no arguments)
+    icon="icons/send.png",  # optional; falls back to text when missing
+    checkable=False,        # optional; make the button toggleable
+)
+# `btn` is the created QPushButton, returned so you can tweak it further.
+```
+
+| Parameter | Description |
+| --- | --- |
+| `text` | Tooltip / accessible label, also shown when no icon is given. **Required.** |
+| `on_click` | Callable invoked on click, takes no arguments. **Required.** |
+| `icon` | Path to an icon file; falls back to `text` when the path is missing/empty. |
+| `checkable` | Make the button toggleable, defaults to `False`. |
+
+Returns the created `QPushButton`.
+
+## Programmatic API
+
+Beyond the UI, `StructEditor` exposes methods to read state and drive exports
+from code (e.g. wired to a custom button):
+
+| Method | Description |
+| --- | --- |
+| `current_values() -> dict` | Live editor values of the active section, keyed by field name (empty dict when no parameter section is shown). |
+| `current_paths() -> dict` | Current `{'modules', 'pipeline', 'elf'}` file paths; an empty string means that slot is unset. |
+| `export_bin(path, show_dialogs=False) -> bool` | Write the current pipeline to a `.bin` at `path` — the programmatic equivalent of clicking Export → Binary. Returns `True` when there are no ELF layout errors (or no ELF is selected), `False` otherwise. |
+
+`export_bin` verifies the ELF layout first when an ELF is selected (the file is
+still written, matching the UI flow). With `show_dialogs=True` it pops the same
+success / ELF-mismatch / failure dialogs the UI shows; with the default
+`show_dialogs=False` no dialogs appear and render/write failures are raised as
+exceptions for the caller to handle.
+
+```python
+paths = editor.current_paths()           # {'modules': ..., 'pipeline': ..., 'elf': ...}
+name = paths['pipeline']                  # derive an output name from the pipeline
+ok = editor.export_bin("out/speech.bin")  # True when ELF layout is clean
+```
 
 ## Export API
 

{struct2ui-0.2.0 → struct2ui-0.3.0}/tests/test_editor.py

@@ -20,6 +20,110 @@ def test_defaults_to_empty_when_no_args(qapp):
     assert w.elf_path == ''
 
 
+def test_add_custom_button_appends_and_invokes_handler(qapp):
+    w = StructEditor()
+    calls = []
+    btn = w.add_custom_button('My Action', lambda: calls.append(1))
+
+    assert isinstance(btn, QtWidgets.QPushButton)
+    assert btn.toolTip() == 'My Action'
+    assert (btn, 'My Action') in [(b, lbl) for b, lbl, _ in w.path_bar._buttons]
+
+    btn.click()
+    assert calls == [1]
+
+
+def test_add_custom_button_checkable(qapp):
+    w = StructEditor()
+    btn = w.add_custom_button('Toggle', lambda: None, checkable=True)
+    assert btn.isCheckable()
+
+
+def _button_index(bar, btn):
+    return [b for b, _, _ in bar._buttons].index(btn)
+
+
+def test_path_bar_has_group_separators(qapp, real_cfg_dir, real_flow):
+    w = StructEditor(real_flow, real_cfg_dir)
+    bar = w.path_bar
+    # Two built-in group dividers, sitting before buttons at index 4 and 7.
+    # First group is [Modules, Pipeline, ELF, Reload].
+    sep_indices = sorted(_button_index(bar, b) for b in bar._separators)
+    assert sep_indices == [4, 7]
+
+
+def test_custom_button_first_starts_group(qapp):
+    w = StructEditor()
+    btn = w.add_custom_button('First', lambda: None)
+    assert btn in w.path_bar._separators
+
+
+def test_custom_buttons_share_one_group(qapp):
+    w = StructEditor()
+    first = w.add_custom_button('First', lambda: None)
+    second = w.add_custom_button('Second', lambda: None)
+    # Only the first custom button carries the dividing line.
+    assert first in w.path_bar._separators
+    assert second not in w.path_bar._separators
+
+
+def test_custom_button_position_start(qapp):
+    w = StructEditor(custom_button_position='start')
+    first = w.add_custom_button('First', lambda: None)
+    second = w.add_custom_button('Second', lambda: None)
+    bar = w.path_bar
+    labels = [lbl for _, lbl, _ in bar._buttons]
+    # Custom buttons lead, in add-order, before the built-ins.
+    assert labels[:2] == ['First', 'Second']
+    # The custom group has no leading divider; the divider sits right after
+    # the last custom button, i.e. before the first built-in (Modules).
+    assert first not in bar._separators
+    assert second not in bar._separators
+    modules_btn = bar._buttons[2][0]
+    assert modules_btn is w.cfg_btn
+    assert modules_btn in bar._separators
+
+    # Verify the *visual* order in the layout: First, Second, divider, Modules.
+    sep = bar._separators[modules_btn]
+    i_first = bar._layout.indexOf(first)
+    i_second = bar._layout.indexOf(second)
+    i_sep = bar._layout.indexOf(sep)
+    i_modules = bar._layout.indexOf(modules_btn)
+    assert i_first < i_second < i_sep < i_modules
+
+
+def test_separator_hidden_when_its_button_overflows(qapp):
+    w = StructEditor()
+    btn = w.add_custom_button('First', lambda: None)
+    bar = w.path_bar
+    sep = bar._separators[btn]
+
+    bar.resize(4000, 40)
+    bar._relayout()
+    assert not sep.isHidden()
+
+    bar.resize(40, 40)
+    bar._relayout()
+    assert sep.isHidden()
+
+
+def test_overflow_menu_carries_group_separators(qapp, real_cfg_dir, real_flow):
+    w = StructEditor(real_flow, real_cfg_dir)
+    bar = w.path_bar
+    bar.resize(40, 40)
+    bar._relayout()
+
+    acts = bar.overflow_menu.actions()
+    # Everything overflowed; menu mirrors the inline grouping.
+    assert not acts[0].isSeparator()
+    sep_positions = [i for i, a in enumerate(acts) if a.isSeparator()]
+    labels = [a.text() for a in acts if not a.isSeparator()]
+    assert labels == ['Modules', 'Pipeline', 'ELF', 'Reload',
+                      'Save', 'Save As', 'Export', 'C2J', 'Report']
+    # Two group dividers (sources|actions and actions|tools).
+    assert len(sep_positions) == 2
+
+
 def test_reload_does_not_persist_paths(qapp, real_cfg_dir, real_flow):
     w = StructEditor(real_flow, real_cfg_dir)
 

{struct2ui-0.2.0 → struct2ui-0.3.0}/tests/test_save.py

@@ -192,3 +192,58 @@ def test_pick_elf_cancel_keeps_state(qapp, real_cfg_dir, flow_copy, monkeypatch)
     w._pick_elf_file()
 
     assert w.elf_path == ''
+
+
+def test_export_bin_api_writes_file(qapp, real_cfg_dir, flow_copy, tmp_path):
+    w = StructEditor(flow_copy, real_cfg_dir)
+    target = str(tmp_path / 'api.bin')
+
+    result = w.export_bin(target)
+
+    assert result is True
+    assert os.path.exists(target)
+    assert len(open(target, 'rb').read()) > 0
+
+
+def test_export_bin_api_raises_on_bad_path(qapp, real_cfg_dir, flow_copy,
+                                           tmp_path):
+    w = StructEditor(flow_copy, real_cfg_dir)
+    bad = str(tmp_path / 'no_such_dir' / 'api.bin')
+
+    with pytest.raises(Exception):
+        w.export_bin(bad)
+
+
+def test_export_bin_api_dialog_swallows_error(qapp, real_cfg_dir, flow_copy,
+                                              tmp_path, monkeypatch):
+    w = StructEditor(flow_copy, real_cfg_dir)
+    bad = str(tmp_path / 'no_such_dir' / 'api.bin')
+    monkeypatch.setattr(
+        QtWidgets.QMessageBox, 'critical', lambda *a, **k: None)
+
+    assert w.export_bin(bad, show_dialogs=True) is False
+
+
+def test_export_bin_api_dialog_on_success(qapp, real_cfg_dir, flow_copy,
+                                          tmp_path, monkeypatch):
+    w = StructEditor(flow_copy, real_cfg_dir)
+    target = str(tmp_path / 'api.bin')
+    shown = []
+    monkeypatch.setattr(
+        QtWidgets.QMessageBox, 'information',
+        lambda *a, **k: shown.append(a))
+
+    result = w.export_bin(target, show_dialogs=True)
+
+    assert result is True
+    assert os.path.exists(target)
+    # Success pops the same information dialog as clicking Export.
+    assert len(shown) == 1
+
+
+def test_current_paths_api(qapp, real_cfg_dir, flow_copy):
+    w = StructEditor(flow_copy, real_cfg_dir)
+    paths = w.current_paths()
+    assert paths['modules'] == real_cfg_dir
+    assert paths['pipeline'] == flow_copy
+    assert paths['elf'] == ''