statable 3.1.0__py3-none-any.whl

statable_gui/event_delivery_settings_dialog.py

@@ -0,0 +1,191 @@
+"""Event delivery settings dialog"""
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QTableWidget, QTableWidgetItem,
+    QLabel, QHeaderView, QComboBox, QDialogButtonBox,
+    QCheckBox, QAbstractItemView
+)
+from PySide6.QtGui import QFont, QMouseEvent
+
+from statable.state_machine import StateMachine
+from statable.model import EventDeliveryType
+from statable.global_defs import GlobalDefinitions
+from .logger import StaTableLogger
+
+
+class DoubleClickTable(QTableWidget):
+    """Table that reliably captures double-click events"""
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setEditTriggers(QAbstractItemView.NoEditTriggers)
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.SingleSelection)
+
+    def mouseDoubleClickEvent(self, event: QMouseEvent):
+        pos = event.position().toPoint()
+        item = self.itemAt(pos)
+        if item:
+            self.cellDoubleClicked.emit(item.row(), item.column())
+
+
+class EventDeliverySettingsDialog(QDialog):
+    """Dialog to configure event delivery type (DIRECT/QUEUE) and display automatic DOUBLE conversion based on ISR usage"""
+    def __init__(self, sm: StateMachine, global_defs: GlobalDefinitions, auto_convert: bool = True, parent=None):
+        super().__init__(parent)
+        self.sm = sm
+        self.global_defs = global_defs
+        self.auto_convert = auto_convert
+
+        self.setWindowTitle(self.tr("Event delivery settings"))
+        self.setMinimumSize(900, 500)
+
+        layout = QVBoxLayout(self)
+
+        #Global settings checkbox
+        self.auto_convert_check = QCheckBox(self.tr("Automatically convert DIRECT events used in ISR to DOUBLE"))
+        self.auto_convert_check.setChecked(self.auto_convert)
+        layout.addWidget(self.auto_convert_check)
+
+        # Event list table
+        self.table = DoubleClickTable(0, 6)
+        self.table.setHorizontalHeaderLabels(["Title", "Event name", "Source", "Delivery type", "ISR usage", "Converted"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table.setFont(QFont("Consolas", 10))
+        layout.addWidget(self.table, stretch=1)
+
+        # Help
+        help_label = QLabel(
+            self.tr("If a DIRECT event is notified from an ISR, it is automatically converted to DOUBLE.\n"
+            "Select QUEUE if you need event counts or data.")
+        )
+        help_label.setStyleSheet("color: gray;")
+        layout.addWidget(help_label)
+
+        # OK/Cancel
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+        self._build_table()
+        self.auto_convert_check.stateChanged.connect(self._update_converted_column)
+
+        StaTableLogger.debug("EventDeliverySettingsDialog initialized")
+
+    def _build_table(self):
+        """Build the table"""
+        self.table.setRowCount(0)
+        for event in self.sm.events.values():
+            row = self.table.rowCount()
+            self.table.insertRow(row)
+
+            # Title (read-only)
+            title_item = QTableWidgetItem(event.title)
+            title_item.setFlags(title_item.flags() & ~Qt.ItemIsEditable)
+            self.table.setItem(row, 0, title_item)
+
+            # Event name (read-only)
+            name_item = QTableWidgetItem(event.name if event.name else "(completion)")
+            name_item.setFlags(name_item.flags() & ~Qt.ItemIsEditable)
+            self.table.setItem(row, 1, name_item)
+
+            # Source (read-only)
+            source_item = QTableWidgetItem(event.source_layer.value)
+            source_item.setFlags(source_item.flags() & ~Qt.ItemIsEditable)
+            self.table.setItem(row, 2, source_item)
+
+            # Delivery type combo
+            combo = QComboBox()
+            combo.addItem(self.tr("DIRECT"), EventDeliveryType.DIRECT)
+            combo.addItem(self.tr("QUEUE"), EventDeliveryType.QUEUE)
+            combo.addItem(self.tr("DOUBLE"), EventDeliveryType.DOUBLE)
+            idx = combo.findData(event.delivery_type)
+            if idx >= 0:
+                combo.setCurrentIndex(idx)
+            combo.currentIndexChanged.connect(lambda _index, r=row: self._on_delivery_changed(r))
+            self.table.setCellWidget(row, 3, combo)
+
+            #ISR usage column (read-only)
+            isr_used = self._check_isr_usage(event.name)
+            isr_item = QTableWidgetItem("Yes" if isr_used else "")
+            isr_item.setFlags(isr_item.flags() & ~Qt.ItemIsEditable)
+            self.table.setItem(row, 4, isr_item)
+
+            # Conversion column (read-only)
+            converted_item = QTableWidgetItem()
+            converted_item.setFlags(converted_item.flags() & ~Qt.ItemIsEditable)
+            self.table.setItem(row, 5, converted_item)
+
+            StaTableLogger.debug(f"  Event: '{event.name}' -> ISR used: {isr_used}")
+
+        self._update_converted_column()
+
+    def _check_isr_usage(self, event_name: str) -> bool:
+        """Determine if event used from interrupt handler"""
+        if not event_name:
+            return False
+
+        for intr in self.global_defs.interrupts:
+            #Check event_names list
+            if event_name in intr.event_names:
+                StaTableLogger.debug(f"  '{event_name}' found in interrupt '{intr.name}' event_names")
+                return True
+
+            #Check the code in actions
+            for act in intr.actions:
+                combined = act.condition + "\n" + act.action
+                if event_name in combined:
+                    StaTableLogger.debug(f"  '{event_name}' found in interrupt '{intr.name}' action code")
+                    return True
+
+        return False
+
+    def _find_row_by_event_name(self, event_name: str) -> int:
+        """Find the row number from the event name"""
+        for row in range(self.table.rowCount()):
+            item = self.table.item(row, 1)
+            if item and item.text() == event_name:
+                return row
+        return -1
+
+    def _on_delivery_changed(self, row: int):
+        """Update the converted column when the delivery type combo changes"""
+        self._update_converted_column()
+
+    def _update_converted_column(self):
+        """Recompute conversion column from settings"""
+        auto = self.auto_convert_check.isChecked()
+        for row in range(self.table.rowCount()):
+            name_item = self.table.item(row, 1)
+            event_name = name_item.text() if name_item else ""
+            if event_name == "(completion)":
+                event_name = ""
+
+            combo = self.table.cellWidget(row, 3)
+            if not combo:
+                continue
+            current_type = combo.currentData()
+            isr_used = self.table.item(row, 4).text() == "Yes"
+            converted = current_type
+            if auto and isr_used and current_type == EventDeliveryType.DIRECT:
+                converted = EventDeliveryType.DOUBLE
+            converted_item = self.table.item(row, 5)
+            if converted_item:
+                converted_item.setText(converted.value if converted else "")
+
+    def _on_accept(self):
+        """OK button: update each event's delivery type and close"""
+        for row in range(self.table.rowCount()):
+            name_item = self.table.item(row, 1)
+            event_name = name_item.text() if name_item else ""
+            if event_name == "(completion)":
+                event_name = ""
+            combo = self.table.cellWidget(row, 3)
+            if combo and event_name in self.sm.events:
+                self.sm.events[event_name].delivery_type = combo.currentData()
+        self.accept()
+
+    def get_auto_convert(self) -> bool:
+        """Return the checkbox state"""
+        return self.auto_convert_check.isChecked()

statable_gui/event_queue_dialog.py

@@ -0,0 +1,245 @@
+"""Event queue definition dialog"""
+
+from typing import Optional, List
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont, QMouseEvent
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem,
+    QPushButton, QLabel, QHeaderView, QLineEdit, QSpinBox,
+    QCheckBox, QFormLayout, QDialogButtonBox, QMessageBox, QAbstractItemView,
+    QWidget, QListWidget, QListWidgetItem
+)
+
+from statable.global_defs import GlobalDefinitions, EventQueueDef
+from .common_widgets import TitleEditWidget, TypeComboBox
+from .logger import StaTableLogger
+
+
+class DoubleClickTable(QTableWidget):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setEditTriggers(QAbstractItemView.NoEditTriggers)
+        self.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.setSelectionMode(QAbstractItemView.SingleSelection)
+
+    def mouseDoubleClickEvent(self, event: QMouseEvent):
+        pos = event.position().toPoint()
+        item = self.itemAt(pos)
+        if item:
+            self.cellDoubleClicked.emit(item.row(), item.column())
+
+
+class EventQueueEditDialog(QDialog):
+    def __init__(self, parent=None, queue_def: Optional[EventQueueDef] = None,
+                 event_names: Optional[List[str]] = None, global_defs=None):
+        super().__init__(parent)
+        self.global_defs = global_defs if global_defs else GlobalDefinitions()
+        self.event_names = event_names or []
+        self.setWindowTitle(self.tr("EventQueueEdit"))
+        self.setMinimumWidth(500)
+
+        layout = QVBoxLayout(self)
+        form = QFormLayout()
+        layout.addLayout(form)
+
+        # Title input field (required / provisional title auto-set)
+        self.title_widget = TitleEditWidget(self, title=queue_def.title if queue_def else "")
+        form.addRow("", self.title_widget)
+
+        # Queue name
+        self.name_edit = QLineEdit(queue_def.name if queue_def else "")
+        form.addRow("Queue name", self.name_edit)
+
+        # Size
+        self.size_spin = QSpinBox()
+        self.size_spin.setRange(2, 256)
+        self.size_spin.setValue(queue_def.size if queue_def else 8)
+        form.addRow("Size", self.size_spin)
+
+        # Element type
+        self.type_combo = TypeComboBox(self, global_defs=self.global_defs)
+        if queue_def:
+            self.type_combo.set_current_text(queue_def.element_type)
+        form.addRow("Element type", self.type_combo)
+
+        # Related event selection list
+        self.event_list = QListWidget()
+        for event_name in self.event_names:
+            item = QListWidgetItem(event_name)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(Qt.Checked if queue_def and event_name in queue_def.event_ids else Qt.Unchecked)
+            self.event_list.addItem(item)
+        form.addRow("Related events", self.event_list)
+
+        # With priority
+        self.priority_check = QCheckBox()
+        self.priority_check.setChecked(queue_def.priority_enabled if queue_def else False)
+        form.addRow("With priority", self.priority_check)
+
+        # Interrupt protection
+        self.safe_check = QCheckBox()
+        self.safe_check.setChecked(queue_def.interrupt_safe if queue_def else True)
+        form.addRow("Interrupt protection", self.safe_check)
+
+        # RTOS usage
+        self.rtos_check = QCheckBox()
+        self.rtos_check.setChecked(queue_def.rtos_enabled if queue_def else False)
+        form.addRow("RTOS usage", self.rtos_check)
+
+        # description
+        self.desc_edit = QLineEdit(queue_def.description if queue_def else "")
+        form.addRow("Description", self.desc_edit)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+        StaTableLogger.debug("EventQueueEditDialog initialized")
+
+    def _on_accept(self):
+        """OK button: auto-set provisional title if title is empty"""
+        auto_title = f"Queue: {self.name_edit.text().strip() or '(unnamed)'}"
+        self.title_widget.ensure_title(auto_title)
+        self.accept()
+
+    def get_queue_def(self) -> EventQueueDef:
+        event_ids = []
+        for i in range(self.event_list.count()):
+            item = self.event_list.item(i)
+            if item.checkState() == Qt.Checked:
+                event_ids.append(item.text())
+        return EventQueueDef(
+            name=self.name_edit.text().strip(),
+            size=self.size_spin.value(),
+            element_type=self.type_combo.current_text(),
+            event_ids=event_ids,
+            priority_enabled=self.priority_check.isChecked(),
+            interrupt_safe=self.safe_check.isChecked(),
+            rtos_enabled=self.rtos_check.isChecked(),
+            description=self.desc_edit.text().strip(),
+            title=self.title_widget.get_title(),
+        )
+
+
+class EventQueueDefsDialog(QDialog):
+    """Event queue definition list dialog"""
+    def __init__(self, global_defs: GlobalDefinitions, event_names: Optional[List[str]] = None, parent=None):
+        super().__init__(parent)
+        self.global_defs = global_defs
+        self.event_names = event_names or []
+        self.setWindowTitle(self.tr("Event queue definition"))
+        self.setMinimumSize(1100, 600)
+
+        layout = QVBoxLayout(self)
+
+        # Search
+        search_layout = QHBoxLayout()
+        search_layout.addWidget(QLabel(self.tr("Search (prefix match):")))
+        self.search_edit = QLineEdit()
+        self.search_edit.setPlaceholderText(self.tr("Title, queue name, description"))
+        self.search_edit.textChanged.connect(self.refresh_table)
+        search_layout.addWidget(self.search_edit)
+        layout.addLayout(search_layout)
+
+        # List table (title column added / direct edit)
+        self.table = DoubleClickTable(0, 9)
+        self.table.setHorizontalHeaderLabels(["Title", "Queue name", "Size", "Element type", "Related events", "Priority", "Interrupt protection", "RTOS", "Description"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table.cellDoubleClicked.connect(self.on_double_clicked)
+        self.table.itemChanged.connect(self.on_item_changed)
+        layout.addWidget(self.table)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        add_btn = QPushButton(self.tr("Add"))
+        add_btn.clicked.connect(self.add_queue)
+        del_btn = QPushButton(self.tr("Delete"))
+        del_btn.clicked.connect(self.delete_queue)
+        btn_layout.addWidget(add_btn)
+        btn_layout.addWidget(del_btn)
+        btn_layout.addStretch()
+        layout.addLayout(btn_layout)
+
+        # Close
+        close_btn = QPushButton(self.tr("Close"))
+        close_btn.clicked.connect(self.accept)
+        layout.addWidget(close_btn, alignment=Qt.AlignRight)
+
+        self.refresh_table()
+        StaTableLogger.debug("EventQueueDefsDialog initialized")
+
+    def refresh_table(self):
+        query = self.search_edit.text().strip().lower() if hasattr(self, 'search_edit') else ""
+        self.table.setRowCount(0)
+        for q in self.global_defs.event_queues:
+            if not self._matches(q, query):
+                continue
+            row = self.table.rowCount()
+            self.table.insertRow(row)
+
+            title_item = QTableWidgetItem(q.title)
+            title_item.setToolTip(self.tr("Title of this queue. Can be edited directly."))
+            self.table.setItem(row, 0, title_item)
+
+            self.table.setItem(row, 1, QTableWidgetItem(q.name))
+            self.table.setItem(row, 2, QTableWidgetItem(str(q.size)))
+            self.table.setItem(row, 3, QTableWidgetItem(q.element_type))
+            self.table.setItem(row, 4, QTableWidgetItem(", ".join(q.event_ids)))
+            self.table.setItem(row, 5, QTableWidgetItem("Yes" if q.priority_enabled else "None"))
+            self.table.setItem(row, 6, QTableWidgetItem("Yes" if q.interrupt_safe else "None"))
+            self.table.setItem(row, 7, QTableWidgetItem("Yes" if q.rtos_enabled else "None"))
+            self.table.setItem(row, 8, QTableWidgetItem(q.description))
+
+    def _matches(self, q: EventQueueDef, query: str) -> bool:
+        """Search filter (prefix match)"""
+        if not query:
+            return True
+        return (
+            q.title.lower().startswith(query) or
+            q.name.lower().startswith(query) or
+            q.description.lower().startswith(query)
+        )
+
+    def on_item_changed(self, item):
+        """Handler when the title column is edited directly"""
+        if item.column() == 0:
+            row = item.row()
+            name_item = self.table.item(row, 1)
+            if name_item and row < len(self.global_defs.event_queues):
+                for q in self.global_defs.event_queues:
+                    if q.name == name_item.text():
+                        q.title = item.text().strip() or f"Queue: {q.name}"
+                        break
+
+    def on_double_clicked(self, row, col):
+        if col == 0:
+            return
+        if row < 0 or row >= len(self.global_defs.event_queues):
+            return
+        target = self.global_defs.event_queues[row]
+        dlg = EventQueueEditDialog(self, queue_def=target, event_names=self.event_names, global_defs=self.global_defs)
+        if dlg.exec() == QDialog.Accepted:
+            new_q = dlg.get_queue_def()
+            if not new_q.name:
+                QMessageBox.warning(self, self.tr("Warning"), self.tr("Please enter a queue name."))
+                return
+            self.global_defs.event_queues[row] = new_q
+            self.refresh_table()
+
+    def add_queue(self):
+        dlg = EventQueueEditDialog(self, event_names=self.event_names, global_defs=self.global_defs)
+        if dlg.exec() == QDialog.Accepted:
+            q = dlg.get_queue_def()
+            if not q.name:
+                QMessageBox.warning(self, self.tr("Warning"), self.tr("Please enter a queue name."))
+                return
+            self.global_defs.event_queues.append(q)
+            self.refresh_table()
+
+    def delete_queue(self):
+        row = self.table.currentRow()
+        if 0 <= row < len(self.global_defs.event_queues):
+            self.global_defs.event_queues.pop(row)
+            self.refresh_table()

statable_gui/global_defs.py

@@ -0,0 +1,167 @@
+"""Data model for global variables, event flags, interrupt handlers, device resources, and timer settings"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class SystemVariable:
+    """Global variables shared across the system"""
+    name: str
+    type: str
+    unit: str = ""
+    default_value: str = ""
+    group: str = ""
+    description: str = ""
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Variable: {self.name}"
+
+
+@dataclass
+class EventFlag:
+    """Event flags managed as bit fields"""
+    name: str
+    min_value: int
+    max_value: int
+    group: str = ""
+    description: str = ""
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Flag: {self.name}"
+
+    @property
+    def bit_width(self) -> int:
+        if self.max_value < self.min_value:
+            return 0
+        return (self.max_value - self.min_value).bit_length()
+
+
+@dataclass
+class InterruptAction:
+    """Conditional actions inside an interrupt handler"""
+    condition: str = ""
+    action: str = ""
+
+
+@dataclass
+class InterruptHandlerDef:
+    """Interrupt handler definition"""
+    name: str
+    description: str = ""
+    event_names: List[str] = field(default_factory=list)
+    is_timer: bool = False
+    actions: List[InterruptAction] = field(default_factory=list)
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Interrupt: {self.name}"
+
+
+@dataclass
+class DevicePlaceholderDef:
+    """Device resource placeholder definition"""
+    name: str
+    description: str = ""
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Device: {self.name}"
+
+
+@dataclass
+class TimerDerivedDef:
+    """Derived timer variable definition"""
+    period_name: str
+    multiplier: int
+    variable_name: str
+    data_type: str = "uint8_t"
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Timer: {self.variable_name}"
+
+
+@dataclass
+class TimerBaseDef:
+    """Timer tick variable definition"""
+    variable_name: str = "g_system_tick"
+    unit: str = "1ms"
+    data_type: str = "volatile uint32_t"
+    derived: List[TimerDerivedDef] = field(default_factory=list)
+    title: str = ""
+    interrupt_name: str = ""   # Interrupt name driving this timer
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Timer base: {self.variable_name}"
+
+
+@dataclass
+class EventQueueDef:
+    """Event queue definition"""
+    name: str
+    size: int
+    element_type: str
+    event_ids: List[str] = field(default_factory=list)
+    priority_enabled: bool = False
+    interrupt_safe: bool = True
+    rtos_enabled: bool = False
+    description: str = ""
+    title: str = ""
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = f"Queue: {self.name}"
+
+
+class GlobalDefinitions:
+    """Management class for global variables, event flags, interrupt handlers, device resources, timer settings, and event queues"""
+
+    def __init__(self):
+        self.variables: List[SystemVariable] = []
+        self.flags: List[EventFlag] = []
+        self.interrupts: List[InterruptHandlerDef] = []
+        self.placeholders: List[DevicePlaceholderDef] = []
+        self.timer_base: TimerBaseDef = TimerBaseDef()
+        self.extra_timers: List[TimerBaseDef] = []   # Add timer base
+        self.event_queues: List[EventQueueDef] = []
+
+    def add_timer_variables(self):
+        """Register all timer base variables and derived timer variables as global variables"""
+        self.variables = [v for v in self.variables if v.group != "Timer"]
+
+        all_timers = [self.timer_base] + self.extra_timers
+        for timer in all_timers:
+            self.variables.append(SystemVariable(
+                name=timer.variable_name,
+                type=timer.data_type,
+                unit=timer.unit,
+                default_value="0",
+                group="Timer",
+                description="Timer base variable",
+                title=timer.title,
+            ))
+            for d in timer.derived:
+                self.variables.append(SystemVariable(
+                    name=d.variable_name,
+                    type=d.data_type,
+                    unit=d.period_name,
+                    default_value="0",
+                    group="Timer",
+                    description=f"Derived timer variable ({d.period_name})",
+                    title=d.title,
+                ))
+
+    def variable_groups(self) -> List[str]:
+        return sorted({v.group for v in self.variables if v.group})
+
+    def flag_groups(self) -> List[str]:
+        return sorted({f.group for f in self.flags if f.group})