digsim-logic-simulator 0.22.0__py3-none-any.whl

digsim/app/gui_objects/_component_port_item.py

@@ -0,0 +1,63 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A component port graphics item"""
+
+from PySide6.QtCore import QRect, Qt
+from PySide6.QtGui import QBrush, QPen
+from PySide6.QtWidgets import QGraphicsRectItem
+
+from digsim.circuit.components.atoms import PortConnectionError
+
+
+class PortGraphicsItem(QGraphicsRectItem):
+    """A port graphics item"""
+
+    def __init__(self, app_model, parent, port):
+        super().__init__(QRect(0, 0, 0, 0), parent)
+        self._app_model = app_model
+        self._port = port
+        self.setPen(QPen(Qt.black))
+        self.setBrush(Qt.SolidPattern)
+        self.setBrush(QBrush(Qt.gray))
+        self.setAcceptHoverEvents(True)
+
+    def _repaint(self):
+        """Make scene repaint for component update"""
+        self._app_model.sig_repaint.emit()
+
+    def mousePressEvent(self, _):
+        """QT event callback function"""
+        if self._app_model.is_running:
+            return
+        if self._app_model.objects.new_wire.ongoing():
+            try:
+                self._app_model.objects.new_wire.end(self._port.parent(), self._port.name())
+            except PortConnectionError as exc:
+                self._app_model.objects.new_wire.abort()
+                self._app_model.sig_error.emit(str(exc))
+                self._repaint()
+        else:
+            self._app_model.objects.new_wire.start(self._port.parent(), self._port.name())
+
+    def hoverEnterEvent(self, _):
+        """QT event callback function"""
+        if self._app_model.is_running:
+            return
+        self.setBrush(QBrush(Qt.black))
+        self.setCursor(Qt.CrossCursor)
+
+    def hoverLeaveEvent(self, _):
+        """QT event callback function"""
+        if self._app_model.is_running:
+            return
+        self.setBrush(QBrush(Qt.gray))
+        self.setCursor(Qt.ArrowCursor)
+
+    def portParentRect(self):
+        """return the parent rect"""
+        return self.parentItem().rect().translated(self.parentItem().pos())
+
+    def portPos(self):
+        """return the parent position"""
+        return self.parentItem().pos() + self.rect().center()

digsim/app/gui_objects/_dip_switch_object.py

@@ -0,0 +1,104 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A hexdigit component placed in the GUI"""
+
+from PySide6.QtCore import QPoint, QRect, Qt
+from PySide6.QtGui import QFont, QPen
+
+from ._image_objects import ImageObject
+
+
+class DipSwitchObject(ImageObject):
+    """The class for a bus/bit component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/DIP_SWITCH.png"
+    DIP_SWITCH_WIDTH = 20
+    DIP_SWITCH_HEIGHT = 10
+
+    _DIP_SWITCH_FONT = QFont("Arial", 8)
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos, port_distance=self.DIP_SWITCH_HEIGHT)
+        self.width = 2.5 * self.DIP_SWITCH_WIDTH
+        self.height = self.component.bits() * self.DIP_SWITCH_HEIGHT
+        self._rects = []
+        self.update_ports()
+
+    def update_ports(self):
+        super().update_ports()
+        self._rects = []
+        for idx in range(0, self.component.bits()):
+            port_pos = self.get_port_pos(f"{idx}")
+            self._rects.append(
+                QRect(
+                    self.object_pos.x() + self.rect().width() / 2 - self.DIP_SWITCH_WIDTH / 2,
+                    port_pos.y() - self.DIP_SWITCH_HEIGHT / 2,
+                    self.DIP_SWITCH_WIDTH,
+                    self.DIP_SWITCH_HEIGHT,
+                )
+            )
+
+    def mouse_position(self, pos):
+        """update component according to on mouse move"""
+        select = None
+        pos = pos - self.pos()
+        for idx, rect in enumerate(self._rects):
+            if pos.x() > rect.x() and pos.x() < (rect.x() + rect.width()):
+                if pos.y() > rect.y() and pos.y() < (rect.y() + rect.height()):
+                    select = idx
+                    break
+        self.component.select(select)
+        self.repaint()
+
+    def single_click_action(self):
+        self.component.toggle()
+        self.repaint()
+
+    def _paint_dip_switch(self, painter):
+        pen = QPen()
+        pen.setColor(Qt.black)
+        pen.setWidth(1)
+        painter.setPen(pen)
+        select_id = self.component.selected()
+        for idx, rect in enumerate(self._rects):
+            painter.setBrush(Qt.darkGray)
+            painter.drawRect(rect)
+            if select_id == idx:
+                painter.setBrush(Qt.green)
+            else:
+                painter.setBrush(Qt.white)
+            if self.component.is_set(idx):
+                painter.drawRect(
+                    rect.x() + rect.width() / 2 + 1,
+                    rect.y() + 1,
+                    rect.width() / 2 - 2,
+                    rect.height() - 2,
+                )
+            else:
+                painter.drawRect(
+                    rect.x() + 1, rect.y() + 1, rect.width() / 2 - 2, rect.height() - 2
+                )
+        painter.setFont(self._DIP_SWITCH_FONT)
+        painter.setPen(Qt.white)
+        for idx, rect in enumerate(self._rects):
+            port_str = f"{idx + 1}"
+            str_pixels_w, _ = self.get_string_metrics(port_str, self._DIP_SWITCH_FONT)
+            painter.drawText(
+                QPoint(rect.x() - str_pixels_w - 4, rect.y() + rect.height() - 1), port_str
+            )
+
+        _, str_h = self.get_string_metrics("ON", self._DIP_SWITCH_FONT)
+        painter.drawText(
+            self.rect().x() + self.rect().width() / 2,
+            self.rect().y() + self.BORDER_TO_PORT - str_h,
+            "ON",
+        )
+
+    def _portlist(self):
+        return self.component.outports()
+
+    def paint(self, painter, option, widget=None):
+        """QT function"""
+        self.paint_component_base(painter, color=Qt.red)
+        self._paint_dip_switch(painter)

digsim/app/gui_objects/_gui_note_object.py

@@ -0,0 +1,80 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A GUI note object"""
+
+from PySide6.QtCore import QPoint, QRect, Qt
+from PySide6.QtGui import QFont, QFontMetrics, QPen
+
+from ._component_object import ComponentObject
+
+
+class GuiNoteObject(ComponentObject):
+    """The class for a note placed in the GUI"""
+
+    NOTE_BORDER = 10
+    NOTE_MINIMUM_WIDTH = 50
+    NOTE_MINIMUM_HEIGHT = 20
+
+    _NOTE_FONT = QFont("Arial", 8)
+    _NOTE_PEN = QPen(Qt.black)
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.update_size()
+
+    def _get_lines(self):
+        return self.component.parameter_get("text").split("\n")
+
+    def update_size(self):
+        fm = QFontMetrics(self._NOTE_FONT)
+        width = self.NOTE_MINIMUM_WIDTH
+        lines = self._get_lines()
+        for line in lines:
+            str_pixels_w = fm.horizontalAdvance(line)
+            width = max(width, str_pixels_w)
+        self.width = width + 2 * self.NOTE_BORDER
+        self.height = max(
+            self.NOTE_MINIMUM_HEIGHT,
+            2 * self.NOTE_BORDER + len(lines) * fm.height(),
+        )
+
+    def paint_component(self, painter):
+        """Paint note rectangle"""
+        fm = QFontMetrics(self._NOTE_FONT)
+        lines = self._get_lines()
+        pen = self._NOTE_PEN
+        if self.selected:
+            pen.setWidth(4)
+        else:
+            pen.setWidth(1)
+        painter.setPen(pen)
+        painter.setBrush(Qt.SolidPattern)
+        painter.setBrush(Qt.yellow)
+        painter.drawRect(self.rect())
+        painter.setFont(self._NOTE_FONT)
+        for idx, line in enumerate(lines):
+            painter.drawText(
+                self.object_pos.x() + self.NOTE_BORDER,
+                self.object_pos.y() + self.NOTE_BORDER + (idx + 1) * fm.height(),
+                line,
+            )
+
+    @classmethod
+    def paint_selectable_component(cls, painter, size, name):
+        note_rect = QRect(
+            cls.NOTE_BORDER,
+            cls.NOTE_BORDER,
+            size.width() - 2 * cls.NOTE_BORDER,
+            size.width() - 2 * cls.NOTE_BORDER,
+        )
+        pen = cls._NOTE_PEN
+        pen.setWidth(1)
+        painter.setPen(pen)
+        painter.setBrush(Qt.SolidPattern)
+        painter.setBrush(Qt.yellow)
+        painter.drawRect(note_rect)
+        painter.setFont(cls._NOTE_FONT)
+        fm = QFontMetrics(cls._NOTE_FONT)
+        painter.drawText(2 * cls.NOTE_BORDER, 2 * cls.NOTE_BORDER + fm.height(), "abc..")
+        cls.paint_selectable_component_name(painter, QPoint(0, 0), size, name)

digsim/app/gui_objects/_gui_object_factory.py

@@ -0,0 +1,80 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A GUI component object factory module"""
+
+from digsim.circuit.components.atoms import DigsimException
+
+from ._bus_bit_object import BitsBusObject, BusBitsObject
+from ._buzzer_object import BuzzerObject
+from ._dip_switch_object import DipSwitchObject
+from ._gui_note_object import GuiNoteObject
+from ._hexdigit_object import HexDigitObject
+from ._image_objects import (
+    ImageObjectAND,
+    ImageObjectClock,
+    ImageObjectDFF,
+    ImageObjectFlipFlop,
+    ImageObjectIC,
+    ImageObjectLed,
+    ImageObjectMUX,
+    ImageObjectNAND,
+    ImageObjectNOR,
+    ImageObjectNOT,
+    ImageObjectOR,
+    ImageObjectStaticValue,
+    ImageObjectXOR,
+)
+from ._label_object import LabelObject
+from ._logic_analyzer_object import LogicAnalyzerObject
+from ._seven_segment_object import SevenSegmentObject
+from ._shortcut_objects import ButtonObject, OnOffSwitchObject
+from ._yosys_object import YosysObject
+
+
+class ComponentObjectFactoryError(DigsimException):
+    """ComponentObjectFactoryError"""
+
+
+CLASS_NAME_TO_COMPONENT_OBJECT = {
+    "AND": ImageObjectAND,
+    "Bus2Wires": BusBitsObject,
+    "Wires2Bus": BitsBusObject,
+    "Clock": ImageObjectClock,
+    "DipSwitch": DipSwitchObject,
+    "DFF": ImageObjectDFF,
+    "HexDigit": HexDigitObject,
+    "LabelWireIn": LabelObject,
+    "LabelWireOut": LabelObject,
+    "Led": ImageObjectLed,
+    "LogicAnalyzer": LogicAnalyzerObject,
+    "NAND": ImageObjectNAND,
+    "NOR": ImageObjectNOR,
+    "NOT": ImageObjectNOT,
+    "MUX": ImageObjectMUX,
+    "OR": ImageObjectOR,
+    "OnOffSwitch": OnOffSwitchObject,
+    "PushButton": ButtonObject,
+    "SevenSegment": SevenSegmentObject,
+    "StaticValue": ImageObjectStaticValue,
+    "XOR": ImageObjectXOR,
+    "IntegratedCircuit": ImageObjectIC,
+    "YosysComponent": YosysObject,
+    "Note": GuiNoteObject,
+    "FlipFlop": ImageObjectFlipFlop,
+    "SRFF": ImageObjectFlipFlop,
+    "ClockedSRFF": ImageObjectFlipFlop,
+    "ClockedJKFF": ImageObjectFlipFlop,
+    "ClockedTFF": ImageObjectFlipFlop,
+    "Buzzer": BuzzerObject,
+}
+
+
+def class_factory(component_class_name):
+    """A function that returns the GUI for a component class (str or class)"""
+
+    if component_class_name in CLASS_NAME_TO_COMPONENT_OBJECT:
+        return CLASS_NAME_TO_COMPONENT_OBJECT[component_class_name]
+
+    # Raise exception if component not found
+    raise ComponentObjectFactoryError(f"Unknown component '{component_class_name}'")

digsim/app/gui_objects/_hexdigit_object.py

@@ -0,0 +1,53 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A hexdigit component placed in the GUI"""
+
+from ._component_object import ComponentObject
+from ._seven_segment_object import SevenSegmentObject
+
+
+class HexDigitObject(SevenSegmentObject):
+    """The class for a hexdigit component placed in the GUI"""
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(
+            app_model,
+            component,
+            xpos,
+            ypos,
+            port_distance=ComponentObject.DEFAULT_PORT_TO_PORT_DISTANCE,
+        )
+
+    def setup_size(self):
+        """Setup the size of the component"""
+        self.digits = self.component.get_digits()
+        str_pixels_w, _ = self.get_string_metrics(f"val[{4 * self.digits - 1}:0]")
+        self.digit_left = self.inport_x_pos() + str_pixels_w + self.PORT_TO_RECT_MARGIN
+        self.digit_top = self.RECT_TO_DIGIT_RECT_MARGIN
+        self.width = (
+            self.digit_left + self.digits * self.DIGIT_WIDTH + self.RECT_TO_DIGIT_RECT_MARGIN
+        )
+        self.height = 2 * self.RECT_TO_DIGIT_RECT_MARGIN + self.DIGIT_HEIGHT
+        self.update_ports()
+
+    def paint_component(self, painter):
+        self.paint_component_base(painter)
+        self.paint_digit_rect(
+            painter,
+            self.object_pos.x() + self.digit_left,
+            self.object_pos.y() + self.RECT_TO_DIGIT_RECT_MARGIN,
+            self.digits,
+        )
+        for digit_id in range(self.digits):
+            active_segments = self.component.segments(digit_id)
+            self.draw_digit(
+                painter,
+                self.object_pos.x() + self.digit_left + self.DIGIT_WIDTH * digit_id,
+                self.object_pos.y() + self.digit_top,
+                active_segments,
+            )
+
+    @classmethod
+    def paint_selectable_component(cls, painter, size, name):
+        cls.paint_selectable_digit(painter, size, name, "ABDEG")

digsim/app/gui_objects/_image_objects.py

@@ -0,0 +1,239 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A component with an image as symbol the GUI"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from PySide6.QtCore import QPoint, Qt
+from PySide6.QtGui import QFont, QPen, QPixmap
+
+from ._component_object import ComponentObject
+
+
+class ImageObject(ComponentObject):
+    """The class for a image component placed in the GUI"""
+
+    IMAGE_FILENAME: str | None = None
+    ACTIVE_IMAGE_FILENAME: str | None = None
+    _pixmap = None
+    _pixmap_active = None
+
+    def __init__(
+        self,
+        app_model,
+        component,
+        xpos,
+        ypos,
+        port_distance=ComponentObject.DEFAULT_PORT_TO_PORT_DISTANCE,
+    ):
+        super().__init__(app_model, component, xpos, ypos, port_distance=port_distance)
+        self._show_name = True
+        self.setup_size()
+        self.update_ports()
+
+    def show_name(self, enable):
+        """Enable/Disable name on image component"""
+        self._show_name = enable
+
+    def setup_size(self):
+        """Change size of component"""
+
+    @classmethod
+    def _get_pixmaps(cls):
+        """Load the pixmap at first use"""
+        if cls.ACTIVE_IMAGE_FILENAME is not None and cls._pixmap_active is None:
+            cls._pixmap_active = QPixmap(Path(__file__).parent / cls.ACTIVE_IMAGE_FILENAME)
+        if cls.IMAGE_FILENAME is not None and cls._pixmap is None:
+            cls._pixmap = QPixmap(Path(__file__).parent / cls.IMAGE_FILENAME)
+
+    def paint_component(self, painter):
+        self.paint_component_base(painter)
+        self._get_pixmaps()
+        xpos = self.size.width() / 2 - self._pixmap.width() / 2
+        ypos = self.size.height() / 2 - self._pixmap.height() / 2
+        self.paint_pixmap(
+            painter, self.object_pos.x() + xpos, self.object_pos.y() + ypos, self.component.active
+        )
+        if self._show_name:
+            self.paint_selectable_component_name(
+                painter, self.object_pos, self.size, self.component.display_name()
+            )
+
+    @classmethod
+    def paint_selectable_component(cls, painter, size, name):
+        cls.paint_selectable_component_name(painter, QPoint(0, 0), size, name)
+        cls._get_pixmaps()
+        xpos = size.width() / 2 - cls._pixmap.width() / 2
+        ypos = size.width() / 2 - cls._pixmap.height() / 2
+        cls.paint_pixmap(painter, xpos, ypos)
+
+    @classmethod
+    def paint_pixmap(cls, painter, xpos, ypos, active=False):
+        """Paint the pixmap"""
+        pixmap = cls._pixmap_active if active and cls._pixmap_active is not None else cls._pixmap
+        painter.drawPixmap(QPoint(xpos, ypos), pixmap)
+
+
+class GateImageObject(ImageObject):
+    """The base class for gate components placed in the GUI"""
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.paint_port_names(False)
+
+
+class ImageObjectAND(GateImageObject):
+    """The class for a AND image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/AND.png"
+
+
+class ImageObjectOR(GateImageObject):
+    """The class for a OR image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/OR.png"
+
+
+class ImageObjectNAND(GateImageObject):
+    """The class for a NAND image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/NAND.png"
+
+
+class ImageObjectNOR(GateImageObject):
+    """The class for a NOR image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/NOR.png"
+
+
+class ImageObjectNOT(GateImageObject):
+    """The class for a NOR image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/NOT.png"
+
+
+class ImageObjectXOR(GateImageObject):
+    """The class for a XOR image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/XOR.png"
+
+
+class ImageObjectDFF(ImageObject):
+    """The class for a DFF image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/DFF.png"
+    PORT_TO_IMAGE_DIST = 20
+
+    def setup_size(self):
+        self._get_pixmaps()
+        str_pixels_w, _ = self.get_string_metrics("D")
+        self.width = 2 * (str_pixels_w + self.PORT_TO_IMAGE_DIST) + self._pixmap.width()
+
+
+class ImageObjectFlipFlop(ImageObject):
+    """The class for a FlipFLop image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/FlipFlop.png"
+    PORT_TO_IMAGE_DIST = 20
+
+    def paint_component(self, painter):
+        self.paint_component_base(painter)
+        self.paint_component_name(painter)
+
+
+class ImageObjectMUX(ImageObject):
+    """The class for a MUX image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/MUX.png"
+    PORT_TO_IMAGE_DIST = 20
+
+    def setup_size(self):
+        self._get_pixmaps()
+        if self.component.port("A").width == 1:
+            str_pixels_w, _ = self.get_string_metrics("A")
+        else:
+            str_pixels_w, _ = self.get_string_metrics("A[31:0]")
+        self.width = 2 * (str_pixels_w + self.PORT_TO_IMAGE_DIST) + self._pixmap.width()
+
+
+class ImageObjectStaticValue(ImageObject):
+    """The class for a StaticValue image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/ZERO.png"
+    ACTIVE_IMAGE_FILENAME = "images/ONE.png"
+
+    _STATIC_VALUE_FONT = QFont("Arial", 16)
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.show_name(False)
+
+    def paint_component(self, painter):
+        if self.component.O.width == 1:
+            super().paint_component(painter)
+        else:
+            self.paint_component_base(painter)
+            value_str = f"{self.component.parameter_get('value')}"
+            str_w, str_h = self.get_string_metrics(value_str, font=self._STATIC_VALUE_FONT)
+            painter.setFont(self._STATIC_VALUE_FONT)
+            painter.drawText(
+                self.rect().x() + self.rect().width() / 2 - str_w / 2,
+                self.rect().y() + str_h,
+                value_str,
+            )
+
+
+class ImageObjectLed(ImageObject):
+    """The class for a Led image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/LED_OFF.png"
+    ACTIVE_IMAGE_FILENAME = "images/LED_ON.png"
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.show_name(False)
+        self.paint_port_names(False)
+
+
+class ImageObjectIC(ImageObject):
+    """The class for a Yosys image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/IC.png"
+
+    def paint_component(self, painter):
+        self.paint_component_base(painter)
+        self.paint_component_name(painter)
+
+
+class ImageObjectWithActiveRect(ImageObject):
+    """
+    A base class for a image component placed in the GUI.
+    When active the image will have a green border painted around it.
+    """
+
+    _ACTIVE_RECT_PEN = QPen(Qt.green)
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.show_name(False)
+        self.paint_port_names(False)
+
+    def paint_component(self, painter):
+        super().paint_component(painter)
+        if self.component.active:
+            xpos = self.object_pos.x() + self.size.width() / 2 - self._pixmap.width() / 2
+            ypos = self.object_pos.y() + self.size.height() / 2 - self._pixmap.height() / 2
+            pen = self._ACTIVE_RECT_PEN
+            pen.setWidth(4)
+            painter.setPen(pen)
+            painter.setBrush(Qt.NoBrush)
+            painter.drawRoundedRect(xpos, ypos, self._pixmap.width(), self._pixmap.height(), 5, 5)
+
+
+class ImageObjectClock(ImageObjectWithActiveRect):
+    """The class for a Clock image component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/Clock.png"