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

digsim/app/model/_model.py

@@ -0,0 +1,210 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""An application model for a GUI simulated circuit"""
+
+import queue
+import time
+from pathlib import Path
+
+from PySide6.QtCore import QThread, Signal
+
+from digsim.app.gui_objects import ComponentObject
+from digsim.circuit.components.atoms import Component
+from digsim.storage_model import AppFileDataClass
+
+from ._model_objects import ModelObjects
+from ._model_settings import ModelSettings
+from ._model_shortcuts import ModelShortcuts
+
+
+class AppModel(QThread):
+    """The application model class for a GUI simulated circuit"""
+
+    sig_audio_start = Signal(bool)
+    sig_audio_notify = Signal(Component)
+    sig_control_notify = Signal()
+    sig_sim_time_notify = Signal(float)
+    sig_synchronize_gui = Signal()
+    sig_repaint = Signal()
+    sig_update_wires = Signal()
+    sig_delete_component = Signal(ComponentObject)
+    sig_delete_wires = Signal()
+    sig_error = Signal(str)
+    sig_warning_log = Signal(str, str)
+    sig_zoom_in_gui = Signal()
+    sig_zoom_out_gui = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self._setup_model_components()
+        self._started = False
+        self._single_step = False
+        self._changed = False
+        self._gui_event_queue = queue.Queue()
+        self._multi_select = False
+
+    def _setup_model_components(self):
+        self._model_objects = ModelObjects(self)
+        self._model_shortcuts = ModelShortcuts(self)
+        self._model_settings = ModelSettings(self)
+
+    @property
+    def objects(self):
+        """return the model objects"""
+        return self._model_objects
+
+    @property
+    def shortcuts(self):
+        """return the model shortcuts"""
+        return self._model_shortcuts
+
+    @property
+    def settings(self):
+        """return the model settings"""
+        return self._model_settings
+
+    @property
+    def is_running(self):
+        """Return True if the simulation thread is running"""
+        return self._started
+
+    @property
+    def is_changed(self):
+        """Return True if there are changes in the model since last save"""
+        return self._changed
+
+    def _model_clear(self):
+        """Clear model"""
+        self.objects.clear()
+        self.shortcuts.clear()
+        self._changed = False
+
+    def model_init(self):
+        """(Re)initialize the model/circuit"""
+        self.objects.circuit.init()
+        self.objects.init()
+        self.sig_sim_time_notify.emit(0)
+
+    def model_start(self):
+        """Start model simulation thread"""
+        self.model_abort_wire()
+        self._started = True
+        self._single_step = False
+        self.start()
+        self.sig_control_notify.emit()
+
+    def model_single_step(self):
+        """Start model simulation thread"""
+        self._started = True
+        self._single_step = True
+        self.start()
+        self.sig_control_notify.emit()
+
+    def model_stop(self):
+        """Stop model simulation thread"""
+        self._started = False
+        self.wait()
+
+    def model_reset(self):
+        """Reset model simulation"""
+        if not self._started:
+            self.model_init()
+
+    def model_changed(self):
+        """Set changed to True, for example when gui has moved component"""
+        self._changed = True
+        self.sig_control_notify.emit()
+
+    def model_add_event(self, func):
+        """Add medel events (functions) from the GUI"""
+        self._gui_event_queue.put(func)
+
+    def model_abort_wire(self):
+        if self._model_objects.new_wire.ongoing():
+            self._model_objects.new_wire.abort()
+            self.sig_repaint.emit()
+
+    def run(self):
+        """Simulation thread run function"""
+        start_time = time.perf_counter()
+        next_tick = start_time
+        sim_tick_ms = 1000 / self._model_settings.get("update_frequency")
+        real_time = self._model_settings.get("real_time")
+        self.sig_audio_start.emit(True)
+        while self._started:
+            next_tick += sim_tick_ms / 1000
+
+            # Execute one GUI event at a time
+            if not self._gui_event_queue.empty():
+                gui_event_func = self._gui_event_queue.get()
+                gui_event_func()
+
+            single_step_stop = self.objects.circuit.run(
+                ms=sim_tick_ms, single_step=self._single_step
+            )
+            if single_step_stop:
+                self._started = False
+
+            self.objects.components.update_callback_objects()
+
+            if not self._single_step and real_time:
+                now = time.perf_counter()
+                sleep_time = next_tick - now
+                sleep_time = max(0.01, sleep_time)
+            else:
+                sleep_time = 0.01  # Sleep a little, to be able to handle event
+            time.sleep(sleep_time)
+
+            self.sig_sim_time_notify.emit(self.objects.circuit.time_ns / 1000000000)
+
+        self._single_step = False
+        self.sig_control_notify.emit()
+        self.sig_audio_start.emit(False)
+
+    def save_circuit(self, path):
+        """Save the circuit with GUI information"""
+        circuit_folder = str(Path(path).parent)
+        model_dataclass = self.objects.circuit_to_model(circuit_folder)
+        appfile_dataclass = AppFileDataClass(
+            circuit=model_dataclass.circuit,
+            gui=model_dataclass.gui,
+            shortcuts=self.shortcuts.to_dict(),
+            settings=self.settings.get_all(),
+        )
+        appfile_dataclass.save(path)
+        self._changed = False
+        self.sig_control_notify.emit()
+
+    def load_circuit(self, path):
+        """Load a circuit with GUI information"""
+        self._model_clear()
+        app_file_dc = AppFileDataClass.load(path)
+        circuit_folder = str(Path(path).parent)
+        if len(circuit_folder) == 0:
+            circuit_folder = "."
+        exception_str_list = self.objects.model_to_circuit(app_file_dc, circuit_folder)
+        self.shortcuts.from_dict(app_file_dc.shortcuts)
+        self.settings.from_dict(app_file_dc.settings)
+        self.model_init()
+        self._changed = False
+        self.objects.reset_undo_stack()
+        self.sig_synchronize_gui.emit()
+        self.sig_control_notify.emit()
+        if len(exception_str_list) > 0:
+            self.sig_warning_log.emit("Load Circuit Warning", "\n".join(exception_str_list))
+
+    def clear_circuit(self):
+        """Clear the circuit"""
+        self.objects.push_undo_state()
+        self._model_clear()
+        self.sig_synchronize_gui.emit()
+        self.sig_control_notify.emit()
+
+    def zoom_in(self):
+        """Send zoom in signal to GUI"""
+        self.sig_zoom_in_gui.emit()
+
+    def zoom_out(self):
+        """Send zoom out signal to GUI"""
+        self.sig_zoom_out_gui.emit()

digsim/app/model/_model_components.py

@@ -0,0 +1,162 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""Handle component objects in the model"""
+
+import digsim.circuit.components
+from digsim.app.gui_objects import ComponentObject
+from digsim.circuit.components import Buzzer
+from digsim.circuit.components.atoms import CallbackComponent
+from digsim.storage_model import GuiPositionDataClass
+
+
+class ModelComponents:
+    """Class to handle the component objects in the model"""
+
+    @staticmethod
+    def is_component_object(obj):
+        """Test if this object is a component object"""
+        return isinstance(obj, ComponentObject)
+
+    def __init__(self, app_model, circuit):
+        self._app_model = app_model
+        self._circuit = circuit
+        self._component_objects = {}
+        self._component_callback_list = []
+
+    def clear(self):
+        """Clear components objects"""
+        self._component_objects = {}
+
+    def init(self):
+        """Initialize components objects"""
+        self._app_model.sig_repaint.emit()
+
+    def get_dict(self):
+        """Get component objects dict"""
+        return self._component_objects
+
+    def is_empty(self):
+        """Return True if there are component objects in the model"""
+        return len(self._component_objects) == 0
+
+    def get_top_zlevel(self):
+        """Get thehighest z level in the model"""
+        max_zlevel = None
+        for _, comp_object in self._component_objects.items():
+            max_zlevel = (
+                comp_object.zlevel if max_zlevel is None else (max(max_zlevel, comp_object.zlevel))
+            )
+        return max_zlevel
+
+    def component_moved(self):
+        """Call when component has moved to update state"""
+        self._app_model.objects.push_undo_state()
+        self._app_model.model_changed()
+
+    def bring_to_front(self, component_object):
+        """Make the component object the highest in the stack"""
+        max_zlevel = self.get_top_zlevel()
+        component_object.zlevel = max_zlevel + 1
+        self._app_model.model_changed()
+
+    def send_to_back(self, component_object):
+        """Make the component object the lowest in the stack"""
+        min_zlevel = None
+        for _, comp_object in self._component_objects.items():
+            min_zlevel = (
+                comp_object.zlevel if min_zlevel is None else (min(min_zlevel, comp_object.zlevel))
+            )
+        if min_zlevel == 0:
+            for _, comp_object in self._component_objects.items():
+                comp_object.zlevel = comp_object.zlevel + 1
+            component_object.zlevel = 0
+        else:
+            component_object.zlevel = min_zlevel - 1
+        self._app_model.model_changed()
+
+    def update_callback_objects(self):
+        """
+        Update the GUI for the components that have changed since the last call
+        """
+        if len(self._component_callback_list) == 0:
+            return
+        for comp in self._component_callback_list:
+            if isinstance(comp, Buzzer):
+                self._app_model.sig_audio_notify.emit(comp)
+        self._app_model.sig_repaint.emit()
+        self._component_callback_list = []
+
+    def _component_callback(self, component):
+        """Add component to callback list (if not available)"""
+        if component not in self._component_callback_list:
+            self._component_callback_list.append(component)
+
+    def _get_component_class(self, name):
+        return getattr(digsim.circuit.components, name)
+
+    def get_object_parameters(self, name):
+        """Get parameters for a component"""
+        return self._get_component_class(name).get_parameters()
+
+    def _add_object(self, component, xpos, ypos):
+        """Add component object in position"""
+        component_object_class = digsim.app.gui_objects.class_factory(type(component).__name__)
+        self._component_objects[component] = component_object_class(
+            self._app_model, component, xpos, ypos
+        )
+        if isinstance(component, CallbackComponent):
+            component.set_callback(self._component_callback)
+        return self._component_objects[component]
+
+    def add_object_by_name(self, name, pos, settings):
+        """Add component object from class name"""
+        self._app_model.objects.push_undo_state()
+        component_class = self._get_component_class(name)
+        component = component_class(self._circuit, **settings)
+        self._app_model.model_init()
+        component_object = self._add_object(component, pos.x(), pos.y())
+        self._app_model.model_changed()
+        return component_object
+
+    def get_object(self, component):
+        """Get component object (from component)"""
+        return self._component_objects[component]
+
+    def get_object_list(self):
+        """Get list of component objects"""
+        return list(self._component_objects.values())
+
+    def update_settings(self, component_object, settings):
+        """Update settings for a component"""
+        self._app_model.objects.push_undo_state()
+        component_object.component.update_settings(settings)
+        self._app_model.model_changed()
+        # Settings can change the component size
+        component_object.update_size()
+        self._app_model.sig_repaint.emit()
+
+    def update_sizes(self):
+        """Update all component sizes"""
+        for comp_object in self.get_object_list():
+            comp_object.update_size()
+
+    def delete(self, component_object):
+        """Delete a component object in the model"""
+        del self._component_objects[component_object.component]
+        self._circuit.delete_component(component_object.component)
+        self._app_model.sig_delete_component.emit(component_object)
+
+    def add_gui_positions(self, gui_dc_dict):
+        """Create model components from circuit_dict"""
+        for comp in self._circuit.get_toplevel_components():
+            gui_dc = gui_dc_dict.get(comp.name(), GuiPositionDataClass())
+            component_object = self._add_object(comp, gui_dc.x, gui_dc.y)
+            component_object.zlevel = gui_dc.z
+
+    def get_gui_dict(self):
+        """Return gui dict from component objects"""
+        gui_dict = {}
+        for comp, comp_object in self.get_dict().items():
+            gui_dict[comp.name()] = comp_object.to_gui_dataclass()
+        return gui_dict

digsim/app/model/_model_new_wire.py

@@ -0,0 +1,57 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""Handle new wire object in the model"""
+
+from digsim.circuit.components.atoms import PortConnectionError
+
+
+class NewWire:
+    """Class to handle functionality for making a new wire"""
+
+    def __init__(self, app_model):
+        self._app_model = app_model
+        self._start_port = None
+        self._end_pos = None
+
+    def start_port(self):
+        """Get start port for unfinished new wire object"""
+        return self._start_port
+
+    def end_pos(self):
+        """Get end point for unfinished new wire object"""
+        return self._end_pos
+
+    def start(self, component, portname):
+        """Start new wire object"""
+        if component.port(portname).can_add_wire():
+            self._start_port = component.port(portname)
+
+    def end(self, component, portname):
+        """End new wire object"""
+        end_port = component.port(portname)
+        if self._start_port.is_output() and end_port.is_input():
+            self._app_model.objects.push_undo_state()
+            self._start_port.wire = end_port
+        elif self._start_port.is_input() and end_port.is_output():
+            self._app_model.objects.push_undo_state()
+            end_port.wire = self._start_port
+        else:
+            raise PortConnectionError("Cannot connect to port of same type")
+        self._app_model.sig_update_wires.emit()
+        self._app_model.model_changed()
+        self._start_port = None
+        self._end_pos = None
+
+    def abort(self):
+        """Abort new wire object"""
+        self._start_port = None
+        self._end_pos = None
+
+    def set_end_pos(self, pos):
+        """Update end point for unfinished new wire object"""
+        self._end_pos = pos
+
+    def ongoing(self):
+        """Return True if an unfinished new wire object is active"""
+        return self._start_port is not None

digsim/app/model/_model_objects.py

@@ -0,0 +1,155 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""Handle objects in the model"""
+
+from digsim.circuit import Circuit
+from digsim.circuit.components.atoms import DigsimException
+from digsim.storage_model import AppFileDataClass, ModelDataClass
+
+from ._model_components import ModelComponents
+from ._model_new_wire import NewWire
+
+
+class ModelObjects:
+    """Class to handle objects in the model"""
+
+    def __init__(self, app_model):
+        self._app_model = app_model
+        self._circuit = Circuit(name="DigSimCircuit")
+        self._model_components = ModelComponents(app_model, self._circuit)
+        self._undo_stack = []
+        self._redo_stack = []
+        self._new_wire = NewWire(self._app_model)
+
+    @property
+    def circuit(self):
+        """return the model circuit"""
+        return self._circuit
+
+    @property
+    def components(self):
+        """return the model components"""
+        return self._model_components
+
+    @property
+    def new_wire(self):
+        """return the model components"""
+        return self._new_wire
+
+    def init(self):
+        """Initialize objects"""
+        self._model_components.init()
+
+    def clear(self):
+        """Clear components and wires"""
+        self._model_components.clear()
+        self._circuit.clear()
+
+    def get_list(self):
+        """Get list of all model objects"""
+        model_objects = self._model_components.get_object_list()
+        return model_objects
+
+    def get_selected(self):
+        """Get selected objects"""
+        return [obj for obj in self.get_list() if obj.selected]
+
+    def _delete(self, selected_objects):
+        for obj in selected_objects:
+            if ModelComponents.is_component_object(obj):
+                self._model_components.delete(obj)
+
+    def delete_selected(self):
+        """Delete selected object(s)"""
+        self.push_undo_state()
+        selected_objects = self._app_model.objects.get_selected()
+        if len(selected_objects) > 0:
+            self._delete(selected_objects)
+            self._app_model.model_changed()
+        self._app_model.sig_delete_wires.emit()
+
+    def model_to_circuit(self, model_dc, circuit_folder):
+        if isinstance(model_dc, AppFileDataClass):
+            # Loaded model
+            dc = ModelDataClass.from_app_file_dc(model_dc)
+        else:
+            dc = model_dc
+
+        try:
+            # Create circuit
+            exception_str_list = self.circuit.from_dataclass(
+                dc.circuit,
+                circuit_folder,
+                component_exceptions=False,
+                connect_exceptions=False,
+            )
+            # Add component positions
+            self.components.add_gui_positions(dc.gui)
+        except DigsimException as exc:
+            self.sig_error.emit(f"Circuit error: {str(exc)}")
+            return exception_str_list
+        return exception_str_list
+
+    def circuit_to_model(self, circuit_folder):
+        model_dc = ModelDataClass(
+            circuit=self.circuit.to_dataclass(circuit_folder), gui=self.components.get_gui_dict()
+        )
+        return model_dc
+
+    def _restore_state(self, model_dc):
+        self.clear()
+        exception_str_list = self.model_to_circuit(model_dc, None)
+        self._app_model.model_init()
+        self._app_model.model_changed()
+        if len(exception_str_list) > 0:
+            self.sig_warning_log.emit("Load Circuit Warning", "\n".join(exception_str_list))
+
+    def reset_undo_stack(self):
+        """Clear undo/redo stacks"""
+        self._undo_stack = []
+        self._redo_stack = []
+        self._app_model.sig_control_notify.emit()
+
+    def push_undo_state(self, clear_redo_stack=True):
+        """Push undo state to stack"""
+        self._undo_stack.append(self.circuit_to_model("/"))
+        if clear_redo_stack:
+            self._redo_stack = []
+            self._app_model.sig_control_notify.emit()
+
+    def drop_undo_state(self):
+        """Drop last undo state"""
+        if len(self._undo_stack) > 0:
+            self._undo_stack.pop()
+            self._app_model.sig_control_notify.emit()
+
+    def push_redo_state(self):
+        """Push redo state to stack"""
+        self._redo_stack.append(self.circuit_to_model("/"))
+
+    def undo(self):
+        """Undo to last saved state"""
+        if len(self._undo_stack) > 0:
+            self.push_redo_state()
+            model_dc = self._undo_stack.pop()
+            self._restore_state(model_dc)
+            self._app_model.sig_control_notify.emit()
+            self._app_model.sig_synchronize_gui.emit()
+
+    def redo(self):
+        """Undo to last saved state"""
+        if len(self._redo_stack) > 0:
+            self.push_undo_state(clear_redo_stack=False)
+            model_dc = self._redo_stack.pop()
+            self._restore_state(model_dc)
+            self._app_model.sig_control_notify.emit()
+            self._app_model.sig_synchronize_gui.emit()
+
+    def can_undo(self):
+        """Return true if the undo stack is not empty"""
+        return len(self._undo_stack) > 0
+
+    def can_redo(self):
+        """Return true if the undo stack is not empty"""
+        return len(self._redo_stack) > 0

digsim/app/model/_model_settings.py

@@ -0,0 +1,35 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""Handle settings in the model"""
+
+from digsim.app.settings import GuiSettingsDialog
+
+
+class ModelSettings:
+    """Class to handle settings in the model"""
+
+    def __init__(self, app_model):
+        self._app_model = app_model
+        self._settings = GuiSettingsDialog.default_settings()
+
+    def update(self, settings):
+        """Update model settings"""
+        self._settings.update(settings)
+        self._app_model.model_changed()
+        # Settings can change the component sizes
+        self._app_model.objects.components.update_sizes()
+        self._app_model.sig_repaint.emit()
+
+    def get_all(self):
+        """Return settings dict"""
+        return self._settings.copy()
+
+    def from_dict(self, circuit_dict):
+        """Get settings from circuit dict"""
+        for key, data in circuit_dict.items():
+            self._settings[key] = data
+
+    def get(self, key):
+        """Get model setting"""
+        return self._settings.get(key)

digsim/app/model/_model_shortcuts.py

@@ -0,0 +1,72 @@
+# Copyright (c) Fredrik Andersson, 2023-2025
+# All rights reserved
+
+"""Handle shortcuts in the model"""
+
+from PySide6.QtCore import Qt
+
+
+class ModelShortcuts:
+    """class to handle key shortcuts in the model"""
+
+    QT_KEY_TO_KEY = {
+        Qt.Key_0: "0",
+        Qt.Key_1: "1",
+        Qt.Key_2: "2",
+        Qt.Key_3: "3",
+        Qt.Key_4: "4",
+        Qt.Key_5: "5",
+        Qt.Key_6: "6",
+        Qt.Key_7: "7",
+        Qt.Key_8: "8",
+        Qt.Key_9: "9",
+    }
+
+    def __init__(self, app_model):
+        self._app_model = app_model
+        self._shortcut_component = {}
+
+    def clear(self):
+        """Clear shortcuts"""
+        self._shortcut_component = {}
+
+    def set_component(self, key, component):
+        """Set shortcut"""
+        self._shortcut_component[key] = component
+
+    def get_component(self, key):
+        """Get shortcut"""
+        return self._shortcut_component.get(key)
+
+    def press(self, qtkey):
+        """Handle shortcut keypress"""
+        key = self.QT_KEY_TO_KEY.get(qtkey)
+        if key is None:
+            return
+        component = self.get_component(key)
+        if component is not None:
+            self._app_model.model_add_event(component.onpress)
+
+    def release(self, qtkey):
+        """Handle shortcut keyrelease"""
+        key = self.QT_KEY_TO_KEY.get(qtkey)
+        if key is None:
+            return
+        component = self.get_component(key)
+        if component is not None:
+            self._app_model.model_add_event(component.onrelease)
+
+    def to_dict(self):
+        """Generate dict from shortcuts"""
+        shortcuts_dict = {}
+        for key, component in self._shortcut_component.items():
+            shortcuts_dict[key] = component.name()
+        return shortcuts_dict
+
+    def from_dict(self, shortcuts_dict):
+        """Generate shortcuts from dict"""
+        self.clear()
+        if shortcuts_dict is not None:
+            for key, component_name in shortcuts_dict.items():
+                component = self._app_model.objects.circuit.get_component(component_name)
+                self.set_component(key, component)