statable 3.1.0__py3-none-any.whl

statable_gui/layer_settings_dialog.py

@@ -0,0 +1,180 @@
+# statable_gui/layer_settings_dialog.py
+"""\nLayer settings dialog\n- Batch configure execution priority and layer name for each tab (layer)\n"""
+
+import logging
+from typing import List, Tuple
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QTableWidget,
+    QTableWidgetItem, QHeaderView, QLabel, QPushButton,
+    QSpinBox, QAbstractItemView, QMessageBox, QGroupBox
+)
+from PySide6.QtCore import Qt
+
+from statable.state_machine import StateMachine
+
+logger = logging.getLogger(__name__)
+
+
+class LayerSettingsDialog(QDialog):
+    """Layer settings dialog"""
+
+    def __init__(self, layers: List[Tuple[str, StateMachine]],
+                 parent=None):
+        """
+        Args:
+            layers: [(tab_name, state_machine), ...]
+        """
+        super().__init__(parent)
+        self.layers = layers
+
+        self.setWindowTitle(self.tr("Layer settings"))
+        self.setMinimumSize(640, 420)
+
+        self._setup_ui()
+        self._load_layers()
+
+    def _setup_ui(self):
+        layout = QVBoxLayout(self)
+
+        # description
+        info_group = QGroupBox(self.tr("About settings items"))
+        info_layout = QVBoxLayout(info_group)
+
+        info_label = QLabel(
+            self.tr("- Layer name: used in generated code identifiers (e.g., Driver -> "
+            "STATE_Driver_Idle).\n"
+            "  Leaving it empty generates a version without a layer name (STATE_Idle).\n"
+            "- Priority: range 1-9. 1 (low) runs / initializes first.\n"
+            "- Tab name: display name (change via the tab rename menu).")
+        )
+        info_label.setStyleSheet("color: gray;")
+        info_layout.addWidget(info_label)
+
+        layout.addWidget(info_group)
+
+        # Layer list table (4 columns)
+        self.table = QTableWidget(0, 4)
+        self.table.setHorizontalHeaderLabels(
+            ["Tab name", "Layer name", "Priority", "Description"]
+        )
+        self.table.horizontalHeader().setSectionResizeMode(
+            0, QHeaderView.ResizeToContents)
+        self.table.horizontalHeader().setSectionResizeMode(
+            1, QHeaderView.ResizeToContents)
+        self.table.horizontalHeader().setSectionResizeMode(
+            2, QHeaderView.ResizeToContents)
+        self.table.horizontalHeader().setSectionResizeMode(
+            3, QHeaderView.Stretch)
+        self.table.setSelectionMode(
+            QAbstractItemView.SingleSelection)
+        self.table.setEditTriggers(
+            QAbstractItemView.DoubleClicked
+            | QAbstractItemView.EditKeyPressed
+        )
+
+        layout.addWidget(self.table)
+
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+
+        cancel_btn = QPushButton(self.tr("Cancel"))
+        cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(cancel_btn)
+
+        ok_btn = QPushButton(self.tr("OK"))
+        ok_btn.clicked.connect(self._on_ok)
+        button_layout.addWidget(ok_btn)
+
+        layout.addLayout(button_layout)
+
+    def _load_layers(self):
+        self.table.setRowCount(len(self.layers))
+
+        # Sort by priority ascending
+        sorted_layers = sorted(
+            self.layers,
+            key=lambda x: getattr(x[1], 'layer_priority', 5)
+        )
+
+        for row, (tab_name, sm) in enumerate(sorted_layers):
+            # Tab name (not editable)
+            tab_item = QTableWidgetItem(tab_name)
+            tab_item.setFlags(
+                tab_item.flags() & ~Qt.ItemIsEditable
+            )
+            self.table.setItem(row, 0, tab_item)
+
+            # Layer name (editable)
+            layer_name = getattr(sm, 'layer_name', '')
+            name_item = QTableWidgetItem(layer_name)
+            self.table.setItem(row, 1, name_item)
+
+            # Priority (spin box)
+            priority = getattr(sm, 'layer_priority', 5)
+            priority_spin = QSpinBox()
+            priority_spin.setRange(1, 9)
+            priority_spin.setValue(priority)
+            self.table.setCellWidget(row, 2, priority_spin)
+
+            # description
+            desc = getattr(sm, 'layer_description', '')
+            desc_item = QTableWidgetItem(desc)
+            self.table.setItem(row, 3, desc_item)
+
+        self.table.resizeRowsToContents()
+
+    def _on_ok(self):
+        # Priority duplicate check
+        priorities = []
+        for row in range(self.table.rowCount()):
+            spin = self.table.cellWidget(row, 2)
+            if spin:
+                priorities.append(spin.value())
+
+        if len(priorities) != len(set(priorities)):
+            reply = QMessageBox.question(
+                self, self.tr("Confirm"),
+                self.tr("Priority is duplicated. Continue anyway?"),
+                QMessageBox.Yes | QMessageBox.No
+            )
+            if reply == QMessageBox.No:
+                return
+
+        self.accept()
+
+    def apply_settings(self):
+        """Apply settings to each StateMachine"""
+        for row in range(self.table.rowCount()):
+            tab_name = self.table.item(row, 0).text()
+
+            #Search for corresponding StateMachine
+            target_sm = None
+            for name, sm in self.layers:
+                if name == tab_name:
+                    target_sm = sm
+                    break
+
+            if target_sm is None:
+                continue
+
+            # Layer name
+            name_item = self.table.item(row, 1)
+            if name_item:
+                target_sm.layer_name = name_item.text().strip()
+
+            # Priority
+            spin = self.table.cellWidget(row, 2)
+            if spin:
+                target_sm.layer_priority = spin.value()
+
+            # description
+            desc_item = self.table.item(row, 3)
+            if desc_item:
+                target_sm.layer_description = desc_item.text()
+
+        logger.info(
+            f"Layer settings applied for "
+            f"{len(self.layers)} layers"
+        )

statable_gui/libcntrl/__init__.py

@@ -0,0 +1,23 @@
+"""[v3.0 / G-1a] Backward-compat shim for statable_gui.libcntrl.
+
+All shared library classes now live in ``statable.shared``.
+This package re-exports them for backward compatibility.
+"""
+
+from statable.shared import (  # noqa: F401
+    RoleFunctionLibrary,
+    RoleFunction,
+    ConditionLibrary,
+    ConditionTemplate,
+    LiteralLibrary,
+    LiteralDefinition,
+)
+
+__all__ = [
+    "RoleFunctionLibrary",
+    "RoleFunction",
+    "ConditionLibrary",
+    "ConditionTemplate",
+    "LiteralLibrary",
+    "LiteralDefinition",
+]

statable_gui/libcntrl/condition_library.py

@@ -0,0 +1,13 @@
+"""[v3.0 / G-1a] Backward-compat shim.
+
+Content moved to: statable.shared.condition_library
+
+Old imports under ``statable_gui.libcntrl`` keep working via re-export.
+New code should import from ``statable.shared`` instead.
+"""
+from statable.shared.condition_library import (  # noqa: F401
+    ConditionLibrary,
+    ConditionTemplate,
+)
+
+__all__ = ["ConditionLibrary", "ConditionTemplate"]

statable_gui/libcntrl/literal_library.py

@@ -0,0 +1,13 @@
+"""[v3.0 / G-1a] Backward-compat shim.
+
+Content moved to: statable.shared.literal_library
+
+Old imports under ``statable_gui.libcntrl`` keep working via re-export.
+New code should import from ``statable.shared`` instead.
+"""
+from statable.shared.literal_library import (  # noqa: F401
+    LiteralDefinition,
+    LiteralLibrary,
+)
+
+__all__ = ["LiteralDefinition", "LiteralLibrary"]

statable_gui/libcntrl/literal_management_dialog.py

@@ -0,0 +1,185 @@
+# statable_gui/libcntrl/literal_management_dialog.py
+"""
+Literal management dialog (table format, edit-fixed version)
+"""
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem,
+    QPushButton, QMessageBox, QLineEdit, QFormLayout, QDialogButtonBox,
+    QHeaderView
+)
+from PySide6.QtCore import Qt
+
+from .literal_library import LiteralLibrary, LiteralDefinition
+
+
+class LiteralManagementDialog(QDialog):
+    """Shared literal management dialog"""
+
+    def __init__(self, literal_library: LiteralLibrary, parent=None):
+        super().__init__(parent)
+        self.literal_library = literal_library
+
+        self.setWindowTitle(self.tr("Literal management"))
+        self.setMinimumSize(600, 400)
+
+        self._setup_ui()
+        self._load_table()
+
+    def _setup_ui(self):
+        main_layout = QVBoxLayout(self)
+
+        self.table = QTableWidget(0, 4)
+        self.table.setHorizontalHeaderLabels(["Name", "Value", "Type", "Description"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table.setSelectionBehavior(QTableWidget.SelectRows)
+        self.table.setSelectionMode(QTableWidget.SingleSelection)
+        self.table.setEditTriggers(QTableWidget.NoEditTriggers)
+        main_layout.addWidget(self.table)
+
+        btn_layout = QHBoxLayout()
+        add_btn = QPushButton(self.tr("Add"))
+        add_btn.clicked.connect(self._add_literal)
+        edit_btn = QPushButton(self.tr("Edit"))
+        edit_btn.clicked.connect(self._edit_literal)
+        delete_btn = QPushButton(self.tr("Delete"))
+        delete_btn.clicked.connect(self._delete_literal)
+        btn_layout.addWidget(add_btn)
+        btn_layout.addWidget(edit_btn)
+        btn_layout.addWidget(delete_btn)
+        main_layout.addLayout(btn_layout)
+
+        close_btn = QPushButton(self.tr("Close"))
+        close_btn.clicked.connect(self.accept)
+        main_layout.addWidget(close_btn)
+
+    def _load_table(self):
+        self.table.setRowCount(0)
+        for lit in self.literal_library.list_all():
+            row = self.table.rowCount()
+            self.table.insertRow(row)
+
+            name_item = QTableWidgetItem(lit.name)
+            name_item.setData(Qt.UserRole, lit.name)
+            self.table.setItem(row, 0, name_item)
+
+            self.table.setItem(row, 1, QTableWidgetItem(lit.value))
+            self.table.setItem(row, 2, QTableWidgetItem(lit.literal_type))
+            self.table.setItem(row, 3, QTableWidgetItem(lit.description))
+
+    def _get_selected_literal_name(self):
+        row = self.table.currentRow()
+        if row < 0:
+            return None
+        item = self.table.item(row, 0)
+        if item:
+            return item.data(Qt.UserRole)
+        return None
+
+    def _add_literal(self):
+        dialog = LiteralEditDialog(parent=self)
+        if dialog.exec() == QDialog.Accepted:
+            lit = dialog.get_literal()
+            try:
+                self.literal_library.add(lit)
+                self._load_table()
+            except ValueError as e:
+                QMessageBox.warning(self, self.tr("Warning"), str(e))
+
+    def _edit_literal(self):
+        name = self._get_selected_literal_name()
+        if name is None:
+            QMessageBox.information(self, self.tr("Info"), self.tr("Please select a literal to edit."))
+            return
+
+        lit = self.literal_library.get(name)
+        if lit is None:
+            return
+
+        dialog = LiteralEditDialog(literal=lit, parent=self)
+        if dialog.exec() == QDialog.Accepted:
+            new_lit = dialog.get_literal()
+
+            # On edit, always delete the old entry before adding
+            self.literal_library.remove(name)
+            try:
+                self.literal_library.add(new_lit)
+                self._load_table()
+            except ValueError as e:
+                # If failure occurs, revert
+                self.literal_library.add(lit)
+                QMessageBox.warning(self, self.tr("Warning"), str(e))
+
+    def _delete_literal(self):
+        name = self._get_selected_literal_name()
+        if name is None:
+            QMessageBox.information(self, self.tr("Info"), self.tr("Please select a literal to delete."))
+            return
+
+        ret = QMessageBox.warning(
+            self,
+            self.tr("Confirm"),
+            f"Literal '{name}': confirm delete?\n"
+            "If any transition condition uses this literal,\n"
+            "It must also be removed from the relevant condition expression.",
+            QMessageBox.Yes | QMessageBox.No
+        )
+        if ret == QMessageBox.Yes:
+            self.literal_library.remove(name)
+            self._load_table()
+
+
+class LiteralEditDialog(QDialog):
+    """Dialog for adding / editing literals"""
+
+    def __init__(self, literal: LiteralDefinition = None, parent=None):
+        super().__init__(parent)
+        self.literal = literal
+
+        self.setWindowTitle("LiteralEdit" if literal else "LiteralAdd")
+        self.setMinimumWidth(350)
+
+        layout = QVBoxLayout(self)
+        form = QFormLayout()
+
+        self.name_edit = QLineEdit()
+        if literal:
+            self.name_edit.setText(literal.name)
+        form.addRow("Name:", self.name_edit)
+
+        self.value_edit = QLineEdit()
+        if literal:
+            self.value_edit.setText(literal.value)
+        form.addRow("Value:", self.value_edit)
+
+        self.type_edit = QLineEdit("int")
+        if literal:
+            self.type_edit.setText(literal.literal_type)
+        form.addRow("Type:", self.type_edit)
+
+        self.desc_edit = QLineEdit()
+        if literal:
+            self.desc_edit.setText(literal.description)
+        form.addRow("Description:", self.desc_edit)
+
+        layout.addLayout(form)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def _on_accept(self):
+        name = self.name_edit.text().strip()
+        if not name:
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("Please enter a name."))
+            return
+        self.accept()
+
+    def get_literal(self) -> LiteralDefinition:
+        return LiteralDefinition(
+            name=self.name_edit.text().strip(),
+            value=self.value_edit.text().strip(),
+            literal_type=self.type_edit.text().strip() or "int",
+            description=self.desc_edit.text().strip(),
+        )

statable_gui/libcntrl/role_function_edit_dialog.py

@@ -0,0 +1,145 @@
+# statable_gui/libcntrl/role_function_edit_dialog.py
+"""
+Edit role function dialog
+"""
+
+from typing import List
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QFormLayout, QLineEdit,
+    QListWidget, QListWidgetItem, QDialogButtonBox, QGroupBox
+)
+from PySide6.QtCore import Qt
+
+from .role_function_library import RoleFunction
+
+
+class RoleFunctionEditDialog(QDialog):
+    """Shared role function edit dialog"""
+
+    def __init__(self, role_function: RoleFunction,
+                 global_vars: List[str] = None,
+                 events: List[str] = None,
+                 literals: List[str] = None,
+                 parent=None):
+        super().__init__(parent)
+        self.role_function = role_function
+        self.global_vars = global_vars or []
+        self.events = events or []
+        self.literals = literals or []
+
+        self.setWindowTitle(self.tr("Edit role function"))
+        self.setMinimumWidth(500)
+
+        self._setup_ui()
+        self._load_data()
+
+    def _setup_ui(self):
+        main_layout = QVBoxLayout(self)
+
+        form = QFormLayout()
+        self.name_edit = QLineEdit()
+        form.addRow("Function name:", self.name_edit)
+        self.title_edit = QLineEdit()
+        form.addRow("Display name:", self.title_edit)
+        self.desc_edit = QLineEdit()
+        form.addRow("Description:", self.desc_edit)
+        main_layout.addLayout(form)
+
+        # Used global variables
+        global_group = QGroupBox(self.tr("Used global variables"))
+        global_layout = QVBoxLayout(global_group)
+        self.global_list = QListWidget()
+        self.global_list.setSelectionMode(QListWidget.NoSelection)
+        for var in self.global_vars:
+            item = QListWidgetItem(var)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Unchecked)
+            self.global_list.addItem(item)
+        global_layout.addWidget(self.global_list)
+        main_layout.addWidget(global_group)
+
+        # Used events
+        event_group = QGroupBox(self.tr("Used events"))
+        event_layout = QVBoxLayout(event_group)
+        self.event_list = QListWidget()
+        self.event_list.setSelectionMode(QListWidget.NoSelection)
+        for event in self.events:
+            item = QListWidgetItem(event)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Unchecked)
+            self.event_list.addItem(item)
+        event_layout.addWidget(self.event_list)
+        main_layout.addWidget(event_group)
+
+        # Used literals
+        literal_group = QGroupBox(self.tr("Used literals (select from existing)"))
+        literal_layout = QVBoxLayout(literal_group)
+        self.literal_list = QListWidget()
+        self.literal_list.setSelectionMode(QListWidget.NoSelection)
+        for lit in self.literals:
+            item = QListWidgetItem(lit)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Unchecked)
+            self.literal_list.addItem(item)
+        literal_layout.addWidget(self.literal_list)
+        main_layout.addWidget(literal_group)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        main_layout.addWidget(buttons)
+
+    def _load_data(self):
+        self.name_edit.setText(self.role_function.name)
+        self.title_edit.setText(self.role_function.title)
+        self.desc_edit.setText(self.role_function.description)
+
+        for i in range(self.global_list.count()):
+            item = self.global_list.item(i)
+            if item.text() in self.role_function.used_global_vars:
+                item.setCheckState(Qt.Checked)
+
+        for i in range(self.event_list.count()):
+            item = self.event_list.item(i)
+            if item.text() in self.role_function.used_events:
+                item.setCheckState(Qt.Checked)
+
+        for i in range(self.literal_list.count()):
+            item = self.literal_list.item(i)
+            if item.text() in self.role_function.used_literals:
+                item.setCheckState(Qt.Checked)
+
+    def _on_accept(self):
+        name = self.name_edit.text().strip()
+        if not name:
+            name = "NewRoleFunction"
+        self.role_function.name = name
+        self.role_function.title = self.title_edit.text().strip() or name
+        self.role_function.description = self.desc_edit.text().strip()
+
+        used_global_vars = []
+        for i in range(self.global_list.count()):
+            item = self.global_list.item(i)
+            if item.checkState() == Qt.Checked:
+                used_global_vars.append(item.text())
+        self.role_function.used_global_vars = used_global_vars
+
+        used_events = []
+        for i in range(self.event_list.count()):
+            item = self.event_list.item(i)
+            if item.checkState() == Qt.Checked:
+                used_events.append(item.text())
+        self.role_function.used_events = used_events
+
+        used_literals = []
+        for i in range(self.literal_list.count()):
+            item = self.literal_list.item(i)
+            if item.checkState() == Qt.Checked:
+                used_literals.append(item.text())
+        self.role_function.used_literals = used_literals
+
+        self.accept()
+
+    def get_role_function(self) -> RoleFunction:
+        return self.role_function

statable_gui/libcntrl/role_function_library.py

@@ -0,0 +1,13 @@
+"""[v3.0 / G-1a] Backward-compat shim.
+
+Content moved to: statable.shared.role_function_library
+
+Old imports under ``statable_gui.libcntrl`` keep working via re-export.
+New code should import from ``statable.shared`` instead.
+"""
+from statable.shared.role_function_library import (  # noqa: F401
+    RoleFunction,
+    RoleFunctionLibrary,
+)
+
+__all__ = ["RoleFunction", "RoleFunctionLibrary"]

statable_gui/literal_definition_dialog.py

@@ -0,0 +1,62 @@
+# statable_gui/literal_definition_dialog.py
+"""New literal definition dialog (R-7 support).
+
+Simple dialog for creating a LiteralDefinition, used by
+RoleFunctionDialog's "+ New Literal" button.
+"""
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QFormLayout, QLineEdit, QComboBox,
+    QDialogButtonBox, QMessageBox,
+)
+
+from statable_gui.libcntrl.literal_library import LiteralDefinition
+
+
+class NewLiteralDialog(QDialog):
+    """Dialog to create a new LiteralDefinition."""
+
+    TYPES = ["int", "float", "bool", "string"]
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(self.tr("New Literal"))
+        self.setMinimumWidth(400)
+
+        layout = QVBoxLayout(self)
+        form = QFormLayout()
+
+        self.name_edit = QLineEdit()
+        self.value_edit = QLineEdit()
+        self.type_combo = QComboBox()
+        self.type_combo.addItems(self.TYPES)
+        self.desc_edit = QLineEdit()
+
+        form.addRow("Name:", self.name_edit)
+        form.addRow("Value:", self.value_edit)
+        form.addRow("Type:", self.type_combo)
+        form.addRow("Description:", self.desc_edit)
+        layout.addLayout(form)
+
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def _on_accept(self):
+        if not self.name_edit.text().strip():
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("Name is required."))
+            return
+        if not self.value_edit.text().strip():
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("Value is required."))
+            return
+        self.accept()
+
+    def get_literal(self) -> LiteralDefinition:
+        return LiteralDefinition(
+            name=self.name_edit.text().strip(),
+            value=self.value_edit.text().strip(),
+            literal_type=self.type_combo.currentText(),
+            description=self.desc_edit.text().strip(),
+        )