pySimBlocks 0.1.0__py3-none-any.whl

pySimBlocks/gui/graphics/connection_item.py

@@ -0,0 +1,266 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from PySide6.QtCore import Qt, QPointF
+from PySide6.QtGui import QPen, QPainterPath, QPainterPathStroker
+from PySide6.QtWidgets import QGraphicsItem, QGraphicsPathItem
+
+from pySimBlocks.gui.graphics.port_item import PortItem
+from pySimBlocks.gui.models.connection_instance import ConnectionInstance
+
+
+class OrthogonalRoute:
+    def __init__(self, points: list[QPointF]):
+        self.points = points
+        self.dragged_index: int | None = None
+
+
+class ConnectionItem(QGraphicsPathItem):
+    OFFSET = 8
+    MARGIN = 12
+    DETOUR = 8
+    PICK_TOL = 6
+    GRID = 5
+
+    def __init__(self,
+                 src_port: PortItem | None,
+                 dst_port: PortItem | None,
+                 instance: ConnectionInstance,
+                 points: list[QPointF] | None = None):
+        super().__init__()
+
+        if src_port is None and dst_port is None:
+            raise ValueError("At least one of the ports must be provided")
+
+        self.src_port = src_port
+        self.dst_port = dst_port
+        self.instance = instance
+        self.is_temporary = (src_port is None) or (dst_port is None)
+        self._valid_port = src_port if src_port is not None else dst_port
+        self.is_manual: bool = False
+        self.route: OrthogonalRoute | None = None
+
+        if points and len(points) >= 2:
+            self.apply_manual_route(points)
+
+        t = self._valid_port.parent_block.view.theme
+
+
+        if self.is_temporary:
+            self.setFlag(QGraphicsItem.ItemIsSelectable, False)
+            self.setAcceptedMouseButtons(Qt.NoButton)
+            pen = QPen(t.wire, 3, Qt.DashLine)
+        else:
+            self.setFlag(QGraphicsItem.ItemIsSelectable, True)
+            self.setAcceptedMouseButtons(Qt.LeftButton)
+            pen = QPen(t.wire, 3, Qt.SolidLine)
+
+        self.setPen(pen)
+        self.setZValue(1)
+
+        self.update_position()
+
+    # --------------------------------------------------------------------------
+    #  Position methods
+    # --------------------------------------------------------------------------
+    def update_position(self):
+        if self.is_temporary:
+            return
+
+        p1 = self.src_port.connection_anchor()
+        p2 = self.dst_port.connection_anchor()
+        if self.is_manual and self.route and len(self.route.points) >= 2:
+            self.route.points[0] = p1
+            self.route.points[-1] = p2
+            self._apply_route(self.route.points)
+            return
+
+        pts = self._compute_auto_route(p1, p2)
+        self.route = OrthogonalRoute(pts)
+        self._apply_route(self.route.points)
+
+    # ------------------------------------------------------------------
+    def update_temp_position(self, scene_pos: QPointF):
+        p1 = self._valid_port.connection_anchor()
+        pts = [p1, scene_pos]
+        self._apply_route(pts)
+
+    # --------------------------------------------------------------------------
+    # Routing methods
+    # --------------------------------------------------------------------------
+    def apply_manual_route(self, points: list[QPointF]):
+        self.route = OrthogonalRoute(points)
+        self.is_manual = True
+        self._apply_route(self.route.points)
+
+    # ------------------------------------------------------------------
+    def invalidate_manual_route(self):
+        """
+        Called when a connected block moves: manual routing is discarded and
+        next update_position() will fully recompute the orthogonal route.
+        """
+        self.is_manual = False
+        self.route = None
+
+    # ------------------------------------------------------------------
+    def _compute_auto_route(self, p1: QPointF, p2: QPointF) -> list[QPointF]:
+        src_block = self.src_port.parent_block
+        dst_block = self.dst_port.parent_block
+
+        # Use the visual block rect (not selection handle hit area) for routing.
+        src_rect = src_block.mapRectToScene(src_block.rect())
+        dst_rect = dst_block.mapRectToScene(dst_block.rect())
+
+        src_out_sign = 1 if not self.src_port.is_on_left_side else -1
+        dst_in_sign = -1 if self.dst_port.is_on_left_side else 1
+
+        p1_out = QPointF(p1.x() + src_out_sign * self.OFFSET, p1.y())
+        p2_in = QPointF(p2.x() + dst_in_sign * self.OFFSET, p2.y())
+
+        same_block = src_block is dst_block
+        u_turn = ((p2_in.x() - p1_out.x()) * src_out_sign) < 0
+        is_feedback = same_block or u_turn
+
+        if not is_feedback:
+            mid_x = (p1_out.x() + p2_in.x()) * 0.5
+            candidate = [
+                p1, p1_out,
+                QPointF(mid_x, p1.y()),
+                QPointF(mid_x, p2.y()),
+                p2_in, p2
+            ]
+
+            path = self._path_from(candidate)
+            if not (path.intersects(src_rect) or path.intersects(dst_rect)):
+                return candidate
+
+        # fallback / feedback routing
+        candidates_y = [
+            min(src_rect.top(), dst_rect.top()) - self.MARGIN,
+            max(src_rect.bottom(), dst_rect.bottom()) + self.MARGIN
+        ]
+
+        if src_rect.bottom() < dst_rect.top():
+            candidates_y.append((src_rect.bottom() + dst_rect.top()) * 0.5)
+        elif dst_rect.bottom() < src_rect.top():
+            candidates_y.append((dst_rect.bottom() + src_rect.top()) * 0.5)
+
+        route_y = min(
+            candidates_y,
+            key=lambda y: abs(p1.y() - y) + abs(p2.y() - y)
+        )
+
+        return [
+            p1, p1_out,
+            QPointF(p1_out.x(), route_y),
+            QPointF(p2_in.x(), route_y),
+            p2_in, p2
+        ]
+
+    # ------------------------------------------------------------------
+    def _snap(self, v: float) -> float:
+        return round(v / self.GRID) * self.GRID
+
+    # --------------------------------------------------------------------------
+    # Path methods
+    # --------------------------------------------------------------------------
+    def _apply_route(self, points: list[QPointF]):
+        path = QPainterPath(points[0])
+        for p in points[1:]:
+            path.lineTo(p)
+        self.setPath(path)
+
+    # ------------------------------------------------------------------
+    def _path_from(self, pts: list[QPointF]) -> QPainterPath:
+        p = QPainterPath(pts[0])
+        for pt in pts[1:]:
+            p.lineTo(pt)
+        return p
+
+    # --------------------------------------------------------------------------
+    # Interaction (segment dragging)
+    # --------------------------------------------------------------------------
+    def segment_at(self, scene_pos: QPointF) -> int | None:
+        if not self.route:
+            return None
+
+        pts = self.route.points
+        for i in range(len(pts) - 1):
+            a, b = pts[i], pts[i + 1]
+
+            if a.x() == b.x():  # vertical
+                if abs(scene_pos.x() - a.x()) < self.PICK_TOL \
+                   and min(a.y(), b.y()) <= scene_pos.y() <= max(a.y(), b.y()):
+                    return i
+
+            if a.y() == b.y():  # horizontal
+                if abs(scene_pos.y() - a.y()) < self.PICK_TOL \
+                   and min(a.x(), b.x()) <= scene_pos.x() <= max(a.x(), b.x()):
+                    return i
+        return None
+
+    # --------------------------------------------------------------
+    def shape(self):
+        """
+        Override the default shape to make it easier to click on the connection.
+        """
+        stroker = QPainterPathStroker()
+        stroker.setWidth(6)  # zone cliquable (px)
+        return stroker.createStroke(self.path())
+
+    # --------------------------------------------------------------------------
+    # Events methods
+    # --------------------------------------------------------------------------
+    def mousePressEvent(self, event):
+        idx = self.segment_at(event.scenePos())
+        if idx is not None:
+            self.route.dragged_index = idx
+            self.is_manual = True
+            event.accept()
+        else:
+            super().mousePressEvent(event)
+
+    # ------------------------------------------------------------------
+    def mouseMoveEvent(self, event):
+        if not self.route or self.route.dragged_index is None:
+            return
+
+        i = self.route.dragged_index
+        a = self.route.points[i]
+        b = self.route.points[i + 1]
+        pos = event.scenePos()
+
+        if a.x() == b.x():  # vertical segment
+            x = self._snap(pos.x())
+            self.route.points[i]     = QPointF(x, a.y())
+            self.route.points[i + 1] = QPointF(x, b.y())
+
+        elif a.y() == b.y():  # horizontal segment
+            y = self._snap(pos.y())
+            self.route.points[i]     = QPointF(a.x(), y)
+            self.route.points[i + 1] = QPointF(b.x(), y)
+
+        self._apply_route(self.route.points)
+
+    # ------------------------------------------------------------------
+    def mouseReleaseEvent(self, event):
+        if self.route:
+            self.route.dragged_index = None
+        super().mouseReleaseEvent(event)

pySimBlocks/gui/graphics/port_item.py

@@ -0,0 +1,153 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QPointF, QRectF, Qt
+from PySide6.QtGui import QBrush, QFont, QPainter, QPainterPath, QPen
+from PySide6.QtWidgets import QGraphicsItem, QGraphicsTextItem
+
+if TYPE_CHECKING:
+    from pySimBlocks.gui.graphics.block_item import BlockItem
+    from pySimBlocks.gui.models.port_instance import PortInstance
+
+
+class PortItem(QGraphicsItem):
+    MARGIN = 4
+    R = 6   # radius input port
+    L = 15  # length output port
+    H = 10  # height output port
+    RECT = QRectF(-8, -8, 15, 15) # bounding rect for both port types
+
+    def __init__(self, instance: 'PortInstance', parent_block: 'BlockItem'):
+        super().__init__(parent_block)
+
+        self.instance = instance
+        self.parent_block = parent_block
+
+        self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges)
+        self.setAcceptedMouseButtons(Qt.LeftButton)
+
+        # Label
+        self.t = parent_block.view.theme
+        self.label = QGraphicsTextItem(self.instance.display_as, parent_block)
+        self.label.setDefaultTextColor(self.t.text)
+        self.label.setFont(QFont("Sans Serif", 8))
+
+    # --------------------------------------------------------------------------
+    # Properties
+    # --------------------------------------------------------------------------
+    @property
+    def is_input(self):
+        return self.instance.direction == "input"
+
+    # --------------------------------------------------------------
+    @property
+    def is_on_left_side(self) -> bool:
+        return self.pos().x() < (self.parent_block.rect().width() * 0.5)
+
+    # --------------------------------------------------------------------------
+    # Public methods
+    # --------------------------------------------------------------------------
+    def update_label_position(self):
+        label_rect = self.label.boundingRect()
+
+        if self.is_on_left_side:
+            self.label.setPos(
+                self.x() + self.R + self.MARGIN,
+                self.y() - label_rect.height() / 2,
+            )
+        else:
+            self.label.setPos(
+                self.x() - label_rect.width() - self.R - self.MARGIN,
+                self.y() - label_rect.height() / 2,
+            )
+
+    # --------------------------------------------------------------
+    def update_display_as(self):
+        self.label.setPlainText(self.instance.display_as)
+
+    # --------------------------------------------------------------
+    def connection_anchor(self) -> QPointF:
+        if self.is_input:
+            x = -self.R if self.is_on_left_side else self.R
+            local = QPointF(x, 0)
+        else:
+            x = self.L if not self.is_on_left_side else -self.L
+            local = QPointF(x, 0)
+        return self.mapToScene(local)
+
+    # --------------------------------------------------------------
+    def is_compatible(self, other: 'PortItem'):
+        return self.instance.direction != other.instance.direction
+
+    # --------------------------------------------------------------------------
+    # Visuals
+    # --------------------------------------------------------------------------
+    def boundingRect(self) -> QRectF:
+        return self.RECT
+
+    # --------------------------------------------------------------
+    def paint(self, painter, option, widget=None):
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        fill = self.t.port_in if self.is_input else self.t.port_out
+
+        painter.setBrush(QBrush(fill))
+        painter.setPen(QPen(self.t.block_border, 1))
+
+        if self.is_input:
+            painter.drawEllipse(-self.R, -self.R, 2 * self.R, 2 * self.R)
+        else:
+            path = QPainterPath()
+            path.moveTo(0, -self.H)
+            path.lineTo(0,  self.H)
+            tip_x = self.L if not self.is_on_left_side else - self.L
+            path.lineTo(tip_x, 0)
+            path.closeSubpath()
+            painter.drawPath(path)
+
+    # --------------------------------------------------------------
+    def shape(self):
+        path = QPainterPath()
+
+        if self.is_input:
+            path.addEllipse(-self.R, -self.R, 2*self.R, 2*self.R)
+        else:
+            tip_x = self.L if not self.is_on_left_side else -self.L
+            path.moveTo(0, -self.H)
+            path.lineTo(0,  self.H)
+            path.lineTo(tip_x, 0)
+            path.closeSubpath()
+
+        return path
+
+    # --------------------------------------------------------------------------
+    # Event handlers
+    # --------------------------------------------------------------------------
+    def mousePressEvent(self, event):
+        self.parent_block.view.create_connection_event(self)
+        event.accept()
+
+    # --------------------------------------------------------------
+    def itemChange(self, change, value):
+        if change == QGraphicsItem.ItemScenePositionHasChanged:
+            self.update_label_position()
+        return super().itemChange(change, value)

pySimBlocks/gui/graphics/theme.py

@@ -0,0 +1,119 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from dataclasses import dataclass
+
+from PySide6.QtGui import QColor, QPalette
+from PySide6.QtWidgets import QApplication
+
+
+def _luma(c: QColor) -> float:
+    r, g, b, _ = c.getRgb()
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+
+def _ensure_contrast(fg: QColor, bg: QColor, min_delta: float = 80.0) -> QColor:
+    """Ensure |luma(fg) - luma(bg)| >= min_delta by pushing fg to black/white."""
+    if abs(_luma(fg) - _luma(bg)) >= min_delta:
+        return fg
+
+    # push toward white on dark bg, toward black on light bg
+    if _luma(bg) < 128:
+        return QColor(235, 235, 235)
+    return QColor(25, 25, 25)
+
+
+def _separate_bg(block: QColor, scene: QColor, delta: float = 35.0) -> QColor:
+    """Make sure block background is separated from scene background."""
+    if abs(_luma(block) - _luma(scene)) >= delta:
+        return block
+
+    # If scene is dark -> lighten block a bit; if scene is light -> darken block a bit
+    h, s, l, a = block.getHsl()
+    if _luma(scene) < 128:
+        l = min(255, l + 30)
+    else:
+        l = max(0, l - 30)
+    out = QColor()
+    out.setHsl(h, s, l, a)
+    return out
+
+
+@dataclass(frozen=True)
+class Theme:
+    scene_bg: QColor
+
+    block_bg: QColor
+    block_bg_selected: QColor
+    block_border: QColor
+    block_border_selected: QColor
+
+    text: QColor
+    text_selected: QColor
+
+    wire: QColor
+
+    port_in: QColor
+    port_out: QColor
+
+
+def make_theme() -> Theme:
+    pal = QApplication.palette()
+
+    scene_bg = pal.color(QPalette.Window)
+    is_dark = _luma(scene_bg) < 128
+
+    # base colors
+    if is_dark:
+        block_bg = QColor("#30343A")
+        block_bg_selected = QColor("#3A6FB0")
+        block_border = QColor("#ACACAC")
+        block_border_selected = QColor("#6FAEFF")
+    else:
+        block_bg = QColor("#ECECEC")
+        block_bg_selected = QColor("#C7DBFF")
+        block_border = QColor("#6E6E6E")
+        block_border_selected = QColor("#4A78FF")
+
+    text = QColor("#F0F0F0") if is_dark else QColor("#1E1E1E")
+    text_selected = QColor("#FFFFFF") if is_dark else QColor("#000000")
+    wire = QColor("#E6E6E6") if is_dark else QColor("#1A1A1A")
+
+    text = _ensure_contrast(text, block_bg, min_delta=90.0)
+    text_selected = _ensure_contrast(text_selected, block_bg_selected, min_delta=90.0)
+    block_border = _ensure_contrast(block_border, block_bg, min_delta=60.0)
+    block_border_selected = _ensure_contrast(block_border_selected, block_bg_selected, min_delta=60.0)
+    wire = _ensure_contrast(wire, scene_bg, min_delta=110.0)
+
+    port_in = QColor("#5FBF73")
+    port_out = QColor("#E5534B")
+
+    return Theme(
+        scene_bg=scene_bg,
+        block_bg=block_bg,
+        block_bg_selected=block_bg_selected,
+        block_border=block_border,
+        block_border_selected=block_border_selected,
+        text=text,
+        text_selected=text_selected,
+        wire=wire,
+        port_in=port_in,
+        port_out=port_out,
+    )

pySimBlocks/gui/main_window.py

@@ -0,0 +1,162 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pathlib import Path
+from typing import Dict, List
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QAction, QKeySequence
+from PySide6.QtWidgets import QMainWindow, QSplitter
+
+from pySimBlocks.gui.blocks.block_meta import BlockMeta
+from pySimBlocks.gui.dialogs.unsaved_dialog import UnsavedChangesDialog
+from pySimBlocks.gui.models.project_state import ProjectState
+from pySimBlocks.gui.project_controller import ProjectController
+from pySimBlocks.gui.services.project_loader import ProjectLoaderYaml
+from pySimBlocks.gui.services.project_saver import ProjectSaverYaml
+from pySimBlocks.gui.services.simulation_runner import SimulationRunner
+from pySimBlocks.gui.services.yaml_tools import cleanup_runtime_project_yaml
+from pySimBlocks.gui.widgets.block_list import BlockList
+from pySimBlocks.gui.widgets.diagram_view import DiagramView
+from pySimBlocks.gui.widgets.toolbar_view import ToolBarView
+from pySimBlocks.tools.blocks_registry import load_block_registry
+
+
+class MainWindow(QMainWindow):
+    def __init__(self, project_path: Path):
+        super().__init__()
+
+        self.loader = ProjectLoaderYaml()
+        self.saver = ProjectSaverYaml()
+        self.runner = SimulationRunner()
+
+        self.block_registry = load_block_registry()
+
+        self.project_state = ProjectState(project_path)
+        self.view = DiagramView()
+        self.project_controller = ProjectController(self.project_state, self.view, self.resolve_block_meta)
+        self.view.project_controller = self.project_controller
+        self.blocks = BlockList(self.get_categories, self.get_blocks, self.resolve_block_meta)
+        self.toolbar = ToolBarView(self.saver, self.runner, self.project_controller)
+
+        splitter = QSplitter(Qt.Horizontal)
+        splitter.addWidget(self.blocks)
+        splitter.addWidget(self.view)
+        splitter.setSizes([180, 800])
+
+        self.setCentralWidget(splitter)
+        self.addToolBar(self.toolbar)
+
+        flag = self.auto_load_detection(project_path)
+        if flag:
+            self.project_controller.load_project(self.loader)
+
+        self.project_controller.dirty_changed.connect(self.update_window_title)
+        self.update_window_title()
+
+        self.save_action = QAction("Save", self)
+        self.save_action.setShortcut(QKeySequence.Save)
+        self.save_action.triggered.connect(self._on_save)
+        self.addAction(self.save_action)
+
+        self.quit_action = QAction("Quit", self)
+        self.quit_action.setShortcut(QKeySequence("Ctrl+Q"))
+        self.quit_action.triggered.connect(self.close)
+        self.addAction(self.quit_action)
+
+        # Ensure keyboard shortcuts (e.g. Space) work immediately on startup.
+        QTimer.singleShot(0, self.view.setFocus)
+
+    # --------------------------------------------------------------------------
+    # Registry
+    # --------------------------------------------------------------------------
+    def get_categories(self) -> List[str]:
+        return sorted(self.block_registry.keys())
+
+    # ------------------------------------------------------------------
+    def get_blocks(self, category: str) -> List[str]:
+        return sorted(self.block_registry.get(category, {}).keys())
+
+    # ------------------------------------------------------------------
+    def resolve_block_meta(self, category: str, block_type: str) -> BlockMeta:
+        return self.block_registry[category][block_type]
+
+    # --------------------------------------------------------------------------
+    # Auto Load
+    # --------------------------------------------------------------------------
+    def auto_load_detection(self, project_path: Path) -> bool:
+        project_yaml = self._auto_detect_yaml(project_path, ["project.yaml"])
+        return project_yaml is not None
+
+    # ------------------------------------------------------------------
+    def _auto_detect_yaml(self, project_path: Path, names: list[str]) -> str | None:
+        for name in names:
+            path = project_path / name
+            if path.is_file():
+                return str(path)
+        return None
+
+    # --------------------------------------------------------------------------
+    # Project Management
+    # --------------------------------------------------------------------------
+    def _on_save(self):
+        if not self.project_controller.is_dirty:
+            return
+        self.saver.save(self.project_controller.project_state, self.project_controller.view.block_items)
+        self.project_controller.clear_dirty()
+
+    # ------------------------------------------------------------------
+    def update_window_title(self):
+        path = self.project_state.directory_path
+        project_name = path.name if path else "Untitled"
+        star = "*" if self.project_controller.is_dirty else ""
+        self.setWindowTitle(f"{project_name}{star} – pySimBlocks")
+
+    # ------------------------------------------------------------------
+    def on_project_loaded(self, project_path: Path):
+        self.update_window_title()
+
+    # ------------------------------------------------------------------
+    def cleanup(self):
+        cleanup_runtime_project_yaml(self.project_state.directory_path)
+
+    # ------------------------------------------------------------------
+    def closeEvent(self, event):
+        if self.confirm_discard_or_save("closing"):
+            self.cleanup()
+            event.accept()
+        else:
+            event.ignore()
+
+    # ------------------------------------------------------------------
+    def confirm_discard_or_save(self, action_name: str) -> bool:
+        if not self.project_controller.is_dirty:
+            return True
+
+        dlg = UnsavedChangesDialog(action_name, self)
+        result = dlg.exec()
+
+        if result == UnsavedChangesDialog.SAVE:
+            self._on_save()
+            return True
+        elif result == UnsavedChangesDialog.DISCARD:
+            return True
+        else:
+            return False