statable 3.1.0__py3-none-any.whl

statable_gui/transition_editor_direct/relations_edit_dialog.py

@@ -0,0 +1,156 @@
+# statable_gui/transition_editor_direct/relations_edit_dialog.py
+"""Dialog to edit one TransitionRelation (v2.2).
+
+[v2.2 enhancement]
+  - Members list shows each transition as "T1: cond_A -> Active"
+    so the user can identify which label belongs to which condition.
+"""
+
+import logging
+from typing import List, Optional, Dict
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox,
+    QLineEdit, QListWidget, QListWidgetItem, QDialogButtonBox,
+    QGroupBox, QMessageBox,
+)
+
+from statable.model import TransitionRelation
+
+logger = logging.getLogger("transition_editor_direct.relations_edit_dialog")
+
+KIND_CHOICES = ["sequential", "exclusive", "group"]
+
+
+def _fmt_member(label: str, detail: str) -> str:
+    """Format a member list entry: 'T1: cond_A -> Active'."""
+    if detail:
+        return f"{label}: {detail}"
+    return label
+
+
+class RelationsEditDialog(QDialog):
+    """Edit a single relation (kind / members / shared_condition)."""
+
+    def __init__(self, parent=None,
+                 relation: Optional[TransitionRelation] = None,
+                 available_labels: Optional[List[str]] = None,
+                 member_details: Optional[Dict[str, str]] = None):
+        """
+        Args:
+            relation: existing relation (None for new)
+            available_labels: list of Transition labels in this cell
+            member_details: {label: "cond_A -> Active"} for display
+        """
+        super().__init__(parent)
+        self.setWindowTitle(self.tr("Edit relation"))
+        self.setMinimumSize(600, 500)
+
+        self.available_labels = list(available_labels or [])
+        self.member_details = dict(member_details or {})
+
+        layout = QVBoxLayout(self)
+
+        # ---- Kind ----
+        kind_layout = QHBoxLayout()
+        kind_layout.addWidget(QLabel(self.tr("Kind:")))
+        self.kind_combo = QComboBox()
+        self.kind_combo.addItems(KIND_CHOICES)
+        kind_layout.addWidget(self.kind_combo)
+        kind_layout.addStretch()
+        layout.addLayout(kind_layout)
+
+        # ---- Members (checkbox list with condition/target) ----
+        members_group = QGroupBox(self.tr("Members (Transition labels)"))
+        members_layout = QVBoxLayout(members_group)
+        self.members_list = QListWidget()
+        for lbl in self.available_labels:
+            detail = self.member_details.get(lbl, "")
+            text = _fmt_member(lbl, detail)
+            item = QListWidgetItem(text)
+            item.setData(Qt.UserRole, lbl)   # store the raw label
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Unchecked)
+            if detail:
+                item.setToolTip(f"{lbl}\n{detail}")
+            self.members_list.addItem(item)
+        members_layout.addWidget(self.members_list)
+
+        if not self.available_labels:
+            hint = QLabel(
+                self.tr("No transitions defined in this cell. "
+                "Add transitions first."))
+            hint.setStyleSheet("color: #a00;")
+            members_layout.addWidget(hint)
+        layout.addWidget(members_group)
+
+        # ---- Shared condition ----
+        cond_group = QGroupBox(self.tr("Shared condition (used when kind = group)"))
+        cond_layout = QVBoxLayout(cond_group)
+        self.shared_edit = QLineEdit()
+        self.shared_edit.setPlaceholderText(self.tr("e.g. cond_A"))
+        cond_layout.addWidget(self.shared_edit)
+        layout.addWidget(cond_group)
+
+        # ---- Note ----
+        note_layout = QHBoxLayout()
+        note_layout.addWidget(QLabel(self.tr("Note:")))
+        self.note_edit = QLineEdit()
+        note_layout.addWidget(self.note_edit)
+        layout.addLayout(note_layout)
+
+        # ---- OK / Cancel ----
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+        # Load
+        if relation is not None:
+            self._load(relation)
+
+    def _load(self, relation: TransitionRelation):
+        kind = relation.kind if relation.kind in KIND_CHOICES else "sequential"
+        self.kind_combo.setCurrentText(kind)
+        self.shared_edit.setText(relation.shared_condition or "")
+        self.note_edit.setText(relation.note or "")
+
+        selected = set(relation.members or [])
+        for i in range(self.members_list.count()):
+            item = self.members_list.item(i)
+            raw_label = item.data(Qt.UserRole) or item.text()
+            if raw_label in selected:
+                item.setCheckState(Qt.Checked)
+
+    def _on_accept(self):
+        members = self.get_members()
+        kind = self.kind_combo.currentText()
+        if kind == "group" and not members:
+            QMessageBox.warning(
+                self, self.tr("Warning"),
+                self.tr("A group relation requires at least one member."))
+            return
+        self.accept()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def get_members(self) -> List[str]:
+        """Return only the raw labels (T1, T2, ...)."""
+        result = []
+        for i in range(self.members_list.count()):
+            item = self.members_list.item(i)
+            if item.checkState() == Qt.Checked:
+                label = item.data(Qt.UserRole) or item.text()
+                result.append(label)
+        return result
+
+    def get_relation(self) -> TransitionRelation:
+        return TransitionRelation(
+            kind=self.kind_combo.currentText(),
+            members=self.get_members(),
+            shared_condition=self.shared_edit.text().strip(),
+            note=self.note_edit.text().strip(),
+        )

statable_gui/transition_editor_direct/relations_tab.py

@@ -0,0 +1,230 @@
+# statable_gui/transition_editor_direct/relations_tab.py
+"""Relations tab widget (v2.2).
+
+Sequential / Exclusive / Group relations between transitions.
+Editing is done via RelationsEditDialog.
+
+[v2.2 enhancement]
+  - Members list shows "T1: cond_A -> Active" so labels are identifiable.
+  - set_transitions() lets the dialog pass transition details.
+
+[v2.3.1 fix]
+  - Add setEditTriggers(NoEditTriggers) to prevent inline edit from
+    swallowing subsequent double-clicks. Same fix as transitions_tab.py.
+"""
+
+import logging
+from typing import List, Optional, Dict
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem,
+    QPushButton, QHeaderView, QAbstractItemView, QLabel, QMessageBox,
+)
+
+from statable.model import TransitionRelation
+from .draft import ActionDraft
+from .relations_edit_dialog import RelationsEditDialog
+
+logger = logging.getLogger("transition_editor_direct.relations_tab")
+
+COL_KIND = 0
+COL_MEMBERS = 1
+COL_SHARED = 2
+COL_NOTE = 3
+COLUMN_COUNT = 4
+
+
+class RelationsTab(QWidget):
+    """Relations tab."""
+
+    relations_changed = Signal()
+
+    def __init__(self, draft: ActionDraft, parent=None):
+        super().__init__(parent)
+        self.draft = draft
+        # v2.2: {label: "cond_A -> Active"} populated by set_transitions()
+        self.member_details: Dict[str, str] = {}
+        self._build_ui()
+
+    def _build_ui(self):
+        layout = QVBoxLayout(self)
+
+        info = QLabel(
+            self.tr("Relations between transitions in this cell.\n"
+            "  sequential: evaluate members in order\n"
+            "  exclusive : at most one fires\n"
+            "  group     : hoists shared_condition as outer if"))
+        layout.addWidget(info)
+
+        self.table = QTableWidget(0, COLUMN_COUNT)
+        self.table.setHorizontalHeaderLabels(
+            ["Kind", "Members", "Shared condition", "Note"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table.setSelectionMode(QAbstractItemView.SingleSelection)
+        # [v2.3.1 fix] Disable inline editing so that double-click always
+        #              triggers the edit dialog.
+        self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
+        self.table.cellDoubleClicked.connect(self._on_double_click)
+        layout.addWidget(self.table)
+
+        btn_layout = QHBoxLayout()
+        add_btn = QPushButton(self.tr("+ Add"))
+        add_btn.clicked.connect(lambda: self._add())
+        edit_btn = QPushButton(self.tr("Edit..."))
+        edit_btn.clicked.connect(lambda: self._edit(self.table.currentRow()))
+        del_btn = QPushButton(self.tr("Delete"))
+        del_btn.clicked.connect(lambda: self.delete_relation(
+            self.table.currentRow()))
+
+        btn_layout.addWidget(add_btn)
+        btn_layout.addWidget(edit_btn)
+        btn_layout.addWidget(del_btn)
+        btn_layout.addStretch()
+        layout.addLayout(btn_layout)
+
+    # ------------------------------------------------------------------
+    # Member details (called by dialog.py)
+    # ------------------------------------------------------------------
+    def set_member_details(self, details: Dict[str, str]):
+        """Update the {label: 'cond -> target'} map.
+
+        Called by ActionEditorDialog whenever transitions change.
+        """
+        self.member_details = dict(details or {})
+
+    # ------------------------------------------------------------------
+    # Available labels (from current cell's transitions)
+    # ------------------------------------------------------------------
+    def _get_available_labels(self) -> List[str]:
+        labels = []
+        for item in self.draft.flow_items:
+            if item.item_type == "transition":
+                lbl = item.params.get("label", "")
+                if lbl:
+                    labels.append(lbl)
+        return labels
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def row_count(self) -> int:
+        return self.table.rowCount()
+
+    def _make_item(self, text: str) -> QTableWidgetItem:
+        """Create a non-editable table item."""
+        item = QTableWidgetItem(text)
+        item.setFlags(item.flags() & ~Qt.ItemIsEditable)
+        return item
+
+    def add_relation(self, relation: Optional[TransitionRelation] = None) -> int:
+        """Add a relation. If relation is None, opens the edit dialog first."""
+        if relation is None:
+            available = self._get_available_labels()
+            if not available:
+                QMessageBox.warning(
+                    self, self.tr("Warning"),
+                    self.tr("No transitions defined in this cell.\n"
+                    "Add transitions first."))
+                return -1
+            dlg = RelationsEditDialog(
+                parent=self,
+                relation=None,
+                available_labels=available,
+                member_details=self.member_details,
+            )
+            if dlg.exec() != RelationsEditDialog.Accepted:
+                return -1
+            relation = dlg.get_relation()
+
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+
+        self.table.setItem(row, COL_KIND, self._make_item(relation.kind))
+        self.table.setItem(row, COL_MEMBERS,
+                           self._make_item(", ".join(relation.members)))
+        self.table.setItem(row, COL_SHARED,
+                           self._make_item(relation.shared_condition))
+        self.table.setItem(row, COL_NOTE, self._make_item(relation.note))
+
+        self.relations_changed.emit()
+        return row
+
+    def delete_relation(self, row: int) -> None:
+        if 0 <= row < self.table.rowCount():
+            self.table.removeRow(row)
+            self.relations_changed.emit()
+
+    def get_relations(self) -> List[TransitionRelation]:
+        result = []
+        for row in range(self.table.rowCount()):
+            def _txt(col: int) -> str:
+                it = self.table.item(row, col)
+                return it.text().strip() if it else ""
+
+            members = [m.strip() for m in _txt(COL_MEMBERS).split(",")
+                       if m.strip()]
+            result.append(TransitionRelation(
+                kind=_txt(COL_KIND) or "sequential",
+                members=members,
+                shared_condition=_txt(COL_SHARED),
+                note=_txt(COL_NOTE),
+            ))
+        return result
+
+    def set_relations(self, relations: List[TransitionRelation]) -> None:
+        self.table.setRowCount(0)
+        for r in relations:
+            row = self.table.rowCount()
+            self.table.insertRow(row)
+            self.table.setItem(row, COL_KIND, self._make_item(r.kind))
+            self.table.setItem(row, COL_MEMBERS,
+                               self._make_item(", ".join(r.members)))
+            self.table.setItem(row, COL_SHARED,
+                               self._make_item(r.shared_condition))
+            self.table.setItem(row, COL_NOTE, self._make_item(r.note))
+
+    # ------------------------------------------------------------------
+    # Slots
+    # ------------------------------------------------------------------
+    def _on_double_click(self, row: int, col: int):
+        self._edit(row)
+
+    def _add(self):
+        self.add_relation(None)
+
+    def _edit(self, row: int):
+        if row < 0 or row >= self.table.rowCount():
+            return
+
+        def _txt(col: int) -> str:
+            it = self.table.item(row, col)
+            return it.text().strip() if it else ""
+
+        current = TransitionRelation(
+            kind=_txt(COL_KIND) or "sequential",
+            members=[m.strip() for m in _txt(COL_MEMBERS).split(",")
+                     if m.strip()],
+            shared_condition=_txt(COL_SHARED),
+            note=_txt(COL_NOTE),
+        )
+
+        available = self._get_available_labels()
+        dlg = RelationsEditDialog(
+            parent=self,
+            relation=current,
+            available_labels=available,
+            member_details=self.member_details,
+        )
+        if dlg.exec() != RelationsEditDialog.Accepted:
+            return
+
+        new_r = dlg.get_relation()
+        self.table.setItem(row, COL_KIND, self._make_item(new_r.kind))
+        self.table.setItem(row, COL_MEMBERS,
+                           self._make_item(", ".join(new_r.members)))
+        self.table.setItem(row, COL_SHARED,
+                           self._make_item(new_r.shared_condition))
+        self.table.setItem(row, COL_NOTE, self._make_item(new_r.note))
+        self.relations_changed.emit()

statable_gui/transition_editor_direct/system_global_dialog.py

@@ -0,0 +1,52 @@
+# statable_gui/transition_editor_direct/system_global_dialog.py
+"""
+System global variables (separate screen)
+"""
+
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QListWidget, QInputDialog
+
+from .draft import SystemGlobal
+
+
+class SystemGlobalDialog(QDialog):
+    def __init__(self, draft, parent=None):
+        super().__init__(parent)
+        self.draft = draft
+        self.setWindowTitle(self.tr("System global variables"))
+        self.setMinimumSize(400, 300)
+
+        layout = QVBoxLayout(self)
+        self.list_widget = QListWidget()
+        layout.addWidget(self.list_widget)
+
+        btn_layout = QHBoxLayout()
+        add_btn = QPushButton(self.tr("Add"))
+        add_btn.clicked.connect(self._add)
+        btn_layout.addWidget(add_btn)
+        del_btn = QPushButton(self.tr("Delete"))
+        del_btn.clicked.connect(self._delete)
+        btn_layout.addWidget(del_btn)
+        layout.addLayout(btn_layout)
+
+        close_btn = QPushButton(self.tr("Close"))
+        close_btn.clicked.connect(self.accept)
+        layout.addWidget(close_btn)
+
+        self._load()
+
+    def _load(self):
+        self.list_widget.clear()
+        for g in self.draft.system_globals:
+            self.list_widget.addItem(f"{g.name} : {g.type} = {g.initial_value}")
+
+    def _add(self):
+        name, ok = QInputDialog.getText(self, "Add", "Variable name:")
+        if ok and name:
+            self.draft.system_globals.append(SystemGlobal(name=name))
+            self._load()
+
+    def _delete(self):
+        row = self.list_widget.currentRow()
+        if row >= 0:
+            del self.draft.system_globals[row]
+            self._load()

statable_gui/transition_editor_direct/transition_actions_dialog.py

@@ -0,0 +1,109 @@
+# statable_gui/transition_editor_direct/transition_actions_dialog.py
+"""Dialog to edit pre_actions / else_actions for one transition (v2.2)."""
+
+import logging
+from typing import List
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, QPushButton,
+    QListWidget, QListWidgetItem, QDialogButtonBox, QGroupBox,
+)
+
+logger = logging.getLogger("transition_editor_direct.transition_actions_dialog")
+
+
+class TransitionActionsDialog(QDialog):
+    """Edit pre_actions and else_actions for a single transition.
+
+    Provides two list widgets with [+ Add] / [Delete] buttons.
+    The add button uses a combo box populated from the role function library.
+    """
+
+    def __init__(self, parent=None,
+                 label: str = "",
+                 pre_actions: List[str] = None,
+                 else_actions: List[str] = None,
+                 role_functions: List[str] = None):
+        super().__init__(parent)
+        self.label = label or "(unnamed)"
+        self.role_functions = role_functions or []
+
+        self.setWindowTitle(f"Edit actions: {self.label}")
+        self.setMinimumSize(500, 450)
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(QLabel(
+            f"Transition: {self.label}\n"
+            "Set role functions executed before / after the transition."))
+
+        # ---- Pre-actions group ----
+        pre_group = QGroupBox(self.tr("Pre-actions (executed before next_state assignment)"))
+        pre_layout = QVBoxLayout(pre_group)
+        self.pre_list = QListWidget()
+        for a in (pre_actions or []):
+            self.pre_list.addItem(a)
+        pre_layout.addWidget(self.pre_list)
+
+        pre_btn = QHBoxLayout()
+        self.pre_combo = QComboBox()
+        self.pre_combo.setEditable(True)
+        self.pre_combo.addItems(self.role_functions)
+        pre_btn.addWidget(self.pre_combo, stretch=1)
+        pre_add = QPushButton(self.tr("+ Add"))
+        pre_add.clicked.connect(lambda: self._add(self.pre_list, self.pre_combo))
+        pre_btn.addWidget(pre_add)
+        pre_del = QPushButton(self.tr("Delete"))
+        pre_del.clicked.connect(lambda: self._del(self.pre_list))
+        pre_btn.addWidget(pre_del)
+        pre_layout.addLayout(pre_btn)
+        layout.addWidget(pre_group)
+
+        # ---- Else-actions group ----
+        else_group = QGroupBox(self.tr("Else-actions (executed in the else branch)"))
+        else_layout = QVBoxLayout(else_group)
+        self.else_list = QListWidget()
+        for a in (else_actions or []):
+            self.else_list.addItem(a)
+        else_layout.addWidget(self.else_list)
+
+        else_btn = QHBoxLayout()
+        self.else_combo = QComboBox()
+        self.else_combo.setEditable(True)
+        self.else_combo.addItems(self.role_functions)
+        else_btn.addWidget(self.else_combo, stretch=1)
+        else_add = QPushButton(self.tr("+ Add"))
+        else_add.clicked.connect(lambda: self._add(self.else_list, self.else_combo))
+        else_btn.addWidget(else_add)
+        else_del = QPushButton(self.tr("Delete"))
+        else_del.clicked.connect(lambda: self._del(self.else_list))
+        else_btn.addWidget(else_del)
+        else_layout.addLayout(else_btn)
+        layout.addWidget(else_group)
+
+        # ---- OK / Cancel ----
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def _add(self, list_widget: QListWidget, combo: QComboBox):
+        name = combo.currentText().strip()
+        if not name:
+            return
+        list_widget.addItem(name)
+        logger.debug(f"Added: {name}")
+
+    def _del(self, list_widget: QListWidget):
+        row = list_widget.currentRow()
+        if row >= 0:
+            list_widget.takeItem(row)
+
+    def get_pre_actions(self) -> List[str]:
+        return [self.pre_list.item(i).text()
+                for i in range(self.pre_list.count())]
+
+    def get_else_actions(self) -> List[str]:
+        return [self.else_list.item(i).text()
+                for i in range(self.else_list.count())]