statable 3.1.0__py3-none-any.whl

statable_gui/role_function_dialog.py

@@ -0,0 +1,244 @@
+"""
+statable_gui/role_function_dialog.py
+Role function create / edit dialog.
+
+Version History
+---------------
+v1.0  - Initial dialog.
+v1.5  - Added namespace field.
+v3.7  - Removed reserved fields from the UI.
+v3.8  - Layout restructured (3 QGroupBox sections).
+v3.9  - Namespace field as editable QComboBox.
+
+[R-7]
+  - Added "+ New Literal" button below the "Used literals" group.
+    Opens NewLiteralDialog, adds the new LiteralDefinition to the
+    shared literal_library, and appends it (pre-checked) to the
+    list widget.
+  - New constructor argument `literal_library=None`. When None, the
+    button is hidden and behavior is unchanged (backward compat).
+"""
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QFormLayout, QLineEdit, QComboBox,
+    QListWidget, QListWidgetItem, QDialogButtonBox, QGroupBox,
+    QPushButton, QMessageBox,
+)
+from PySide6.QtCore import Qt
+
+from statable.model import RoleFunction
+from .logger import StaTableLogger
+
+try:
+    from .literal_definition_dialog import NewLiteralDialog
+except ImportError:
+    from literal_definition_dialog import NewLiteralDialog
+
+
+class RoleFunctionDialog(QDialog):
+    """Dialog for creating / editing role functions."""
+
+    def __init__(self, parent=None, role_function=None,
+                 global_vars=None, events=None, literals=None,
+                 namespace_choices=None,
+                 literal_library=None):
+        super().__init__(parent)
+        self.setWindowTitle(self.tr("Edit role function"))
+        self.setMinimumWidth(500)
+
+        self._original = role_function
+        self._global_vars = list(global_vars or [])
+        self._events = list(events or [])
+        self._literals = list(literals or [])
+        self._namespace_choices = list(namespace_choices or [])
+        # [R-7] shared library for creating new literals
+        self._literal_library = literal_library
+
+        self._setup_ui()
+        self._load_data()
+        StaTableLogger.debug("RoleFunctionDialog initialized")
+
+    # ------------------------------------------------------------------
+    # UI construction
+    # ------------------------------------------------------------------
+    def _setup_ui(self):
+        main_layout = QVBoxLayout(self)
+
+        # ---- Top: form fields ----
+        form = QFormLayout()
+
+        self.name_edit = QLineEdit()
+        form.addRow("Function name:", self.name_edit)
+
+        self.namespace_combo = QComboBox()
+        self.namespace_combo.setEditable(True)
+        self.namespace_combo.setInsertPolicy(QComboBox.NoInsert)
+        self.namespace_combo.addItem(self.tr(""))
+        for ns in self._namespace_choices:
+            if ns and ns != "":
+                self.namespace_combo.addItem(ns)
+        self.namespace_combo.setToolTip(
+            self.tr("Namespace (layer name / feature group name).\n"
+            "If specified, it can be referenced as 'Driver.Init'.\n"
+            "If empty, it is treated as having no layer ('Init').\n"
+            "Select from the list, or type a new value.")
+        )
+        form.addRow("Namespace:", self.namespace_combo)
+
+        self.title_edit = QLineEdit()
+        self.title_edit.setPlaceholderText(
+            self.tr("Label shown in the list (auto-set if empty)"))
+        form.addRow("Display name:", self.title_edit)
+
+        self.desc_edit = QLineEdit()
+        form.addRow("Description:", self.desc_edit)
+
+        main_layout.addLayout(form)
+
+        # ---- Middle: three checkbox groups ----
+        self.global_list = self._make_check_list(
+            main_layout, "Used global variables", self._global_vars)
+        self.event_list = self._make_check_list(
+            main_layout, "Used events", self._events)
+        self.literal_list = self._make_check_list(
+            main_layout, "Used literals (select from existing)",
+            self._literals)
+
+        # [R-7] "+ New Literal" button (only when library available)
+        if self._literal_library is not None:
+            btn_row = QHBoxLayout()
+            btn_row.addStretch()
+            self.new_literal_btn = QPushButton(self.tr("+ New Literal"))
+            self.new_literal_btn.setToolTip(
+                self.tr("Create a new literal and add it to the list above"))
+            self.new_literal_btn.clicked.connect(self._on_new_literal)
+            btn_row.addWidget(self.new_literal_btn)
+            main_layout.addLayout(btn_row)
+
+        # ---- Bottom: buttons ----
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        main_layout.addWidget(buttons)
+
+    @staticmethod
+    def _make_check_list(parent_layout, title, items):
+        group = QGroupBox(title)
+        group_layout = QVBoxLayout(group)
+        lst = QListWidget()
+        lst.setSelectionMode(QListWidget.NoSelection)
+        for text in items:
+            item = QListWidgetItem(text)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Unchecked)
+            lst.addItem(item)
+        group_layout.addWidget(lst)
+        parent_layout.addWidget(group)
+        return lst
+
+    # ------------------------------------------------------------------
+    # Data binding
+    # ------------------------------------------------------------------
+    def _load_data(self):
+        rf = self._original
+        if rf is None:
+            return
+
+        self.name_edit.setText(rf.name)
+        self.title_edit.setText(rf.title)
+        self.desc_edit.setText(rf.description)
+
+        ns = getattr(rf, 'namespace', '') or ''
+        idx = self.namespace_combo.findText(ns)
+        if idx >= 0:
+            self.namespace_combo.setCurrentIndex(idx)
+        else:
+            self.namespace_combo.setEditText(ns)
+
+        self._check_items(
+            self.global_list,
+            getattr(rf, 'used_global_vars', []) or [])
+        self._check_items(
+            self.event_list,
+            getattr(rf, 'used_events', []) or [])
+        self._check_items(
+            self.literal_list,
+            getattr(rf, 'used_literals', []) or [])
+
+    @staticmethod
+    def _check_items(lst, selected):
+        sel = set(selected)
+        for i in range(lst.count()):
+            item = lst.item(i)
+            if item.text() in sel:
+                item.setCheckState(Qt.Checked)
+
+    @staticmethod
+    def _collect_checked(lst):
+        result = []
+        for i in range(lst.count()):
+            item = lst.item(i)
+            if item.checkState() == Qt.Checked:
+                result.append(item.text())
+        return result
+
+    # ------------------------------------------------------------------
+    # [R-7] New literal handler
+    # ------------------------------------------------------------------
+    def _on_new_literal(self):
+        if self._literal_library is None:
+            return
+
+        dlg = NewLiteralDialog(self)
+        if dlg.exec() != QDialog.Accepted:
+            return
+
+        lit = dlg.get_literal()
+        try:
+            self._literal_library.add(lit)
+        except ValueError:
+            QMessageBox.warning(
+                self, self.tr("Warning"),
+                f"A literal named '{lit.name}' already exists.")
+            return
+
+        # Append to the list widget, pre-checked
+        item = QListWidgetItem(lit.name)
+        item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+        item.setCheckState(Qt.Checked)
+        self.literal_list.addItem(item)
+        StaTableLogger.info(f"New literal created: {lit.name}")
+
+    # ------------------------------------------------------------------
+    # OK / Cancel
+    # ------------------------------------------------------------------
+    def _on_accept(self):
+        if not self.title_edit.text().strip():
+            auto_title = (
+                f"Role function: "
+                f"{self.name_edit.text().strip() or '(unnamed)'}")
+            self.title_edit.setText(auto_title)
+        self.accept()
+
+    # ------------------------------------------------------------------
+    # Result
+    # ------------------------------------------------------------------
+    def get_role_function(self) -> RoleFunction:
+        orig = self._original
+        namespace = self.namespace_combo.currentText().strip()
+
+        return RoleFunction(
+            name=self.name_edit.text().strip(),
+            namespace=namespace,
+            description=self.desc_edit.text().strip(),
+            title=self.title_edit.text().strip(),
+            return_type=orig.return_type if orig else "void",
+            arg1_type=orig.arg1_type if orig else "",
+            arg1_name=orig.arg1_name if orig else "",
+            arg2_type=orig.arg2_type if orig else "",
+            arg2_name=orig.arg2_name if orig else "",
+            used_global_vars=self._collect_checked(self.global_list),
+            used_events=self._collect_checked(self.event_list),
+            used_literals=self._collect_checked(self.literal_list),
+        )

statable_gui/sample_data.py

@@ -0,0 +1,11 @@
+"""Sample data generation (GUI layer re-export)"""
+
+from statable.sample_data import (
+    create_sample_state_machine,
+    create_sample_global_defs,
+)
+
+__all__ = [
+    "create_sample_state_machine",
+    "create_sample_global_defs",
+]

statable_gui/state_actions_dialog.py

@@ -0,0 +1,398 @@
+# statable_gui/state_actions_dialog.py
+"""
+State actions (Entry / Exit / Do) editing dialog.
+
+Version: 1.0 (2026-09-26 / Phase 4a)
+
+Provides StateActionsDialog: a 4-tab editor for per-state actions.
+
+Tabs:
+  - Entry:   actions executed once when entering the state
+  - Exit:    actions executed once when leaving the state
+  - Do:      actions executed every loop while in the state
+  - Preview: generated C code preview
+
+Each action tab contains:
+  - Action list (QTableWidget: Type / Target / Condition)
+  - Add / Delete / Up / Down buttons
+  - Custom code marker hint (read-only)
+
+On OK, updates State.entry / State.exit / State.do_actions.
+
+Design notes:
+  - Uses statable.model.ActionStep.
+  - action_type: "role" (default) or "fire_event".
+  - Empty Target rows are dropped on OK.
+  - Custom code editing is done in the generated file
+    (marker: [[STABLE_USER_CODE_START:<Layer>_<Kind>_<State>_custom]]).
+"""
+
+from typing import List, Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem,
+    QPushButton, QDialogButtonBox, QTabWidget, QWidget,
+    QLabel, QGroupBox, QHeaderView, QPlainTextEdit,
+)
+
+from statable.model import State, ActionStep
+from statable.state_machine import StateMachine
+
+from .logger import StaTableLogger
+
+
+KIND_ENTRY = "Entry"
+KIND_EXIT = "Exit"
+KIND_DO = "Do"
+
+
+class _ActionListWidget(QWidget):
+    """Reusable action list editor.
+
+    Columns:
+      0: Type      ("role" or "fire_event")
+      1: Target    (RoleFunc name, or Event name)
+      2: Condition (C expression; empty = unconditional)
+    """
+
+    COL_TYPE = 0
+    COL_TARGET = 1
+    COL_CONDITION = 2
+
+    VALID_TYPES = ("role", "fire_event")
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._setup_ui()
+
+    def _setup_ui(self):
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self.table = QTableWidget(0, 3)
+        self.table.setHorizontalHeaderLabels(["Type", "Target", "Condition"])
+        self.table.horizontalHeader().setSectionResizeMode(
+            self.COL_TYPE, QHeaderView.ResizeToContents)
+        self.table.horizontalHeader().setSectionResizeMode(
+            self.COL_TARGET, QHeaderView.Stretch)
+        self.table.horizontalHeader().setSectionResizeMode(
+            self.COL_CONDITION, QHeaderView.Stretch)
+        self.table.setFont(QFont("Consolas", 10))
+        layout.addWidget(self.table)
+
+        btn_row = QHBoxLayout()
+        self.add_btn = QPushButton(self.tr("+ Add"))
+        self.add_btn.clicked.connect(self._on_add)
+        self.del_btn = QPushButton(self.tr("Delete"))
+        self.del_btn.clicked.connect(self._on_delete)
+        self.up_btn = QPushButton(self.tr("Up"))
+        self.up_btn.clicked.connect(self._on_up)
+        self.down_btn = QPushButton(self.tr("Down"))
+        self.down_btn.clicked.connect(self._on_down)
+        btn_row.addWidget(self.add_btn)
+        btn_row.addWidget(self.del_btn)
+        btn_row.addStretch()
+        btn_row.addWidget(self.up_btn)
+        btn_row.addWidget(self.down_btn)
+        layout.addLayout(btn_row)
+
+    # ------------------------------------------------------------------
+    # Actions
+    # ------------------------------------------------------------------
+    def _on_add(self):
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+        self.table.setItem(row, self.COL_TYPE,
+                           QTableWidgetItem("role"))
+        self.table.setItem(row, self.COL_TARGET,
+                           QTableWidgetItem(""))
+        self.table.setItem(row, self.COL_CONDITION,
+                           QTableWidgetItem(""))
+        self.table.editItem(self.table.item(row, self.COL_TARGET))
+
+    def _on_delete(self):
+        row = self.table.currentRow()
+        if row >= 0:
+            self.table.removeRow(row)
+
+    def _on_up(self):
+        row = self.table.currentRow()
+        if row > 0:
+            self._swap_rows(row, row - 1)
+            self.table.selectRow(row - 1)
+
+    def _on_down(self):
+        row = self.table.currentRow()
+        if 0 <= row < self.table.rowCount() - 1:
+            self._swap_rows(row, row + 1)
+            self.table.selectRow(row + 1)
+
+    def _swap_rows(self, r1: int, r2: int):
+        for col in range(self.table.columnCount()):
+            i1 = self.table.takeItem(r1, col)
+            i2 = self.table.takeItem(r2, col)
+            self.table.setItem(r1, col, i2)
+            self.table.setItem(r2, col, i1)
+
+    # ------------------------------------------------------------------
+    # Data binding
+    # ------------------------------------------------------------------
+    def set_actions(self, actions: List[ActionStep]):
+        """Populate the table from a List[ActionStep]."""
+        self.table.setRowCount(0)
+        for a in (actions or []):
+            row = self.table.rowCount()
+            self.table.insertRow(row)
+
+            atype = (getattr(a, "action_type", "role") or "role")
+            if atype not in self.VALID_TYPES:
+                atype = "role"
+
+            if atype == "fire_event":
+                target = getattr(a, "event_name", "") or ""
+            else:
+                target = getattr(a, "role_function", "") or ""
+
+            cond = getattr(a, "condition", "") or ""
+
+            self.table.setItem(row, self.COL_TYPE,
+                               QTableWidgetItem(atype))
+            self.table.setItem(row, self.COL_TARGET,
+                               QTableWidgetItem(target))
+            self.table.setItem(row, self.COL_CONDITION,
+                               QTableWidgetItem(cond))
+
+    def get_actions(self) -> List[ActionStep]:
+        """Return the current table contents as List[ActionStep]."""
+        result: List[ActionStep] = []
+        for row in range(self.table.rowCount()):
+            type_item = self.table.item(row, self.COL_TYPE)
+            target_item = self.table.item(row, self.COL_TARGET)
+            cond_item = self.table.item(row, self.COL_CONDITION)
+
+            atype = (type_item.text().strip()
+                     if type_item else "role") or "role"
+            if atype not in self.VALID_TYPES:
+                atype = "role"
+            target = target_item.text().strip() if target_item else ""
+            cond = cond_item.text().strip() if cond_item else ""
+
+            if not target:
+                # Empty target rows are dropped
+                continue
+
+            if atype == "fire_event":
+                result.append(ActionStep(
+                    action_type="fire_event",
+                    event_name=target,
+                    condition=cond,
+                ))
+            else:
+                result.append(ActionStep(
+                    action_type="role",
+                    role_function=target,
+                    condition=cond,
+                ))
+        return result
+
+
+class StateActionsDialog(QDialog):
+    """State actions (Entry / Exit / Do) editor.
+
+    [Phase 4a]
+      4 tabs: Entry / Exit / Do / Preview.
+      Each action tab hosts an _ActionListWidget.
+      On OK, updates State.entry / State.exit / State.do_actions.
+    """
+
+    KIND_TO_ATTR = {
+        KIND_ENTRY: "entry",
+        KIND_EXIT: "exit",
+        KIND_DO: "do_actions",
+    }
+
+    @staticmethod
+    def _to_pascal(name: str) -> str:
+        """Convert snake_case / lowerCamelCase to PascalCase."""
+        if not name:
+            return ""
+        # Simple heuristic: capitalize each '_'-separated segment
+        parts = [p for p in name.replace("-", "_").split("_") if p]
+        return "".join(p[:1].upper() + p[1:] for p in parts)
+
+    @classmethod
+    def _rf_call_preview(cls, layer: str, role_function: str) -> str:
+        """Build a preview-only RoleFunc_<NS>_<Name>(NULL, ctx) string."""
+        if not role_function:
+            return ""
+        rf = role_function.strip()
+        if rf.startswith("RoleFunc_"):
+            full = rf
+        elif "." in rf:
+            ns, name = rf.split(".", 1)
+            full = (f"RoleFunc_{cls._to_pascal(ns)}_"
+                    f"{cls._to_pascal(name)}")
+        else:
+            full = (f"RoleFunc_{layer}_{cls._to_pascal(rf)}"
+                    if layer else f"RoleFunc_{cls._to_pascal(rf)}")
+        return f"(void){full}(NULL, ctx)"
+
+    def __init__(self, parent=None, state: Optional[State] = None,
+                 state_machine: Optional[StateMachine] = None):
+        super().__init__(parent)
+        self.state = state
+        self.state_machine = state_machine
+
+        title_state = state.name if state is not None else "(unknown)"
+        self.setWindowTitle(f"State actions - {title_state}")
+        self.setMinimumSize(800, 600)
+
+        self._setup_ui()
+        self._load_state()
+        StaTableLogger.debug(
+            f"StateActionsDialog initialized: state={title_state}")
+
+    # ------------------------------------------------------------------
+    # UI
+    # ------------------------------------------------------------------
+    def _setup_ui(self):
+        layout = QVBoxLayout(self)
+
+        # Info label
+        info = QLabel(
+            self.tr("Entry / Exit / Do actions for this state.\n"
+            "Custom C code can be edited in the generated file "
+            "([[STABLE_USER_CODE_..._custom]] marker).")
+        )
+        info.setWordWrap(True)
+        layout.addWidget(info)
+
+        self.tabs = QTabWidget()
+        layout.addWidget(self.tabs)
+
+        # Entry / Exit / Do tabs
+        self.entry_widget = _ActionListWidget()
+        self.exit_widget = _ActionListWidget()
+        self.do_widget = _ActionListWidget()
+
+        self.tabs.addTab(self.entry_widget, KIND_ENTRY)
+        self.tabs.addTab(self.exit_widget, KIND_EXIT)
+        self.tabs.addTab(self.do_widget, KIND_DO)
+
+        # Preview tab
+        self.preview_widget = QPlainTextEdit()
+        self.preview_widget.setReadOnly(True)
+        self.preview_widget.setFont(QFont("Consolas", 10))
+        self.preview_widget.setPlaceholderText(
+            self.tr("Click 'Refresh' to preview the generated C code."))
+        preview_container = QWidget()
+        preview_layout = QVBoxLayout(preview_container)
+        refresh_btn = QPushButton(self.tr("Refresh preview"))
+        refresh_btn.clicked.connect(self._refresh_preview)
+        preview_layout.addWidget(refresh_btn)
+        preview_layout.addWidget(self.preview_widget)
+        self.tabs.addTab(preview_container, self.tr("Preview"))
+
+        # Buttons
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    # ------------------------------------------------------------------
+    # Data binding
+    # ------------------------------------------------------------------
+    def _load_state(self):
+        if self.state is None:
+            return
+        self.entry_widget.set_actions(
+            list(getattr(self.state, "entry", []) or []))
+        self.exit_widget.set_actions(
+            list(getattr(self.state, "exit", []) or []))
+        self.do_widget.set_actions(
+            list(getattr(self.state, "do_actions", []) or []))
+
+    def _on_accept(self):
+        if self.state is not None:
+            self.state.entry = self.entry_widget.get_actions()
+            self.state.exit = self.exit_widget.get_actions()
+            self.state.do_actions = self.do_widget.get_actions()
+            StaTableLogger.debug(
+                f"StateActionsDialog OK: state={self.state.name}, "
+                f"entry={len(self.state.entry)}, "
+                f"exit={len(self.state.exit)}, "
+                f"do={len(self.state.do_actions)}")
+        self.accept()
+
+    # ------------------------------------------------------------------
+    # Preview
+    # ------------------------------------------------------------------
+    def _refresh_preview(self):
+        """Generate a small preview of what would be emitted for this state."""
+        if self.state is None:
+            self.preview_widget.setPlainText("(no state)")
+            return
+
+        state_name = self.state.name
+        layer = "Layer"
+        if self.state_machine is not None:
+            layer = getattr(self.state_machine, "layer_name", "") or "Layer"
+
+        lines = []
+        for kind, actions in (
+            (KIND_ENTRY, self.entry_widget.get_actions()),
+            (KIND_EXIT, self.exit_widget.get_actions()),
+            (KIND_DO, self.do_widget.get_actions()),
+        ):
+            func_name = f"{layer}_{kind}_{state_name}"
+            marker = f"{layer}_{kind}_{state_name}_custom"
+            lines.append(f"static void {func_name}(SystemContext_t *ctx)")
+            lines.append("{")
+            if actions:
+                lines.append("    /* --- GUI-edited actions (regenerated) --- */")
+                for a in actions:
+                    atype = getattr(a, "action_type", "role") or "role"
+                    cond = (getattr(a, "condition", "") or "").strip()
+                    if atype == "fire_event":
+                        evt = getattr(a, "event_name", "") or ""
+                        # Mirror the codegen: FIRE_EVENT_<Layer>(ctx,
+                        # EVENT_<Layer>_<UPPER_SNAKE>)
+                        if "." in evt:
+                            evt_layer, evt_name = evt.split(".", 1)
+                        else:
+                            evt_layer, evt_name = layer, evt
+                        evt_upper = evt_name.upper().replace(" ", "_")
+                        call = (f"FIRE_EVENT_{evt_layer}(ctx, "
+                                f"EVENT_{evt_layer}_{evt_upper})")
+                    else:
+                        rf = getattr(a, "role_function", "") or ""
+                        call = self._rf_call_preview(layer, rf)
+                    if cond:
+                        lines.append(f"    if ({cond}) {{")
+                        lines.append(f"        {call};")
+                        lines.append("    }")
+                    else:
+                        lines.append(f"    {call};")
+                lines.append("    /* --- end GUI-edited actions --- */")
+            lines.append("")
+            lines.append("    /* --- user custom code (preserved) --- */")
+            lines.append(f"    /* [[STABLE_USER_CODE_START:{marker}]] */")
+            lines.append("    (void)ctx;")
+            lines.append(f"    /* [[STABLE_USER_CODE_END:{marker}]] */")
+            lines.append("}")
+            lines.append("")
+
+        self.preview_widget.setPlainText("\n".join(lines))
+
+
+# ======================================================================
+# Convenience entry point
+# ======================================================================
+def open_state_actions_dialog(parent, state, state_machine):
+    """Open the dialog and return True if the user accepted."""
+    dlg = StateActionsDialog(
+        parent=parent, state=state, state_machine=state_machine)
+    return dlg.exec() == QDialog.Accepted