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

digsim/app/gui/_warning_dialog.py

@@ -0,0 +1,46 @@
+# Copyright (c) Fredrik Andersson, 2023-2024
+# All rights reserved
+
+"""A warning dialog"""
+
+from PySide6.QtCore import QSize, Qt
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QStyle,
+    QVBoxLayout,
+)
+
+
+class WarningDialog(QDialog):
+    """WarningDialog"""
+
+    def __init__(self, parent, title, warning_message):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.setLayout(QVBoxLayout(self))
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.setStyleSheet("QLabel{font-size: 18pt;}")
+        frame = QFrame(parent)
+        frame.setLayout(QHBoxLayout(frame))
+        frame.setFrameShape(QFrame.StyledPanel)
+        frame.setFrameShadow(QFrame.Sunken)
+        label = QLabel()
+        label.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+        label.setText(warning_message)
+        icon = self.style().standardIcon(QStyle.SP_MessageBoxWarning)
+        button = QLabel()
+        button.setPixmap(icon.pixmap(QSize(32, 32)))
+        frame.layout().addWidget(button)
+        frame.layout().setStretchFactor(label, 0)
+        frame.layout().addWidget(label)
+        frame.layout().setStretchFactor(label, 1)
+        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
+        buttonBox.accepted.connect(self.accept)
+        self.layout().addWidget(frame)
+        self.layout().setStretchFactor(frame, 1)
+        self.layout().addWidget(buttonBox)
+        self.layout().setStretchFactor(buttonBox, 0)

digsim/app/gui_objects/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""All classes within digsim.app.gui_object namespace"""
+
+from ._component_object import ComponentObject  # noqa: F401
+from ._gui_object_factory import class_factory  # noqa: F401

digsim/app/gui_objects/_bus_bit_object.py

@@ -0,0 +1,94 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A hexdigit component placed in the GUI"""
+
+from PySide6.QtCore import QPoint, QSize, Qt
+from PySide6.QtGui import QPen
+
+from ._component_object import ComponentObject
+
+
+class BusBitsObject(ComponentObject):
+    """The class for a bus/bit component placed in the GUI"""
+
+    WIRE_LENGTH_COMPONENT = 5
+    WIRE_LENGTH_SELECTABLE = 15
+    PORT_DISTANCE = 10
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos, port_distance=self.PORT_DISTANCE)
+        bus_w, _ = self.get_string_metrics("bus[31:0]")
+        self.width = 2 * self.inport_x_pos() + 2 * bus_w + abs(2 * self.WIRE_LENGTH_COMPONENT)
+        self.update_ports()
+
+    @classmethod
+    def _paint_bus_bit(cls, painter, pos, size, wire_length, bit_wires_y):
+        center_pos = QPoint(size.width() / 2, size.height() / 2)
+        pen = QPen()
+        pen.setWidth(4)
+        pen.setColor(Qt.black)
+        painter.setPen(pen)
+        line_height = size.height() - cls.BORDER_TO_PORT
+        painter.drawLine(
+            pos.x() + center_pos.x(),
+            pos.y() + center_pos.y() - line_height / 2,
+            pos.x() + center_pos.x(),
+            pos.y() + center_pos.y() + line_height / 2,
+        )
+        painter.drawLine(
+            pos.x() + center_pos.x() - wire_length,
+            pos.y() + center_pos.y(),
+            pos.x() + center_pos.x(),
+            pos.y() + center_pos.y(),
+        )
+        pen.setWidth(2)
+        painter.setPen(pen)
+        for wire_y in bit_wires_y:
+            painter.drawLine(
+                pos.x() + center_pos.x() + wire_length, wire_y, pos.x() + center_pos.x(), wire_y
+            )
+
+    def _portlist(self):
+        return self.component.outports()
+
+    def paint_component(self, painter):
+        self.paint_component_base(painter)
+        bit_wires_y = []
+        for port in self._portlist():
+            bit_wires_y.append(self.get_port_pos(port.name()).y())
+        self._paint_bus_bit(
+            painter,
+            self.object_pos,
+            self.rect(),
+            self.WIRE_LENGTH_COMPONENT,
+            bit_wires_y,
+        )
+
+    @classmethod
+    def paint_selectable_component(cls, painter, size, name):
+        image_size = QSize(size.width(), size.width())
+        bit_wires_y = [
+            size.width() / 2 - 3 * size.width() / 12,
+            size.width() / 2 - 1 * size.width() / 12,
+            size.width() / 2 + 1 * size.width() / 12,
+            size.width() / 2 + 3 * size.width() / 12,
+        ]
+        cls._paint_bus_bit(
+            painter,
+            QPoint(0, 0),
+            image_size,
+            cls.WIRE_LENGTH_SELECTABLE,
+            bit_wires_y,
+        )
+        cls.paint_selectable_component_name(painter, QPoint(0, 0), size, name)
+
+
+class BitsBusObject(BusBitsObject):
+    """The class for a bit/bit component placed in the GUI"""
+
+    WIRE_LENGTH_COMPONENT = -5
+    WIRE_LENGTH_SELECTABLE = -15
+
+    def _portlist(self):
+        return self.component.inports()

digsim/app/gui_objects/_buzzer_object.py

@@ -0,0 +1,97 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A buzzer component object"""
+
+from math import pi, sin
+from struct import pack
+
+from PySide6.QtCore import QByteArray, QIODevice
+from PySide6.QtMultimedia import QAudioFormat, QAudioSink, QMediaDevices
+
+from ._image_objects import ImageObjectWithActiveRect
+
+
+class _AudioOutput(QIODevice):
+    def __init__(self, audio_format, tone_hz):
+        super().__init__()
+
+        self.pos = 0
+        self.audio_buffer = QByteArray()
+        self.audio_buffer.clear()
+
+        factor = 2 * pi * tone_hz / audio_format.sampleRate()
+        channel_bytes = audio_format.bytesPerSample()
+        length = audio_format.sampleRate() * audio_format.channelCount() * channel_bytes
+
+        sample_index = 0
+        while length > 0:
+            x = 32767 * sin((sample_index % audio_format.sampleRate()) * factor)
+            packed = pack("<h", int(x))
+            for _ in range(audio_format.channelCount()):
+                self.audio_buffer.append(packed)
+                length -= channel_bytes
+            sample_index += 1
+        self.open(QIODevice.ReadOnly)
+
+    def readData(self, maxlen):
+        """Read function"""
+        data = QByteArray()
+        total = 0
+        while maxlen > total:
+            chunk = min(self.audio_buffer.size() - self.pos, maxlen - total)
+            data.append(self.audio_buffer.mid(self.pos, chunk))
+            self.pos = (self.pos + chunk) % self.audio_buffer.size()
+            total += chunk
+
+        return data.data()
+
+    def writeData(self, _):
+        """Write function"""
+        return 0
+
+    def bytesAvailable(self):
+        """Byteas available function"""
+        return self.audio_buffer.size() + super().bytesAvailable()
+
+
+class BuzzerObject(ImageObjectWithActiveRect):
+    """The class for Buzzer component placed in the GUI"""
+
+    IMAGE_FILENAME = "images/Buzzer.png"
+    DATA_SAMPLE_RATE_HZ = 44100
+
+    def __init__(self, app_model, component, xpos, ypos):
+        super().__init__(app_model, component, xpos, ypos)
+        self.audio_sink = None
+        self._app_model.sig_audio_start.connect(self._audio_start)
+        self._app_model.sig_audio_notify.connect(self._audio_notify)
+        self.device = QMediaDevices.defaultAudioOutput()
+        self.audio_format = QAudioFormat()
+        self.audio_format.setSampleRate(self.DATA_SAMPLE_RATE_HZ)
+        self.audio_format.setChannelCount(1)
+        self.audio_format.setSampleFormat(QAudioFormat.Int16)
+        self.audio_output = _AudioOutput(self.audio_format, self.component.tone_frequency())
+
+    def _audio_start(self, enable):
+        if enable:
+            self._play(self.component.active)
+        else:
+            self._play(False)
+
+    def _audio_notify(self, component):
+        if component == self.component:
+            self._play(component.active)
+
+    def _play(self, active):
+        if self.device is None:
+            return
+        if active:
+            if self.audio_sink is None:
+                self.audio_sink = QAudioSink(self.device, self.audio_format)
+                self.audio_sink.setVolume(0.1)
+            self.audio_sink.start(self.audio_output)
+        else:
+            if self.audio_sink is not None:
+                self.audio_sink.stop()
+                self.audio_sink = None

digsim/app/gui_objects/_component_context_menu.py

@@ -0,0 +1,79 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A component context menu"""
+
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMenu
+
+from digsim.app.settings import ComponentSettingsDialog
+
+
+class ComponentContextMenu(QMenu):
+    """The component contextmenu class"""
+
+    def __init__(self, parent, app_model, component_object):
+        super().__init__(parent)
+        self._parent = parent
+        self._app_model = app_model
+        self._component_object = component_object
+        self._component = self._component_object.component
+        self._reconfigurable_parameters = {}
+        # Title
+        titleAction = QAction(self._component.display_name(), self)
+        titleAction.setEnabled(False)
+        self.addAction(titleAction)
+        self.addSeparator()
+        # Settings
+        self._add_settings()
+        self._component_object.add_context_menu_action(self, parent)
+        self.addSeparator()
+        # Bring to front / Send to back
+        raiseAction = QAction("Bring to front", self)
+        self.addAction(raiseAction)
+        raiseAction.triggered.connect(self._raise)
+        lowerAction = QAction("Send to back", self)
+        self.addAction(lowerAction)
+        lowerAction.triggered.connect(self._lower)
+        self.addSeparator()
+        # Delete
+        deleteAction = QAction("Delete", self)
+        self.addAction(deleteAction)
+        deleteAction.triggered.connect(self._delete)
+        self._menu_action = None
+
+    def _add_settings(self):
+        self._reconfigurable_parameters = self._component.get_reconfigurable_parameters()
+        if len(self._reconfigurable_parameters) > 0:
+            settingsAction = QAction("Settings", self)
+            self.addAction(settingsAction)
+            settingsAction.triggered.connect(self._settings)
+
+    def create(self, position):
+        """Create context menu for component"""
+        self._menu_action = self.exec_(position)
+
+    def get_action(self):
+        """Get context menu action"""
+        return self._menu_action.text() if self._menu_action is not None else ""
+
+    def _delete(self):
+        self._component_object.setSelected(True)
+        self._app_model.objects.delete_selected()
+
+    def _raise(self):
+        self._app_model.objects.components.bring_to_front(self._component_object)
+
+    def _lower(self):
+        self._app_model.objects.components.send_to_back(self._component_object)
+
+    def _settings(self):
+        """Start the settings dialog for reconfiguration"""
+        ok, settings = ComponentSettingsDialog.start(
+            self._parent,
+            self._app_model,
+            self._component.name(),
+            self._reconfigurable_parameters,
+        )
+        if ok:
+            self._app_model.objects.components.update_settings(self._component_object, settings)

digsim/app/gui_objects/_component_object.py

@@ -0,0 +1,374 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""A component placed in the GUI"""
+
+import abc
+
+from PySide6.QtCore import QPoint, QRect, QSize, Qt
+from PySide6.QtGui import QFont, QFontMetrics, QPen
+from PySide6.QtWidgets import QGraphicsItem, QGraphicsRectItem
+
+from digsim.storage_model import GuiPositionDataClass
+
+from ._component_context_menu import ComponentContextMenu
+from ._component_port_item import PortGraphicsItem
+
+
+class ComponentObject(QGraphicsRectItem):
+    """A component graphics item, a 'clickable' item with a custom paintEvent"""
+
+    DEFAULT_WIDTH = 80
+    DEFAULT_HEIGHT = 80
+    RECT_TO_BORDER = 5
+    BORDER_TO_PORT = 25
+    PORT_SIDE = 8
+    DEFAULT_PORT_TO_PORT_DISTANCE = 20
+
+    _COMPONENT_NAME_FONT = QFont("Arial", 10)
+    _PORT_NAME_FONT = QFont("Arial", 8)
+    _SELECTABLE_COMPONENT_NAME_FONT = QFont("Arial", 8)
+
+    def __init__(
+        self, app_model, component, xpos, ypos, port_distance=DEFAULT_PORT_TO_PORT_DISTANCE
+    ):
+        super().__init__(QRect(xpos, ypos, self.DEFAULT_WIDTH, self.DEFAULT_HEIGHT))
+        self._app_model = app_model
+        self._component = component
+        self._port_distance = port_distance
+
+        # Signals
+        self._app_model.sig_control_notify.connect(self._control_notify)
+
+        # Class variables
+        self._port_dict = {}
+        self._parent_widget = None
+        self._mouse_press_pos = None
+        self._moved = False
+        self._paint_port_names = True
+        self._save_pos = self.rect().topLeft()
+
+        # Create ports
+        self.create_ports()
+
+        # Qt Flags
+        self.setFlag(QGraphicsItem.ItemIsMovable, True)
+        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
+        self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
+        self.setAcceptHoverEvents(True)
+
+    def _control_notify(self):
+        if self._app_model.is_running:
+            self.setFlag(QGraphicsItem.ItemIsMovable, False)
+            self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, False)
+        else:
+            self.setFlag(QGraphicsItem.ItemIsMovable, True)
+            self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
+
+    def itemChange(self, change, value):
+        """QT event callback function"""
+        if change == QGraphicsItem.ItemPositionHasChanged:
+            self._moved = True
+        elif change == QGraphicsItem.ItemSelectedChange:
+            if self._app_model.is_running:
+                value = 0
+        elif change == QGraphicsItem.ItemSelectedHasChanged:
+            self.repaint()
+        return super().itemChange(change, value)
+
+    def hoverEnterEvent(self, _):
+        """QT event callback function"""
+        if self._app_model.is_running and self.component.has_action:
+            self.setCursor(Qt.PointingHandCursor)
+
+    def hoverLeaveEvent(self, _):
+        """QT event callback function"""
+        self.setCursor(Qt.ArrowCursor)
+
+    def hoverMoveEvent(self, event):
+        """QT event callback function"""
+        self.mouse_position(event.scenePos())
+        super().hoverMoveEvent(event)
+
+    def mousePressEvent(self, event):
+        """QT event callback function"""
+        super().mousePressEvent(event)
+        if event.button() == Qt.LeftButton:
+            if self._app_model.is_running:
+                self._app_model.model_add_event(self.component.onpress)
+            else:
+                self._mouse_press_pos = event.screenPos()
+                self.setCursor(Qt.ClosedHandCursor)
+
+    def mouseReleaseEvent(self, event):
+        """QT event callback function"""
+        super().mouseReleaseEvent(event)
+        if event.button() == Qt.LeftButton:
+            if self._app_model.is_running:
+                self._app_model.model_add_event(self.component.onrelease)
+            else:
+                self.setCursor(Qt.ArrowCursor)
+                if event.screenPos() != self._mouse_press_pos:
+                    # Move completed, set model to changed
+                    self._app_model.objects.components.component_moved()
+                    position = self.rect().topLeft() + self.pos()
+                    self._save_pos = position.toPoint()
+                else:
+                    if not self._app_model.objects.new_wire.ongoing():
+                        self.single_click_action()
+        self._mouse_press_pos = None
+
+    def contextMenuEvent(self, event):
+        """QT event callback function"""
+        if self._app_model.is_running:
+            return
+        if self._app_model.objects.new_wire.ongoing():
+            self._app_model.objects.new_wire.abort()
+        context_menu = ComponentContextMenu(self._parent_widget, self._app_model, self)
+        context_menu.create(event.screenPos())
+
+    def paint(self, painter, option, widget=None):
+        """QT function"""
+        self.paint_component(painter)
+        if self._paint_port_names:
+            self.paint_portnames(painter)
+
+    @property
+    def component(self):
+        """Get component"""
+        return self._component
+
+    def paint_port_names(self, enable):
+        """Enable/Disable paint port names"""
+        self._paint_port_names = enable
+
+    def has_moved(self):
+        """True if the component has moved since last call"""
+        moved = self._moved
+        self._moved = False
+        return moved
+
+    def create_ports(self):
+        """Create ports for component object"""
+        for port in self._component.ports:
+            self._port_dict[port] = {}
+            if port.width == 1:
+                self._port_dict[port]["name"] = port.name()
+            else:
+                self._port_dict[port]["name"] = f"{port.name()}[{port.width - 1}:0]"
+            item = PortGraphicsItem(self._app_model, self, port)
+            self._port_dict[port]["item"] = item
+        self.update_ports()
+
+    def update_ports(self):
+        """Update port positions for the placed component"""
+
+        # Make sure all ports are fit in the hieght of the component
+        max_ports = max(len(self._component.inports()), len(self._component.outports()))
+        if max_ports > 1:
+            min_height = (max_ports - 1) * self._port_distance + 2 * self.BORDER_TO_PORT
+            self.height = max(self.height, min_height)
+
+        # Make sure port names fit in the width of the component
+        max_inport_name = ""
+        max_outport_name = ""
+        for port in self.component.ports:
+            port_name = self._port_dict[port]["name"]
+            if port.is_input() and len(port_name) > len(max_inport_name):
+                max_inport_name = port_name
+            elif not port.is_input() and len(port_name) > len(max_outport_name):
+                max_outport_name = port_name
+        max_port_names = f"{max_inport_name} {max_outport_name}"
+        max_port_names_w, _ = self.get_string_metrics(max_port_names)
+        self.width = max(2 * self.inport_x_pos() + max_port_names_w, self.width)
+
+        # Create port rects
+        self._set_port_rects(self._component.inports(), -self.RECT_TO_BORDER)
+        self._set_port_rects(
+            self._component.outports(), self.RECT_TO_BORDER + self.width - self.PORT_SIDE - 1
+        )
+
+    def get_port_item(self, port):
+        """Get port item"""
+        return self._port_dict[port]["item"]
+
+    def set_port_rect(self, port, rect):
+        """Set port rect"""
+        self.get_port_item(port).setRect(rect)
+
+    def _set_port_rects(self, ports, xpos):
+        if len(ports) == 1:
+            rect = QRect(
+                self.object_pos.x() + xpos,
+                self.object_pos.y() + self.height / 2 - self.PORT_SIDE / 2,
+                self.PORT_SIDE,
+                self.PORT_SIDE,
+            )
+            self.get_port_item(ports[0]).setRect(rect)
+        elif len(ports) > 1:
+            top_to_port = (self.height - self._port_distance * (len(ports) - 1)) / 2
+            for idx, port in enumerate(ports):
+                rect = QRect(
+                    self.object_pos.x() + xpos,
+                    self.object_pos.y()
+                    + top_to_port
+                    + idx * self._port_distance
+                    - self.PORT_SIDE / 2,
+                    self.PORT_SIDE,
+                    self.PORT_SIDE,
+                )
+                self.get_port_item(port).setRect(rect)
+
+    def set_parent_widget(self, parent):
+        """Set the parent"""
+        self._parent_widget = parent
+
+    @property
+    def selected(self):
+        """Get the selected variable for the current object"""
+        return self.isSelected()
+
+    def repaint(self):
+        """Update GUI for this component object"""
+        self._app_model.sig_repaint.emit()
+
+    def get_string_metrics(self, port_str, font=QFont("Arial", 8)):
+        """Get the port display name (including bits if available)"""
+        fm = QFontMetrics(font)
+        str_pixels_w = fm.horizontalAdvance(port_str)
+        str_pixels_h = fm.height()
+        return str_pixels_w, str_pixels_h
+
+    def paint_component_name(self, painter):
+        """Paint the component name"""
+        painter.setFont(self._COMPONENT_NAME_FONT)
+        fm = QFontMetrics(self._COMPONENT_NAME_FONT)
+        display_name_str = self._component.display_name()
+        str_pixels_w = fm.horizontalAdvance(display_name_str)
+        str_pixels_h = fm.height()
+        painter.drawText(
+            self.rect().x() + self.rect().width() / 2 - str_pixels_w / 2,
+            self.rect().y() + str_pixels_h,
+            display_name_str,
+        )
+
+    def paint_component_base(self, painter, color=Qt.gray):
+        """Paint component base rect"""
+        comp_rect = self.rect()
+        pen = QPen()
+        if self.selected:
+            pen.setWidth(4)
+        else:
+            pen.setWidth(1)
+        pen.setColor(Qt.black)
+        painter.setPen(pen)
+        painter.setBrush(Qt.SolidPattern)
+        painter.setBrush(color)
+        painter.drawRoundedRect(comp_rect, 5, 5)
+
+    @abc.abstractmethod
+    def paint_component(self, painter):
+        """Paint component"""
+
+    @classmethod
+    @abc.abstractmethod
+    def paint_selectable_component(cls, painter, size, name):
+        """
+        Paint selectable component
+        use width x width (square) to paint component image
+        """
+
+    @classmethod
+    def paint_selectable_component_name(cls, painter, point, size, name):
+        """Paint the name for the selectable component"""
+        painter.setFont(cls._SELECTABLE_COMPONENT_NAME_FONT)
+        fm = QFontMetrics(cls._SELECTABLE_COMPONENT_NAME_FONT)
+        str_pixels_w = fm.horizontalAdvance(name)
+        str_pixels_h = fm.height()
+        painter.setPen(Qt.black)
+        painter.drawText(
+            point.x() + size.width() / 2 - str_pixels_w / 2,
+            point.y() + size.height() - str_pixels_h,
+            name,
+        )
+
+    def inport_x_pos(self):
+        """Get the X position left of the input port"""
+        return 1.5 * self.PORT_SIDE
+
+    def paint_portnames(self, painter, color=Qt.black):
+        """Paint component ports"""
+        painter.setPen(color)
+        painter.setFont(self._PORT_NAME_FONT)
+        for port in self._component.ports:
+            rect = self.get_port_item(port).rect()
+            port_str = self._port_dict[port]["name"]
+            str_pixels_w, str_pixels_h = self.get_string_metrics(port_str, self._PORT_NAME_FONT)
+            text_y = rect.y() + str_pixels_h - self.PORT_SIDE / 2
+            if rect.x() < self.object_pos.x():
+                text_pos = QPoint(rect.x() + self.inport_x_pos(), text_y)
+            else:
+                text_pos = QPoint(rect.x() - str_pixels_w - self.PORT_SIDE / 2, text_y)
+            painter.drawText(text_pos, port_str)
+
+    def get_port_pos(self, portname):
+        """Get component port pos"""
+        port = self.component.port(portname)
+        return self.get_port_item(port).rect().center()
+
+    def mouse_position(self, pos):
+        """Component function: called for mouse position update"""
+
+    def single_click_action(self):
+        """Component function:: called for mouse single click"""
+
+    def add_context_menu_action(self, menu, parent):
+        """Component function:: called when context menu is created"""
+
+    def update_size(self):
+        """Component function: called when the component can update its size"""
+
+    @property
+    def size(self):
+        """Get size"""
+        return QSize(self.width, self.height)
+
+    @property
+    def object_pos(self):
+        """Get position"""
+        return self.rect().topLeft()
+
+    @property
+    def width(self):
+        """Get width"""
+        return self.rect().width()
+
+    @width.setter
+    def width(self, width):
+        """Set width"""
+        self.setRect(self.rect().x(), self.rect().y(), width, self.rect().height())
+
+    @property
+    def height(self):
+        """Get height"""
+        return self.rect().height()
+
+    @height.setter
+    def height(self, height):
+        """Set height"""
+        self.setRect(self.rect().x(), self.rect().y(), self.rect().width(), height)
+
+    @property
+    def zlevel(self):
+        """Get zlevel"""
+        return self.zValue()
+
+    @zlevel.setter
+    def zlevel(self, level):
+        """Set zlevel"""
+        self.setZValue(level)
+
+    def to_gui_dataclass(self):
+        return GuiPositionDataClass(
+            x=int(self._save_pos.x()), y=int(self._save_pos.y()), z=int(self.zlevel)
+        )