nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_graphics_view.py

@@ -0,0 +1,907 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing `Graphics View` for NodeEditor
+"""
+from qtpy.QtWidgets import QGraphicsView, QApplication, QWidget, QGraphicsItem
+from qtpy.QtCore import Signal, QPoint, Qt, QEvent, QPointF, QRectF
+from qtpy.QtGui import QPainter, QDragEnterEvent, QDropEvent, QMouseEvent, QKeyEvent, QWheelEvent, QInputEvent
+
+from nodeeditor import _QT_API_NAME as QT_API
+from nodeeditor.node_graphics_socket import QDMGraphicsSocket
+from nodeeditor.node_graphics_edge import QDMGraphicsEdge
+from nodeeditor.node_edge_dragging import EdgeDragging
+from nodeeditor.node_edge_rerouting import EdgeRerouting
+from nodeeditor.node_edge_intersect import EdgeIntersect
+from nodeeditor.node_edge_snapping import EdgeSnapping
+from nodeeditor.node_graphics_cutline import QDMCutLine
+from nodeeditor.utils import dumpException, pp, isCTRLPressed, isSHIFTPressed, isALTPressed
+
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from nodeeditor.node_node import Node
+    from nodeeditor.node_graphics_scene import QDMGraphicsScene
+
+MODE_NOOP = 1               #: Mode representing ready state
+MODE_EDGE_DRAG = 2          #: Mode representing when we drag edge state
+MODE_EDGE_CUT = 3           #: Mode representing when we draw a cutting edge
+MODE_EDGES_REROUTING = 4    #: Mode representing when we re-route existing edges
+#: Mode representing when we drag a node to calculate dropping on intersecting edge
+MODE_NODE_DRAG = 5
+
+STATE_STRING = ['', 'Noop', 'Edge Drag',
+                'Edge Cut', 'Edge Rerouting', 'Node Drag']
+
+#: Distance when click on socket to enable `Drag Edge`
+EDGE_DRAG_START_THRESHOLD = 50
+
+#: Enable UnrealEngine style rerouting
+EDGE_REROUTING_UE = True
+
+#: Socket snapping distance
+EDGE_SNAPPING_RADIUS = 24
+#: Enable socket snapping feature
+EDGE_SNAPPING = True
+
+#: How the view invalidates its viewport after a change.
+#:
+#: ``FullViewportUpdate`` repaints every visible item on every change, and the
+#: old mouse-move path forced one on *every* move (clearing socket highlights).
+#: ``BoundingRectViewportUpdate`` repaints the union of the rectangles that
+#: actually changed, so dragging a node at a zoomed-out fit costs a third of the
+#: edge paints FullViewportUpdate does (36 vs 119 per pass at 120 nodes) and
+#: measures 2.2x faster per step; panning and repainting are within noise of
+#: ``MinimalViewportUpdate``. It is the wider of the two cheap modes on purpose:
+#: every node's look is an embedded ``QGraphicsProxyWidget``, and the narrow
+#: mode's region bookkeeping is what Qt documents as the one that can leave
+#: widget trails across a scroll.
+DEFAULT_VIEWPORT_UPDATE_MODE = (
+    QGraphicsView.ViewportUpdateMode.BoundingRectViewportUpdate
+)
+
+DEBUG = False
+DEBUG_MMB_SCENE_ITEMS = False
+DEBUG_MMB_LAST_SELECTIONS = False
+DEBUG_EDGE_INTERSECT = False
+DEBUG_STATE = False
+
+
+class QDMGraphicsView(QGraphicsView):
+    """Class representing NodeEditor's `Graphics View`"""
+    #: pyqtSignal emitted when cursor position on the `Scene` has changed
+    scenePosChanged = Signal(int, int)
+
+    def __init__(self, grScene: 'QDMGraphicsScene', parent: QWidget = None) -> None:
+        """
+        :param grScene: reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
+        :type grScene: :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
+        :param parent: parent widget
+        :type parent: ``QWidget``
+
+        :Instance Attributes:
+
+        - **grScene** - reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
+        - **mode** - state of the `Graphics View`
+        - **zoomInFactor**- ``float`` - zoom step scaling, default 1.25
+        - **zoomClamp** - ``bool`` - do we clamp zooming or is it infinite?
+        - **zoom** - current zoom step
+        - **zoomStep** - ``int`` - the relative zoom step when zooming in/out
+        - **zoomRange** - ``[min, max]``
+
+        """
+        super().__init__(parent)
+        self.grScene = grScene
+
+        self.initUI()
+
+        self.setScene(self.grScene)
+
+        self.mode = MODE_NOOP
+        self.editingFlag = False
+        self.rubberBandDraggingRectangle = False
+
+        #: The socket currently drawn highlighted while CTRL-snapping, if any.
+        #: Tracked so a mouse-move can clear the previous one instead of
+        #: scanning a 248-unit square of the scene and repainting the viewport.
+        self._highlighted_socket: QDMGraphicsSocket | None = None
+
+        # edge dragging
+        self.dragging = EdgeDragging(self)
+
+        # edges re-routing
+        self.rerouting = EdgeRerouting(self)
+
+        # drop a node on an existing edge
+        self.edgeIntersect = EdgeIntersect(self)
+
+        # edge snapping
+        self.snapping = EdgeSnapping(
+            self, snapping_radius=EDGE_SNAPPING_RADIUS)
+
+        # cutline
+        self.cutline = QDMCutLine()
+        self.grScene.addItem(self.cutline)
+
+        self.last_scene_mouse_position = QPointF(0, 0)
+        self.zoomInFactor = 1.25
+        self.zoomClamp = True
+        self.zoom = 10
+        self.zoomStep = 1
+        self.zoomRange = [0, 10]
+
+        # listeners
+        self._drag_enter_listeners: list = []
+        self._drop_listeners: list = []
+
+    def initUI(self) -> None:
+        """Set up this ``QGraphicsView``"""
+        # self.setRenderHints(QPainter.Antialiasing | QPainter.HighQualityAntialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform)
+        self.setRenderHints(
+            QPainter.Antialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform)
+
+        self.setViewportUpdateMode(DEFAULT_VIEWPORT_UPDATE_MODE)
+
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
+        self.setDragMode(QGraphicsView.RubberBandDrag)
+
+        # enable dropping
+        self.setAcceptDrops(True)
+
+    def isSnappingEnabled(self, event: 'QInputEvent' = None) -> bool:
+        """Returns ``True`` if snapping is currently enabled"""
+        return EDGE_SNAPPING and isCTRLPressed(event) if event else True
+
+    def resetMode(self) -> None:
+        """Helper function to re-set the grView's State Machine state to the default"""
+        self.mode = MODE_NOOP
+
+    def dragEnterEvent(self, event: Optional[QDragEnterEvent]) -> None:
+        """Trigger our registered `Drag Enter` events"""
+        for callback in self._drag_enter_listeners:
+            callback(event)
+
+    def dropEvent(self, event: Optional[QDropEvent]) -> None:
+        """Trigger our registered `Drop` events"""
+        for callback in self._drop_listeners:
+            callback(event)
+
+    def addDragEnterListener(self, callback: 'function') -> None:
+        """
+        Register callback for `Drag Enter` event
+
+        :param callback: callback function
+        """
+        self._drag_enter_listeners.append(callback)
+
+    def addDropListener(self, callback: 'function') -> None:
+        """
+        Register callback for `Drop` event
+
+        :param callback: callback function
+        """
+        self._drop_listeners.append(callback)
+
+    def mousePressEvent(self, event: Optional[QMouseEvent]) -> None:
+        """Dispatch Qt's mousePress event to corresponding function below"""
+        if event is None:
+            return
+        if event.button() == Qt.MouseButton.MiddleButton:
+            self.middleMouseButtonPress(event)
+        elif event.button() == Qt.MouseButton.LeftButton:
+            self.leftMouseButtonPress(event)
+        elif event.button() == Qt.MouseButton.RightButton:
+            self.rightMouseButtonPress(event)
+        else:
+            super().mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event: Optional[QMouseEvent]) -> None:
+        """Dispatch Qt's mouseRelease event to corresponding function below"""
+        if event is None:
+            return
+        if self.mode == MODE_EDGE_DRAG:
+            item = self.getItemAtClick(event)
+            if item is None:  # Clicked on empty space
+                self.dragging.cancelDragEdge()
+                return
+        if event.button() == Qt.MouseButton.MiddleButton:
+            self.middleMouseButtonRelease(event)
+        elif event.button() == Qt.MouseButton.LeftButton:
+            self.leftMouseButtonRelease(event)
+        elif event.button() == Qt.MouseButton.RightButton:
+            self.rightMouseButtonRelease(event)
+        else:
+            super().mouseReleaseEvent(event)
+
+    def middleMouseButtonPress(self, event: QMouseEvent) -> None:
+        """When Middle mouse button was pressed"""
+
+        item = self.getItemAtClick(event)
+
+        # debug printout
+        if DEBUG_MMB_SCENE_ITEMS:
+            if isinstance(item, QDMGraphicsEdge):
+                print("MMB DEBUG:", item.edge, "\n\t",
+                      item.edge.grEdge if item.edge.grEdge is not None else None)
+                return
+
+            if isinstance(item, QDMGraphicsSocket):
+                print("MMB DEBUG:", item.socket, "socket_type:", item.socket.socket_type,
+                      "has edges:", "no" if item.socket.edges == [] else "")
+                if item.socket.edges:
+                    for edge in item.socket.edges:
+                        print("\t", edge)
+                return
+
+        if DEBUG_MMB_SCENE_ITEMS and (item is None or self.mode == MODE_EDGES_REROUTING):
+            print("SCENE:")
+            print("  Nodes:")
+            for node in self.grScene.scene.nodes:
+                print("\t", node)
+            print("  Edges:")
+            for edge in self.grScene.scene.edges:
+                print("\t", edge, "\n\t\tgrEdge:",
+                      edge.grEdge if edge.grEdge is not None else None)
+
+            if isCTRLPressed(event):
+                print("  Graphic Items in GraphicScene:")
+                for item in self.grScene.items():
+                    print('    ', item)
+
+        if DEBUG_MMB_LAST_SELECTIONS and isSHIFTPressed(event):
+            print("scene _last_selected_items:",
+                  self.grScene.scene._last_selected_items)
+            return
+
+        # faking events for enable MMB dragging the scene
+        if QT_API in ("pyqt5", "pyside2"):
+            releaseEvent = QMouseEvent(
+                QEvent.Type.MouseButtonRelease,
+                event.localPos(),  # type: ignore
+                event.screenPos(),  # type: ignore
+                Qt.MouseButton.LeftButton,
+                Qt.MouseButton.NoButton,
+                event.modifiers())
+
+        elif QT_API in ("pyqt6", "pyside6"):
+            releaseEvent = QMouseEvent(
+                QEvent.Type.MouseButtonRelease,
+                # ----------------- Change it to localPos if dont work.----------------------
+                event.position(),
+                # ---------------------------------------
+                Qt.MouseButton.LeftButton,
+                Qt.MouseButton.NoButton,
+                event.modifiers())
+
+        super().mouseReleaseEvent(releaseEvent)
+        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)
+
+        if QT_API in ("pyqt5", "pyside2"):
+            fakeEvent = QMouseEvent(
+                event.type(),
+                event.localPos(),  # type: ignore
+                event.screenPos(),  # type: ignore
+                Qt.MouseButton.LeftButton,
+                event.buttons() | Qt.MouseButton.LeftButton,
+                event.modifiers())
+        elif QT_API in ("pyqt6", "pyside6"):
+            fakeEvent = QMouseEvent(
+                event.type(),
+                event.position(),
+                Qt.MouseButton.LeftButton,
+                event.buttons() | Qt.MouseButton.LeftButton,
+                event.modifiers())
+        super().mousePressEvent(fakeEvent)
+
+    def middleMouseButtonRelease(self, event: QMouseEvent) -> None:
+        """When Middle mouse button was released"""
+        if QT_API in ("pyqt5", "pyside2"):
+            fakeEvent = QMouseEvent(
+                event.type(),
+                event.localPos(),  # type: ignore
+                event.screenPos(),  # type: ignore
+                Qt.MouseButton.LeftButton,
+                event.buttons() & ~Qt.MouseButton.LeftButton,
+                event.modifiers())
+        elif QT_API in ("pyqt6", "pyside6"):
+            fakeEvent = QMouseEvent(
+                event.type(),
+                event.position(),
+                Qt.MouseButton.LeftButton,
+                event.buttons() & ~Qt.MouseButton.LeftButton,
+                event.modifiers())
+        super().mouseReleaseEvent(fakeEvent)
+        self.setDragMode(QGraphicsView.DragMode.RubberBandDrag)
+
+    def leftMouseButtonPress(self, event: QMouseEvent) -> None:
+        """When Left  mouse button was pressed"""
+
+        # get the item we clicked on
+        item = self.getItemAtClick(event)
+
+        if item is None:
+            if isCTRLPressed(event):
+                self.mode = MODE_EDGE_CUT
+                if QT_API in ("pyqt5", "pyside2"):
+                    fakeEvent = QMouseEvent(
+                        QEvent.Type.MouseButtonRelease,
+                        event.localPos(),  # type: ignore
+                        event.screenPos(),  # type: ignore
+                        Qt.MouseButton.LeftButton,
+                        Qt.MouseButton.NoButton,
+                        event.modifiers())
+                elif QT_API in ("pyqt6", "pyside6"):
+                    fakeEvent = QMouseEvent(
+                        QEvent.Type.MouseButtonRelease,
+                        event.position(),
+                        Qt.MouseButton.LeftButton,
+                        Qt.MouseButton.NoButton,
+                        event.modifiers())
+                super().mouseReleaseEvent(fakeEvent)
+                QApplication.setOverrideCursor(Qt.CursorShape.CrossCursor)
+                return
+            else:
+                self.rubberBandDraggingRectangle = True
+
+        # we store the position of last LMB click
+        self.last_lmb_click_scene_pos = self.mapToScene(event.pos())
+
+        # if DEBUG: print("LMB Click on", item, self.debug_modifiers(event))
+
+        # logic - Shift + LMB Node
+        if hasattr(item, "node") or isinstance(item, QDMGraphicsEdge) or item is None:
+            if isSHIFTPressed(event):
+                event.ignore()
+                if QT_API in ("pyqt5", "pyside2"):
+                    fakeEvent = QMouseEvent(
+                        QEvent.Type.MouseButtonPress,
+                        event.localPos(),  # type: ignore
+                        event.screenPos(),  # type: ignore
+                        Qt.MouseButton.LeftButton,
+                        event.buttons() | Qt.MouseButton.LeftButton,
+                        event.modifiers() | Qt.KeyboardModifier.ControlModifier)
+                elif QT_API in ("pyqt6", "pyside6"):
+                    fakeEvent = QMouseEvent(
+                        QEvent.Type.MouseButtonPress,
+                        event.position(),
+                        Qt.MouseButton.LeftButton,
+                        event.buttons() | Qt.MouseButton.LeftButton,
+                        event.modifiers() | Qt.KeyboardModifier.ControlModifier)
+                super().mousePressEvent(fakeEvent)
+                return
+
+        if hasattr(item, "node"):
+            if DEBUG_EDGE_INTERSECT:
+                print('View::leftMouseButtonPress - Start dragging a node')
+            if self.mode == MODE_NOOP:
+                self.mode = MODE_NODE_DRAG
+                self.edgeIntersect.enterState(item.node)
+                if DEBUG_EDGE_INTERSECT:
+                    print(">> edgeIntersect start:",
+                          self.edgeIntersect.draggedNode)
+
+        # support for snapping
+        if self.isSnappingEnabled(event):
+            item = self.snapping.getSnappedSocketItem(event)
+
+        if isinstance(item, QDMGraphicsSocket):
+
+            if isALTPressed(event) and self.mode == MODE_NOOP:
+                # ALT + LMB on a socket to see the data processed by that node.
+                socket = item.socket
+                node = socket.node
+                # Emit signal with both socket and node
+                self.grScene.socketClicked.emit(socket, node)
+
+                return
+
+            if self.mode == MODE_NOOP and isCTRLPressed(event):
+                socket = item.socket
+                if socket.hasAnyEdge():
+                    self.mode = MODE_EDGES_REROUTING
+                    self.rerouting.startRerouting(socket)
+                    return
+
+            if self.mode == MODE_NOOP:
+                self.mode = MODE_EDGE_DRAG
+                self.dragging.edgeDragStart(item)
+                return
+
+        if self.mode == MODE_EDGE_DRAG and item is not None:
+            res = self.dragging.edgeDragEnd(item)
+            if res:
+                return
+
+        super().mousePressEvent(event)
+
+    def leftMouseButtonRelease(self, event: QMouseEvent) -> None:
+        """When Left  mouse button was released"""
+
+        # get the item on which we release the mouse button on
+        item = self.getItemAtClick(event)
+
+        try:
+            # logic - Shift + LMB release (add selection)
+            if hasattr(item, "node") or isinstance(item, QDMGraphicsEdge) or item is None:
+                if isSHIFTPressed(event):
+                    event.ignore()
+                    if QT_API in ("pyqt5", "pyside2"):
+                        fakeEvent = QMouseEvent(
+                            event.type(),
+                            event.localPos(),  # type: ignore
+                            event.screenPos(),  # type: ignore
+                            Qt.LeftButton,  # type: ignore
+                            Qt.NoButton,  # type: ignore
+                            event.modifiers() | Qt.ControlModifier  # type: ignore
+                        )
+                    elif QT_API in ("pyqt6", "pyside6"):
+                        fakeEvent = QMouseEvent(
+                            event.type(),
+                            event.position(),
+                            Qt.MouseButton.LeftButton,
+                            Qt.MouseButton.NoButton,
+                            event.modifiers() | Qt.KeyboardModifier.ControlModifier)
+                    super().mouseReleaseEvent(fakeEvent)
+                    return
+
+            if self.mode == MODE_EDGE_DRAG:
+                if self.distanceBetweenClickAndReleaseIsOff(event):
+                    if self.isSnappingEnabled(event):
+                        item = self.snapping.getSnappedSocketItem(event)
+                    if item is not None:
+                        res = self.dragging.edgeDragEnd(item)
+                        if res:
+                            return
+
+            if self.mode == MODE_EDGES_REROUTING:
+                if self.isSnappingEnabled(event):
+                    item = self.snapping.getSnappedSocketItem(event)
+
+                if not EDGE_REROUTING_UE:
+                    # version 2 -- more consistent with the nodeeditor?
+                    if not self.rerouting.first_mb_release:
+                        # for confirmation of first MB release
+                        self.rerouting.first_mb_release = True
+                        # skip any re-routing until first MB was released
+                        return
+
+                self.rerouting.stopRerouting(
+                    item.socket if isinstance(item, QDMGraphicsSocket) else None)
+
+                # don't forget to end the REROUTING MODE
+
+                self.mode = MODE_NOOP
+
+            if self.mode == MODE_EDGE_CUT:
+                self.cutIntersectingEdges()
+                self.cutline.line_points = []
+                self.cutline.update()
+                QApplication.setOverrideCursor(Qt.CursorShape.ArrowCursor)
+                self.mode = MODE_NOOP
+                return
+
+            if self.mode == MODE_NODE_DRAG:
+                scenepos = self.mapToScene(event.pos())
+                self.edgeIntersect.leaveState(scenepos.x(), scenepos.y())
+                try:
+                    self._dropNodesIntoGroupAt(scenepos)
+                except Exception:
+                    pass
+                try:
+                    self._clearGroupDropHighlight()
+                except Exception:
+                    pass
+                self.mode = MODE_NOOP
+                self.update()
+
+            if self.rubberBandDraggingRectangle:
+                self.rubberBandDraggingRectangle = False
+                current_selected_items = self.grScene.selectedItems()
+
+                if current_selected_items != self.grScene.scene._last_selected_items:
+                    if current_selected_items == []:
+                        self.grScene.itemsDeselected.emit()
+                    else:
+                        self.grScene.itemSelected.emit()
+                    self.grScene.scene._last_selected_items = current_selected_items
+
+                # the rubber band rectangle doesn't disappear without handling the event
+                super().mouseReleaseEvent(event)
+                return
+
+            # otherwise deselect everything
+            if item is None:
+                self.grScene.itemsDeselected.emit()
+
+        except:
+            dumpException()
+
+        super().mouseReleaseEvent(event)
+
+    def rightMouseButtonPress(self, event: QMouseEvent) -> None:
+        """When Right mouse button was pressed"""
+        super().mousePressEvent(event)
+
+    def rightMouseButtonRelease(self, event: QMouseEvent) -> None:
+        """When Right mouse button was release"""
+
+        # cannot be because with dragging RMB we spawn Create New Node Context Menu
+        # However, you could use this if you want to cancel with RMB
+        # if self.mode == MODE_EDGE_DRAG:
+        #     self.dragging.edgeDragEnd(None)
+        #     return
+
+        super().mouseReleaseEvent(event)
+
+    def mouseMoveEvent(self, event: Optional[QMouseEvent]) -> None:
+        """Overriden Qt's ``mouseMoveEvent`` handling Scene/View logic"""
+
+        if event is None:
+            return
+
+        scenepos: QPointF = self.mapToScene(event.pos())
+
+        try:
+            # Hover highlight is a CTRL-snapping affordance only. The old code
+            # scanned a 248x248-unit square for sockets on every single move
+            # and, when it found any, repainted the whole viewport - which is
+            # what made panning a large graph stutter. Track the one socket
+            # that can be highlighted and repaint just that item.
+            if self.isSnappingEnabled(event):
+                gr_socket, scenepos = self.snapping.getSnappedToSocketPosition(
+                    scenepos)
+                self._setHighlightedSocket(
+                    gr_socket if isinstance(gr_socket, QDMGraphicsSocket) else None)
+            else:
+                self._setHighlightedSocket(None)
+
+            if self.mode == MODE_EDGE_DRAG:
+                self.dragging.updateDestination(scenepos.x(), scenepos.y())
+
+            if self.mode == MODE_NODE_DRAG:
+                self.edgeIntersect.update(scenepos.x(), scenepos.y())
+                try:
+                    self._updateGroupDropHighlight(scenepos)
+                except Exception:
+                    pass
+
+            if self.mode == MODE_EDGES_REROUTING:
+                self.rerouting.updateScenePos(scenepos.x(), scenepos.y())
+
+            if self.mode == MODE_EDGE_CUT and self.cutline is not None:
+                self.cutline.line_points.append(scenepos)
+                self.cutline.update()
+
+        except Exception as e:
+            dumpException()
+
+        self.last_scene_mouse_position = scenepos
+
+        self.scenePosChanged.emit(int(scenepos.x()), int(scenepos.y()))
+
+        super().mouseMoveEvent(event)
+
+    def keyPressEvent(self, event: Optional[QKeyEvent]) -> None:
+        """
+        .. note::
+            This overridden Qt's method was used for handling key shortcuts, before we implemented proper
+            ``QWindow`` with Actions and Menu. Still the commented code serves as an example on how to handle
+            key presses without Qt's framework for Actions and shortcuts. There is also an example on
+            how to solve the problem when a Node contains Text/LineEdit and we press the `Delete`
+            key (also serving to delete `Node`)
+
+        :param event: Qt's Key event
+        :type event: ``QKeyEvent``
+        :return:
+        """
+
+        if event.key() == Qt.Key.Key_Escape:
+            if self.mode == MODE_EDGE_DRAG:
+                self.dragging.cancelDragEdge()
+                return
+
+        super().keyPressEvent(event)
+
+    def cutIntersectingEdges(self) -> None:
+        """Compare which `Edges` intersect with current `Cut line` and delete them safely"""
+        for ix in range(len(self.cutline.line_points) - 1):
+            p1 = self.cutline.line_points[ix]
+            p2 = self.cutline.line_points[ix + 1]
+
+            # @TODO: we could collect all touched nodes, and notify them once after all edges removed
+            # we could cut 3 edges leading to a single nodeeditor this will notify it 3x
+            # maybe we could use some Notifier class with methods collect() and dispatch()
+            for edge in self.grScene.scene.edges.copy():
+                try:
+                    gr = getattr(edge, 'grEdge', None)
+                    if gr is None:
+                        continue
+                    # never cut hidden internal edges of collapsed groups
+                    try:
+                        if not gr.isVisible():
+                            continue
+                    except Exception:
+                        pass
+                    if gr.intersectsWith(p1, p2):
+                        edge.remove()
+                except Exception:
+                    continue
+        self.grScene.scene.history.storeHistory(
+            "Delete cutted edges", setModified=True)
+
+    def _setHighlightedSocket(self, gr_socket: Optional['QDMGraphicsSocket']) -> None:
+        """Highlight at most one socket, repainting only the two it touches.
+
+        ``getSnappedToSocketPosition`` sets ``isHighlighted`` on the socket it
+        finds; this method keeps that flag in step with what was highlighted
+        last move, so removing the highlight is one repaint of one small item
+        rather than a full-viewport redraw.
+        """
+        if gr_socket is self._highlighted_socket:
+            return
+
+        previous = self._highlighted_socket
+        self._highlighted_socket = gr_socket
+
+        if previous is not None:
+            try:
+                previous.isHighlighted = False
+                previous.update()
+            except RuntimeError:
+                pass  # C++ side already gone
+
+        if gr_socket is not None:
+            gr_socket.isHighlighted = True
+            gr_socket.update()
+
+    def setSocketHighlights(self, scenepos: QPointF, highlighted: bool = True, radius: float = 50):
+        """Set/disable socket highlights in Scene area defined by `scenepos` and `radius`"""
+        scanrect = QRectF(
+            scenepos.x() - radius,
+            scenepos.y() - radius,
+            radius * 2,
+            radius * 2
+        )
+        # Get all items and filter for sockets
+        scene_items = self.grScene.items(scanrect)
+        socket_items: List[QDMGraphicsSocket] = [
+            item for item in scene_items if isinstance(item, QDMGraphicsSocket)
+        ]
+
+        # Set highlight state
+        for grSocket in socket_items:
+            grSocket.isHighlighted = highlighted
+
+        return socket_items
+
+    def _draggedNodes(self):
+        """Nodes being dragged (selected .node items, fallback to edgeIntersect)."""
+        nodes = []
+        try:
+            for item in list(self.grScene.selectedItems()):
+                try:
+                    n = getattr(item, 'node', None)
+                    if n is not None and n not in nodes:
+                        nodes.append(n)
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        if not nodes:
+            try:
+                dn = getattr(getattr(self, 'edgeIntersect', None), 'draggedNode', None)
+                if dn is not None:
+                    nodes = [dn]
+            except Exception:
+                pass
+        return nodes
+
+    def _clearGroupDropHighlight(self) -> None:
+        try:
+            scene = self.grScene.scene
+            for grp in list(getattr(scene, 'groups', [])):
+                try:
+                    if getattr(grp, '_drop_highlight', False):
+                        grp.setDropHighlight(False)
+                except Exception:
+                    continue
+        except Exception:
+            pass
+
+    def _updateGroupDropHighlight(self, scenepos) -> None:
+        try:
+            scene = self.grScene.scene
+            nodes = self._draggedNodes()
+            if not nodes:
+                self._clearGroupDropHighlight()
+                return
+            try:
+                target = scene.findGroupForDrop(scenepos, exclude_nodes=nodes)
+            except Exception:
+                target = None
+            for grp in list(getattr(scene, 'groups', [])):
+                try:
+                    grp.setDropHighlight(grp is target)
+                except Exception:
+                    continue
+        except Exception:
+            pass
+
+    def _dropNodesIntoGroupAt(self, scenepos) -> bool:
+        try:
+            scene = self.grScene.scene
+            nodes = self._draggedNodes()
+            if not nodes:
+                return False
+            changed = scene.dropNodesIntoGroup(nodes, scenepos)
+            if changed:
+                try:
+                    scene.history.storeHistory("Moved nodes into group", setModified=True)
+                except Exception:
+                    pass
+            return changed
+        except Exception:
+            return False
+
+    def deleteSelected(self) -> None:
+        """Delete selected items. Delete-key on a Group = delete Group + Children."""
+        try:
+            from nodeeditor.node_group import Group
+        except Exception:
+            Group = None  # type: ignore
+
+        selected = list(self.grScene.selectedItems())
+        groups = [it for it in selected if Group is not None and isinstance(it, Group)]
+        # delete groups + children first
+        for grp in groups:
+            try:
+                grp.deleteWithChildren()
+            except Exception:
+                continue
+        # delete remaining nodes/edges that still exist (nodes from deleted groups are gone)
+        scene = self.grScene.scene
+        for item in selected:
+            try:
+                if Group is not None and isinstance(item, Group):
+                    continue
+                if isinstance(item, QDMGraphicsEdge):
+                    try:
+                        if getattr(item, 'edge', None) in scene.edges:
+                            item.edge.remove()
+                    except Exception:
+                        pass
+                elif hasattr(item, 'node'):
+                    try:
+                        if getattr(item, 'node', None) in scene.nodes:
+                            item.node.remove()
+                    except Exception:
+                        pass
+            except Exception:
+                continue
+        self.grScene.scene.history.storeHistory(
+            "Delete selected", setModified=True)
+
+    def debug_modifiers(self, event):
+        """Helper function get string if we hold Ctrl, Shift or Alt modifier keys"""
+        out = "MODS: "
+        if isSHIFTPressed(event):
+            out += "SHIFT "
+        if isCTRLPressed(event):
+            out += "CTRL "
+        if isALTPressed(event):
+            out += "ALT "
+        return out
+
+    def getItemAtClick(self, event: QMouseEvent) -> Optional['QGraphicsItem']:
+        """Return the object on which we've clicked/release mouse button
+
+        :param event: Qt's mouse or key event
+        :type event: ``QEvent``
+        :return: ``QGraphicsItem`` which the mouse event happened or ``None``
+        """
+        pos = event.pos()
+        obj = self.itemAt(pos)
+        return obj
+
+    def distanceBetweenClickAndReleaseIsOff(self, event: QMouseEvent) -> bool:
+        """ Measures if we are too far from the last Mouse button click scene position.
+        This is used for detection if we release too far after we clicked on a `Socket`
+
+        :param event: Qt's mouse event
+        :type event: ``QMouseEvent``
+        :return: ``True`` if we released too far from where we clicked before
+        """
+        new_lmb_release_scene_pos = self.mapToScene(event.pos())
+        dist_scene = new_lmb_release_scene_pos - self.last_lmb_click_scene_pos
+        edge_drag_threshold_sq = EDGE_DRAG_START_THRESHOLD*EDGE_DRAG_START_THRESHOLD
+        return (dist_scene.x()*dist_scene.x() + dist_scene.y()*dist_scene.y()) > edge_drag_threshold_sq
+
+    def zoomIn(self):
+        """Step the zoom level up and return the factor to scale the scene by.
+
+        :return: the zoom factor to apply
+        :rtype: ``float``
+        """
+        # self.scale(self.zoomInFactor, self.zoomInFactor)
+        self.zoom += self.zoomStep
+        return self.zoomInFactor
+
+    def zoomOut(self):
+        """Step the zoom level down and return the factor to scale the scene by.
+
+        :return: the zoom factor to apply
+        :rtype: ``float``
+        """
+        # self.scale(1 / self.zoomInFactor, 1 / self.zoomInFactor)
+        self.zoom -= self.zoomStep
+        return 1 / self.zoomInFactor
+
+    def applyZoom(self, zoomFactor: float) -> None:
+        """Scale the scene by ``zoomFactor``, keeping the zoom level inside the configured range.
+
+        :param zoomFactor: the factor to scale the scene by
+        :type zoomFactor: ``float``
+        """
+        clamped = False
+        if self.zoom < self.zoomRange[0]:
+            self.zoom, clamped = self.zoomRange[0], True
+        if self.zoom > self.zoomRange[1]:
+            self.zoom, clamped = self.zoomRange[1], True
+        # set scene scale
+        if not clamped or self.zoomClamp is False:
+            self.scale(zoomFactor, zoomFactor)
+        self._syncDetailLod()
+
+    def _syncDetailLod(self) -> None:
+        """Match the scene's item detail to the view's current zoom.
+
+        Called before the scene is painted, never from inside the paint pass:
+        hiding an item while Qt is painting leaves the pixels it already claimed
+        on screen, and those ghosts then drift with every scroll.
+        """
+        gr_scene = self.scene()
+        updater = getattr(gr_scene, "updateDetailLod", None)
+        if updater is None:
+            return
+        if updater(abs(self.transform().m11())):
+            # The flip changed which items are visible: repaint so the area the
+            # now hidden items occupied is cleared in this pass, not the next.
+            self.viewport().update()
+
+    def paintEvent(self, event) -> None:
+        """Sync the level of detail with the zoom, then paint the scene."""
+        self._syncDetailLod()
+        super().paintEvent(event)
+
+    def wheelEvent(self, event: Optional[QWheelEvent]) -> None:
+        """overridden Qt's ``wheelEvent``. This handles zooming"""
+        if event is None:
+            return
+
+        if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
+            # calculate our zoom Factor
+            zoomOutFactor = 1 / self.zoomInFactor
+
+            # calculate zoom
+            if event.angleDelta().y() > 0:
+                zoomFactor = self.zoomIn()
+            else:
+                zoomFactor = self.zoomOut()
+
+            self.applyZoom(zoomFactor)
+
+        elif event.modifiers() == Qt.KeyboardModifier.ShiftModifier:
+            # Redirect vertical scrolling to horizontal scrolling
+            scroll_amount = event.angleDelta().y()  # Get the vertical delta
+            scroll_bar = self.horizontalScrollBar()
+            if scroll_bar is not None:
+                scroll_bar.setValue(scroll_bar.value() - scroll_amount)
+            # self.horizontalScrollBar().setValue(
+            #     self.horizontalScrollBar().value() - scroll_amount)
+            # self.horizontalScrollBar().setValue(2)
+
+        else:
+            # Normal scrolling
+            super().wheelEvent(event)