Implemented formatting/parsing and module actions

src/simudator/gui/dialogs/module_state_dialog.py

-from typing import Optional
-
 from qtpy.QtCore import Qt
 from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot
 from qtpy.QtWidgets import (
     QComboBox,
     QDialog,
@@ -12,65 +11,97 @@ from qtpy.QtWidgets import (
 )
 
 from simudator.core import Module
+from simudator.gui.formatting import format_to_str, parse_str
+from simudator.gui.module_graphics_item.module_widget import ModuleWidget
 
 
 class ModuleStateDialog(QDialog):
-    accepted = pyqtSignal(str, str, str, name='okSignal')
+    """
+    A dialog for letting the user edit the state of a processor module.
+
+    Parameters
+    ----------
+    module : Module
+        The module to edit the state of.
+    module_widget : ModuleWidget
+        The corresponding module widget for the module. Used mainly for
+        formatting and parsing the values of the state variables of the module.
+    parent : QWidget | None
+        Optional parent widget of this dialog.
+    flags : Qt.WindowFlags | Qt.WindowType
+        Optional window flags for the window of the dialog.
+    """
+
+    state_edited = pyqtSignal()
 
     def __init__(
         self,
         module: Module,
-        parent: Optional['QWidget'] = None,
+        module_widget: ModuleWidget,
+        parent: QWidget | None = None,
         flags: Qt.WindowFlags | Qt.WindowType = Qt.WindowFlags(),
     ) -> None:
         super().__init__(parent, flags)
 
-        self.module = module
-        states = module.get_gui_state()
-
-        # Remove the 'name' state of the module from the drop down menu so
-        # that the user cannot e.g. edit or add a breakpoint of a module
-        states.pop('name')
+        self._module = module
+        self._state_vars = module_widget.get_state_vars()
 
-        # Set up the drop down menu for selecting a state of the module
-        # to perform an action to
-        self.stateSelectWidget = QComboBox()
-        self.stateSelectWidget.addItems(states.keys())
-        self.stateSelectWidget.activated.connect(self.updateState)
+        # Set up the drop down menu for selecting a state variable of the module
+        self._state_var_widget = QComboBox()
+        self._state_var_widget.addItems(self._state_vars.keys())
 
-        # Set up a text field for entering the value used for the e.g. editing
-        # the selected state
-        self.valueWidget = QLineEdit()
+        # Set up a text field for displaying and editing the value of the
+        # selected state variable
+        self._value_widget = QLineEdit()
 
         # Set up buttons
-        self.okButton = QPushButton('OK')
-        self.okButton.clicked.connect(self.signalOK)
-        self.cancelButton = QPushButton('Cancel')
-        self.cancelButton.clicked.connect(self.close)
+        self._accept_button = QPushButton('OK')
+        self._accept_button.clicked.connect(self.edit_state)
+        self._cancel_button = QPushButton('Cancel')
+        self._cancel_button.clicked.connect(self.close)
 
         # Set up the layout of the widget
-        self.HBoxLayout = QHBoxLayout()
-        self.HBoxLayout.addWidget(self.stateSelectWidget, 0)
-        self.HBoxLayout.addWidget(self.valueWidget, 1)
-        self.HBoxLayout.addWidget(self.okButton, 2)
-        self.HBoxLayout.addWidget(self.cancelButton, 3)
-        self.setLayout(self.HBoxLayout)
+        self._layout = QHBoxLayout()
+        self._layout.addWidget(self._state_var_widget, 0)
+        self._layout.addWidget(self._value_widget, 1)
+        self._layout.addWidget(self._accept_button, 2)
+        self._layout.addWidget(self._cancel_button, 3)
+        self.setLayout(self._layout)
 
         # Show the widget
-        self.updateState()
-        self.show()
-
-    def updateState(self) -> None:
-        selectedState = self.stateSelectWidget.currentText()
-        value = self.module.get_gui_state()[selectedState]
-        self.valueWidget.setText(str(value))
-
-    def signalOK(self) -> None:
-        module_name = self.module.get_state()['name']
-        selectedState = self.stateSelectWidget.currentText()
-        enteredValue = self.valueWidget.text()
-        self.accepted.emit(module_name, selectedState, enteredValue)
-        self.close()
-
-    def close(self) -> bool:
-        return super().close()
+        self.select_state_var()
+        self.exec()
+
+    @Slot()
+    def select_state_var(self) -> None:
+        """
+        Select a state variable of the module to edit.
+        """
+        selected_state = self._state_var_widget.currentText()
+        format_info = self._state_vars[selected_state]
+        value = format_to_str(format_info, self._module.get_state()[selected_state])
+        self._value_widget.setText(value)
+
+    @Slot()
+    def edit_state(self) -> None:
+        """
+        Parse the user input and edit the state of the module associated with
+        this dialog.
+
+        This triggers the `state_edited` signal if the parsing is
+        successful. Else, the user is given an error message.
+        """
+        state = self._module.get_state()
+        selected_state_var = self._state_var_widget.currentText()
+        try:
+            value = parse_str(
+                self._state_vars[selected_state_var], self._value_widget.text()
+            )
+            state[selected_state_var] = value
+            self._module.set_state(state)
+            self.state_edited.emit()
+            self.close()
+        except ValueError as e:
+            # TODO: error handling
+            pass
+

src/simudator/gui/formatting.py

+import math
+from enum import Enum, auto
+from typing import Any
+
+
+class Format(Enum):
+    """
+    An Enum class containing the different valid formats for formatting and
+    parsing values of different data types.
+    """
+
+    Str = (auto(),)
+    Int = (auto(),)
+    Bin = (auto(),)
+    Hex = (auto(),)
+    Decimal = (auto(),)
+    DecimalSigned = (auto(),)
+
+
+class FormatInfo:
+    """
+    A class for neatly keeping data about the supported formats and selected
+    format for correctly displaying and parsing values of different data types.
+
+    Parameters
+    ----------
+    supported_format : list[Format]
+        List of formats that are supported for some variable.
+    selected_format : Format
+        The format that should be used on initialization.
+    **kwargs
+        Arguments passed to `format_to_str` and `parse_str`. Required by some
+        formats.
+
+    Attributes
+    ----------
+    supported_formats : list[Format]
+        List of format that are supported.
+    selected_format : Format
+        The selected format to use when formatting/parsing. Should be one of
+        the supported formats.
+    """
+
+    NUMERICAL_FORMATS = (
+        Format.Int,
+        Format.Bin,
+        Format.Hex,
+        Format.Decimal,
+        Format.DecimalSigned,
+    )
+    """
+    List of standard numerical formats for handling numbers. It is possible to
+    switch between these formats easily as they all require the same
+    keyword arguments.
+    """
+
+    __slots__ = ("selected_format", "supported_formats", "kwargs")
+
+    def __init__(
+        self, supported_formats: list[Format], selected_format: Format, **kwargs
+    ) -> None:
+        self.selected_format = selected_format
+        self.supported_formats = supported_formats
+        self.kwargs = kwargs
+
+
+def format_to_str(format_info: FormatInfo, value: Any) -> str:
+    """
+    Create a formatted string from a given value.
+
+    Parameters
+    ----------
+    format_info : FormatInfo
+        A class containing information about what format to use.
+    value : Any
+        An arbitrary value that is to be formatted to a string.
+
+    Returns
+    -------
+    The input value formatted to a string according to the input variable
+    format.
+    """
+    match format_info.selected_format:
+        case Format.Int:
+            pass
+        case Format.Str:
+            pass
+        case Format.Bin:
+            return f"{value:0{format_info.kwargs["bit_length"]}b}"
+        case Format.Hex:
+            return f"{value:0{math.ceil(format_info.kwargs["bit_length"]/4)}x}"
+        case Format.Decimal:
+            pass
+        case Format.DecimalSigned:
+            pass
+
+
+def parse_str(format_info: FormatInfo, value: str) -> Any:
+    """
+    Parse an input string formatted using the given format.
+
+    Parameters
+    ----------
+    format_info : FormatInfo
+        An instance containing information about the format used on the string.
+    value : str
+        A formatted string to parse into a value.
+
+    Returns
+    -------
+    The parsed value from the formatted string. The data type of the value
+    depends on the format.
+    """
+    match format_info.selected_format:
+        case Format.Int:
+            return int(value)
+        case Format.Hex:
+            return int(value, base=16)
+

src/simudator/gui/gui.py

@@ -2,7 +2,6 @@ import ast
 import sys
 
 from qtpy import QtCore, QtWidgets
-from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot
 from qtpy.QtWidgets import (
     QAction,
@@ -19,6 +18,7 @@ from simudator.gui.cpu_graphics_scene import CpuGraphicsScene
 from simudator.gui.dialogs.lambda_breakpoint_dialog import LambdaBreakpointDialog
 from simudator.gui.menu_bar import MainMenuBar
 from simudator.gui.module_graphics_item.module_graphics_item import ModuleGraphicsItem
+from simudator.gui.module_graphics_item.module_widget import ModuleWidget
 from simudator.gui.pipeline import PipeLine
 from simudator.gui.processor_handler import ProcessorHandler
 from simudator.gui.signal_viewer import SignalViewer
@@ -182,12 +182,6 @@ class GUI(QMainWindow):
         if self._breakpoint_window is not None:
             self._breakpoint_window.update()
 
-    """
-    @Slot is used to explicitly mark a python method as a Qt slot
-    and specify a C++ signature for it, which is used most commonly
-    in order to select a particular overload.
-    """
-
     @Slot(str, str, str)
     def editModuleState(self, module_name, state, value) -> None:
         """
@@ -297,6 +291,20 @@ class GUI(QMainWindow):
         self.connectModuleActions(item.getActionSignals())
         self._processor_handler.changed.connect(item.update)
 
+    def add_module_widget(self, widget: ModuleWidget) -> None:
+        """
+        Add a module widget to the processor scene and connect its QT signals
+        and slots.
+
+        Parameters
+        ----------
+        widget : ModuleWidget
+        The module widget to add to the processor scene.
+        """
+        self._processor_handler.changed.connect(widget.update)
+        self._graphics_scene.addItem(widget)
+        widget.state_changed.connect(self._processor_handler.handle_module_change)
+
     def add_all_signals(self) -> None:
         """
         Add visual representations of all processor signals between all modules

src/simudator/gui/module_graphics_item/actions.py

+from enum import Enum, auto
+
+from PyQt5.QtWidgets import QAction
+
+from simudator.core.module import Module
+from simudator.gui.dialogs.module_state_dialog import ModuleStateDialog
+from simudator.gui.module_graphics_item.module_widget import ModuleWidget
+
+
+class ActionType(Enum):
+    """
+    An Enum class containing the different valid actions for interacting with
+    module widgets.
+    """
+
+    EditState = (auto(),)
+
+
+def edit_state_action(module: Module, module_widget: ModuleWidget) -> QAction:
+    """
+    Create a QAction for opening a state-edit dialog for a module widget.
+    The dialog triggers the state_changed signal of the module widget if the
+    user accepts the dialog.
+
+    Parameters
+    ----------
+    module : Module
+        The module that should be edited when triggering the created edit action.
+    module_widget : ModuleWidget
+        The module widget for the module that should be edited. Used for
+        displaying and parsing information correctly.
+
+    Returns
+    -------
+    QAction
+        A Qt action for opening a dialog for editing the state of a module.
+        Intended to be added as an action to the given module widget.
+    """
+    action = QAction("Edit state", module_widget)
+
+    def action_triggered():
+        dialog = ModuleStateDialog(module, module_widget)
+        dialog.state_edited.connect(module_widget.state_changed)
+
+    action.triggered.connect(action_triggered)
+    return action
+

src/simudator/gui/module_graphics_item/module_widget.py

 from typing import Any
-from qtpy.QtCore import Property, QPointF, QRectF, Qt, Slot
-from qtpy.QtGui import QBrush, QColor, QFont, QFontMetrics, QPainter, QPainterPath, QPen
+
+from qtpy.QtCore import Property, QRectF, Qt
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot
+from qtpy.QtGui import QBrush, QColor, QFont, QFontMetrics, QPainter, QPainterPath, QPen
 from qtpy.QtWidgets import (
+    QErrorMessage,
     QGraphicsItem,
+    QGraphicsSceneContextMenuEvent,
     QGraphicsWidget,
+    QMenu,
     QStyleOptionGraphicsItem,
     QWidget,
-    QAction,
 )
 
 from simudator.core.module import Module
+from simudator.gui.formatting import Format, FormatInfo, format_to_str
 
-class ModuleWidget(QGraphicsWidget):
-    DEFAULT_WIDTH = 50*3
-    DEFAULT_HEIGHT = 50*3
-
-    update = pyqtSignal()
 
-    def __init__(self, module: Module, state_vars: list[str], actions: list[QAction], formatters: dict[str, Any], parent: QGraphicsItem | None = None, flags: Qt.WindowFlags | Qt.WindowType = Qt.WindowFlags()) -> None:
+class ModuleWidget(QGraphicsWidget):
+    """
+    A general class for displaying an arbitrary processor module. The
+    appearance of a module can be customized by changing its properties and
+    by choosing which state variables to display and in what formats.
+
+    Parameters
+    ----------
+    module : Module
+        The processor module to display.
+    state_vars : dict[str, FormatInfo]
+        The state variables of the module to display and in what formats to
+        display them.
+    parent : QGraphicsItem | None
+        Optional parent item of this module widget.
+    flags : Qt.WindowFlags | Qt.WindowType
+        Optional window flags for the window of this widget.
+    """
+
+    DEFAULT_WIDTH = 50 * 3
+    DEFAULT_HEIGHT = 50 * 3
+
+    state_changed = pyqtSignal()
+
+    def __init__(
+        self,
+        module: Module,
+        state_vars: dict[str, FormatInfo],
+        parent: QGraphicsItem | None = None,
+        flags: Qt.WindowFlags | Qt.WindowType = Qt.WindowFlags(),
+    ) -> None:
         super().__init__(parent, flags)
         super().__init__(parent, flags)
         self.setFlag(QGraphicsItem.ItemIsMovable)
 
         self._module = module
         self._state_vars = state_vars
-        self._actions = actions
-        self._formatters = formatters
 
         # Default values for properties for appearance
         # TODO: Put these values in constants?
@@ -41,9 +68,11 @@ class ModuleWidget(QGraphicsWidget):
         width = self.DEFAULT_WIDTH
         height = self.DEFAULT_HEIGHT
         if len(self._state_vars) <= 1:
-           height = QFontMetrics(self._text_font).height() + 2*self._padding
+            height = QFontMetrics(self._text_font).height() + 2 * self._padding
         else:
-            height = (self._padding + QFontMetrics(self._text_font).height()) * (len(state_vars) + 1) + self._padding
+            height = (self._padding + QFontMetrics(self._text_font).height()) * (
+                len(state_vars) + 1
+            ) + self._padding
         self.resize(width, height)
 
     def paint(
@@ -72,24 +101,30 @@ class ModuleWidget(QGraphicsWidget):
         text_rect = self.shape().boundingRect()
 
         # Draw only name of the module if no state variables are to be shown
-        if len(self._state_vars) == 0:
+        if len(self._state_vars.keys()) == 0:
             painter.drawText(text_rect, text_flags, self._module.get_state()["name"])
 
         # Special case: only 1 state variable to show
-        elif len(self._state_vars) == 1:
-            value = self._module.get_state()[self._state_vars[0]]
-            painter.drawText(text_rect, text_flags, f"{self._module.get_state()["name"]}: {value}")
+        elif len(self._state_vars.keys()) == 1:
+            state_var = list(self._state_vars.keys())[0]
+            format_info = self._state_vars[state_var]
+            value = format_to_str(format_info, self._module.get_state()[state_var])
+            painter.drawText(
+                text_rect, text_flags, f"{self._module.get_state()["name"]}: {value}"
+            )
 
         # Draw the name of the module and each state variable with its value on one row each
         else:
-            text_rect = QRectF(0,  0, width, height/(len(self._state_vars)+1))
+            text_rect = QRectF(0, 0, width, height / (len(self._state_vars) + 1))
             painter.drawText(text_rect, text_flags, self._module.get_state()["name"])
 
             for i, state_var in enumerate(self._state_vars):
-                y_start = height / (len(self._state_vars)+1) * (i+1)
-                y_end = height / (len(self._state_vars) + 1 )
+                y_start = height / (len(self._state_vars) + 1) * (i + 1)
+                y_end = height / (len(self._state_vars) + 1)
                 text_rect = QRectF(0, y_start, width, y_end)
-                value = self._module.get_state()[state_var]
+
+                format_info = self._state_vars[state_var]
+                value = format_to_str(format_info, self._module.get_state()[state_var])
                 painter.drawText(text_rect, text_flags, f"{state_var}: {value}")
 
         painter.restore()
@@ -98,7 +133,9 @@ class ModuleWidget(QGraphicsWidget):
     def update(self, rect: QRectF | None = None):
         # This "override" is needed in order to decorate update() as a
         # pyqt slot
-        super().update()
+        if rect is None:
+            rect = self.boundingRect()
+        super().update(rect)
 
     def shape(self) -> QPainterPath:
         path = QPainterPath()
@@ -111,6 +148,60 @@ class ModuleWidget(QGraphicsWidget):
         margin = self.outline_width / 2
         return QRectF(0 - margin, 0 - margin, width + margin, height + margin)
 
+    @Slot(bool)
+    def show_ports(self, value: bool) -> None:
+        """
+        Toggle the visibility of the signal ports of the displayed module.
+
+        Parameters
+        ----------
+        value : bool
+            `True` to show all ports, `False` to hide them.
+        """
+        pass
+
+    def contextMenuEvent(self, event: 'QGraphicsSceneContextMenuEvent') -> None:
+        """
+        Show a context menu for this module, allowing the user to perform any
+        of the actions available to this module.
+        """
+        menu = QMenu()
+        menu.addActions(self.actions())
+        menu.exec_(event.screenPos())
+
+    def get_state_vars(self) -> dict[str, FormatInfo]:
+        """
+        Return a mapping from displayed state variables of the displayed
+        module to their respective format information.
+
+        Useful for viewing the supported formats and the selected format for a
+        state variable.
+
+        Returns
+        -------
+        dict[str, FormatInfo]
+            Mapping from state variable to FormatInfo instance.
+        """
+        return self._state_vars
+
+    @Slot()
+    def set_format(self, state_var: str, format: Format) -> None:
+        """
+        Set the format to be used when displaying and parsing a given state
+        variable of the displayed module.
+
+        Parameters
+        ----------
+        state_va : str
+            The state variable to set the formats of.
+        format : Format
+            The format to use for the value of the state variable. Should be
+            one of the supported formats in the FormatInfo instance for the
+            state variable.
+        """
+        self._state_vars[state_var].selected_format = format
+        self.update()
+
     def outline_width(self) -> float:
         """Return the outline pen width.
 
@@ -216,4 +307,5 @@ class ModuleWidget(QGraphicsWidget):
     outline = Property(QBrush, outline, set_outline)
     background = Property(QBrush, background, set_background)
     text_color = Property(QColor, text_color, set_text_color)
-    text_font = Property(QFont, text_font, set_text_font)
+    text_font = Property(QFont, text_font, set_text_font)
\ No newline at end of file
+

src/simudator/gui/processor_handler.py

-from qtpy import QtCore
 from qtpy.QtCore import QObject, QThreadPool
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot
@@ -21,12 +20,12 @@ class ProcessorHandler(QObject):
 
     running = pyqtSignal(bool)
     """
-    PyQT signal emitted when the processor has started or finished running. 
+    PyQT signal emitted when the processor has started or finished running.
     Emits ``True`` when it has started and ``False`` when it has finished.
     """
     cycle_changed = pyqtSignal(int)
     """
-    PyQT signal emitted when the current clock cycle count of the processor 
+    PyQT signal emitted when the current clock cycle count of the processor
     has changed. Emits the current clock cycle count as an ``int``.
     """
     changed = pyqtSignal()
@@ -105,7 +104,7 @@ class ProcessorHandler(QObject):
     @Slot(int)
     def step_asm_instructions(self, instructions: int):
         """
-        Run some numer of asm instructions.
+        Run some number of asm instructions.
 
         Parameters
         ----------
@@ -333,3 +332,12 @@ class ProcessorHandler(QObject):
         )
         if ok:
             self._update_delay = delay
+
+    @Slot()
+    def handle_module_change(self):
+        """
+        Handle propagating changes when the state of a module has been edited
+        by the user.
+        """
+        pass
+