nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_edge.py

@@ -0,0 +1,518 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing NodeEditor's class for representing Edge and Edge Type Constants.
+"""
+from collections import OrderedDict
+from nodeeditor.node_graphics_edge import QDMGraphicsEdge
+from nodeeditor.node_serializable import Serializable
+from nodeeditor.utils_no_qt import dumpException
+
+from typing import TYPE_CHECKING, List, Optional, Tuple, Any, Callable
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_socket import Socket
+    from nodeeditor.node_scene import Scene
+
+
+EDGE_TYPE_DIRECT = 1        #:
+EDGE_TYPE_BEZIER = 2        #:
+EDGE_TYPE_SQUARE = 3        #:
+EDGE_TYPE_IMPROVED_SHARP = 4       #:
+EDGE_TYPE_IMPROVED_BEZIER = 5       #:
+EDGE_TYPE_DEFAULT = EDGE_TYPE_IMPROVED_BEZIER
+
+DEBUG = False
+
+
+class Edge(Serializable):
+    """
+    Class for representing Edge in NodeEditor.
+    """
+
+    #: class variable containing list of registered edge validators
+    edge_validators: List['function'] = []
+
+    def __init__(self, scene: 'Scene', start_socket: 'Socket' = None, end_socket: 'Socket' = None,
+                 edge_type=EDGE_TYPE_DIRECT, label: str = "", input_index: int = -1) -> None:
+        """
+
+        :param scene: Reference to the :py:class:`~nodeeditor.node_scene.Scene`
+        :type scene: :py:class:`~nodeeditor.node_scene.Scene`
+        :param start_socket: Reference to the starting socket
+        :type start_socket: :py:class:`~nodeeditor.node_socket.Socket`
+        :param end_socket: Reference to the End socket or ``None``
+        :type end_socket: :py:class:`~nodeeditor.node_socket.Socket` or ``None``
+        :param edge_type: Constant determining type of edge. See :ref:`edge-type-constants`
+        :param label: Code-set text drawn on top of the edge. Not editable by
+            the user in the view; change it from code via ``edge.label = ...``
+            or ``edge.setLabel(...)`` at creation time or runtime.
+        :param input_index: Read position of this `Edge` on its **end** (input)
+            :class:`~nodeeditor.node_socket.Socket`, ``0`` being read first.
+            Only meaningful when ``end_socket`` is an input socket accepting
+            multiple `Edges`; pass ``-1`` (the default) to append the `Edge`,
+            i.e. read it last. See :ref:`multi-input-nodes`.
+
+        :Instance Attributes:
+
+            - **scene** - reference to the :class:`~nodeeditor.node_scene.Scene`
+            - **grEdge** - Instance of :class:`~nodeeditor.node_graphics_edge.QDMGraphicsEdge` subclass handling graphical representation in the ``QGraphicsScene``.
+        """
+        super().__init__()
+        self.scene = scene
+
+        # default init
+        self._start_socket = None
+        self._end_socket = None
+
+        # Must be set *before* attaching the sockets: an ordered input
+        # `Socket` reads it in `addEdge()` to place this Edge at the right
+        # slot instead of appending it.
+        self.input_index = input_index
+
+        self.start_socket = start_socket
+        self.end_socket = end_socket
+        self._edge_type = edge_type
+
+        # create Graphics Edge instance
+        self.grEdge: QDMGraphicsEdge = self.createEdgeClassInstance()
+
+        if label:
+            self.setLabel(label)
+
+        self.scene.addEdge(self)
+
+    def __str__(self) -> str:
+        """A short description of this `Edge` and the two sockets it connects"""
+        return "<Edge %s..%s -- S:%s E:%s>" % (
+            hex(id(self))[2:5], hex(id(self))[-3:],
+            self.start_socket, self.end_socket
+        )
+
+    @property
+    def input_index(self) -> int:
+        """
+        Read position of this `Edge` on its end (input) :class:`~nodeeditor.node_socket.Socket`.
+
+        ``0`` is read first, ``1`` next, and so on. Only meaningful for `Edges`
+        whose ``end_socket`` is an input socket; the owning
+        :class:`~nodeeditor.node_socket.Socket` owns and compacts the value, so
+        assign it from code only together with
+        :meth:`~nodeeditor.node_socket.Socket.compactEdgeOrder`. Use
+        :class:`~nodeeditor.node_multi_input_node.MultiInputNode` for a safe
+        reordering API.
+
+        :getter: current read position, or ``-1`` when not attached to an input socket
+        :setter: coerces to ``int``; anything invalid becomes ``-1``
+        :type: ``int``
+        """
+        return self._input_index
+
+    @input_index.setter
+    def input_index(self, value) -> None:
+        try:
+            self._input_index = int(value)
+        except (TypeError, ValueError):
+            self._input_index = -1
+
+    @property
+    def start_socket(self) -> Optional["Socket"]:
+        """
+        Start socket
+
+        :getter: Returns start :class:`~nodeeditor.node_socket.Socket`
+        :setter: Sets start :class:`~nodeeditor.node_socket.Socket` safely
+        :type: :class:`~nodeeditor.node_socket.Socket`
+        """
+        return self._start_socket if self._start_socket else None
+
+    @start_socket.setter
+    def start_socket(self, value: "Socket") -> None:
+        # if we were assigned to some socket before, delete us from the socket
+        if self._start_socket is not None:
+            self._start_socket.removeEdge(self)
+
+        # assign new start socket
+        self._start_socket = value
+        # addEdge to the Socket class
+        if self.start_socket is not None:
+            self.start_socket.addEdge(self)
+
+    @property
+    def end_socket(self):
+        """
+        End socket
+
+        :getter: Returns end :class:`~nodeeditor.node_socket.Socket` or ``None`` if not set
+        :setter: Sets end :class:`~nodeeditor.node_socket.Socket` safely
+        :type: :class:`~nodeeditor.node_socket.Socket` or ``None``
+        """
+        return self._end_socket
+
+    @end_socket.setter
+    def end_socket(self, value) -> None:
+        # if we were assigned to some socket before, delete us from the socket
+        if self._end_socket is not None:
+            self._end_socket.removeEdge(self)
+
+        # assign new end socket
+        self._end_socket = value
+        # addEdge to the Socket class
+        if self.end_socket is not None:
+            self.end_socket.addEdge(self)
+            if not self.end_socket.is_input:
+                # a read position is only meaningful on an input socket
+                self.input_index = -1
+
+    @property
+    def edge_type(self):
+        """
+        Edge type
+
+        :getter: get edge type constant for current ``Edge``. See :ref:`edge-type-constants`
+        :setter: sets new edge type. On background, creates new :class:`~nodeeditor.node_graphics_edge.QDMGraphicsEdge`
+            child class if necessary, adds this ``QGraphicsPathItem`` to the ``QGraphicsScene`` and updates edge sockets
+            positions.
+        """
+        return self._edge_type
+
+    @edge_type.setter
+    def edge_type(self, value) -> None:
+        # assign new value
+        self._edge_type = value
+
+        # update the grEdge pathCalculator
+        self.grEdge.createEdgePathCalculator()
+
+        if self.start_socket is not None:
+            self.updatePositions()
+
+    @property
+    def label(self) -> str:
+        """
+        Code-set text drawn on top of the edge.
+
+        :getter: current label text (``""`` when unset)
+        :setter: sets new label text; ``""``/``None`` hides the label.
+            Not user-editable in the view -- change only from code, both at
+            creation time (``Edge(..., label="...")``) and at runtime
+            (``edge.label = "..."``).
+        """
+        return self.grEdge.label()
+
+    @label.setter
+    def label(self, value: str) -> None:
+        self.setLabel(value)
+
+    def getLabel(self) -> str:
+        """Return the current code-set edge label."""
+        return self.grEdge.label()
+
+    def setLabel(self, text: str) -> None:
+        """Set the text drawn on top of the edge (``""`` hides it)."""
+        self.grEdge.setLabel(text)
+
+    @classmethod
+    def getEdgeValidators(cls):
+        """Return the list of Edge Validator Callbacks"""
+        return cls.edge_validators
+
+    @classmethod
+    def registerEdgeValidator(cls, validator_callback: 'function') -> None:
+        """Register Edge Validator Callback
+
+        :param validator_callback: A function handle to validate Edge
+        :type validator_callback: `function`
+        """
+        cls.edge_validators.append(validator_callback)
+
+    @classmethod
+    def validateEdge(cls, start_socket: 'Socket', end_socket: 'Socket') -> bool:
+        """Validate Edge agains all registered `Edge Validator Callbacks`
+
+        :param start_socket: Starting :class:`~nodeeditor.node_socket.Socket` of Edge to check
+        :type start_socket: :class:`~nodeeditor.node_socket.Socket`
+        :param end_socket: Target/End :class:`~nodeeditor.node_socket.Socket` of Edge to check
+        :type end_socket: :class:`~nodeeditor.node_socket.Socket`
+        :return: ``True`` if the Edge is valid or ``False`` if not
+        :rtype: ``bool``
+        """
+        for validator in cls.getEdgeValidators():
+            if not validator(start_socket, end_socket):
+                return False
+        return True
+
+    def reconnect(self, from_socket: 'Socket', to_socket: 'Socket') -> None:
+        """Helper function which reconnects edge `from_socket` to `to_socket`"""
+        if self.start_socket == from_socket:
+            self.start_socket = to_socket
+        elif self.end_socket == from_socket:
+            self.end_socket = to_socket
+
+    def getGraphicsEdgeClass(self):
+        """Returns the class representing Graphics Edge"""
+        return QDMGraphicsEdge
+
+    def createEdgeClassInstance(self):
+        """
+        Create instance of grEdge class
+        :return: Instance of `grEdge` class representing the Graphics Edge in the grScene
+        """
+        self.grEdge = self.getGraphicsEdgeClass()(self)
+        self.scene.grScene.addItem(self.grEdge)
+        if self.start_socket is not None:
+            self.updatePositions()
+        return self.grEdge
+
+    def getOtherSocket(self, known_socket: 'Socket'):
+        """
+        Returns the opposite socket on this ``Edge``
+
+        :param known_socket: Provide known :class:`~nodeeditor.node_socket.Socket` to be able to determine the opposite one.
+        :type known_socket: :class:`~nodeeditor.node_socket.Socket`
+        :return: The oposite socket on this ``Edge`` or ``None``
+        :rtype: :class:`~nodeeditor.node_socket.Socket` or ``None``
+        """
+        return self.start_socket if known_socket == self.end_socket else self.end_socket
+
+    def doSelect(self, new_state: bool = True) -> None:
+        """
+        Provide the safe selecting/deselecting operation. In the background it takes care about the flags, notifications
+        and storing history for undo/redo.
+
+        :param new_state: ``True`` if you want to select the ``Edge``, ``False`` if you want to deselect the ``Edge``
+        :type new_state: ``bool``
+        """
+        self.grEdge.doSelect(new_state)
+
+    def updatePositions(self) -> None:
+        """
+        Updates the internal `Graphics Edge` positions.
+
+        Collapsed-group aware: if an endpoint lives in a collapsed Group,
+        the endpoint is overridden to that group's per-edge stub row.
+        Logical sockets are never mutated. Internal edges of a collapsed
+        group stay hidden.
+        """
+        try:
+            if self.start_socket is None:
+                return
+            if getattr(self, 'grEdge', None) is None:
+                return
+
+            start_node = getattr(self.start_socket, 'node', None)
+            end_node = getattr(self.end_socket, 'node', None) if self.end_socket is not None else None
+
+            start_group = None
+            end_group = None
+            try:
+                if start_node is not None:
+                    start_group = self.scene.findCollapsedGroupForNode(start_node)
+                if end_node is not None:
+                    end_group = self.scene.findCollapsedGroupForNode(end_node)
+            except Exception:
+                start_group = end_group = None
+
+            # internal edge of a collapsed group -> keep hidden
+            try:
+                if start_group is not None and start_group is end_group and end_group is not None:
+                    try:
+                        self.grEdge.hide()
+                    except Exception:
+                        pass
+                    return
+            except Exception:
+                pass
+
+            # source
+            source_pos = None
+            try:
+                if start_group is not None:
+                    p = start_group.stubPosFor(self)
+                    if p is not None:
+                        source_pos = [p.x(), p.y()]
+                if source_pos is None:
+                    gs = getattr(self.start_socket, 'grSocket', None)
+                    if gs is None:
+                        return
+                    sp = gs.scenePos()
+                    source_pos = [sp.x(), sp.y()]
+            except Exception:
+                return
+            self.grEdge.setSource(*source_pos)
+
+            if self.end_socket is not None:
+                end_pos = None
+                try:
+                    if end_group is not None:
+                        p = end_group.stubPosFor(self)
+                        if p is not None:
+                            end_pos = [p.x(), p.y()]
+                    if end_pos is None:
+                        gs = getattr(self.end_socket, 'grSocket', None)
+                        if gs is None:
+                            self.grEdge.setDestination(*source_pos)
+                            self.grEdge.update()
+                            return
+                        ep = gs.scenePos()
+                        end_pos = [ep.x(), ep.y()]
+                except Exception:
+                    end_pos = list(source_pos)
+                self.grEdge.setDestination(*end_pos)
+            else:
+                self.grEdge.setDestination(*source_pos)
+            self.grEdge.update()
+        except Exception:
+            try:
+                dumpException()
+            except Exception:
+                pass
+
+    def remove_from_sockets(self) -> None:
+        """
+        Helper function which sets start and end :class:`~nodeeditor.node_socket.Socket` to ``None``
+        """
+        self.end_socket = None
+        self.start_socket = None
+        # forget the read position; re-attaching appends at the end by default
+        self.input_index = -1
+
+    def remove(self, silent_for_socket: 'Socket' = None, silent: bool=False) -> None:
+        """
+        Safely remove this Edge.
+
+        Removes `Graphics Edge` from the ``QGraphicsScene`` and it's reference to all GC to clean it up.
+        Notifies nodes previously connected :class:`~nodeeditor.node_node.Node` (s) about this event.
+
+        Triggers Nodes':
+
+        - :py:meth:`~nodeeditor.node_node.Node.onEdgeConnectionChanged`
+        - :py:meth:`~nodeeditor.node_node.Node.onInputChanged`
+
+        :param silent_for_socket: :class:`~nodeeditor.node_socket.Socket` of a :class:`~nodeeditor.node_node.Node` which
+            won't be notified, when this ``Edge`` is going to be removed
+        :type silent_for_socket: :class:`~nodeeditor.node_socket.Socket`
+        :param silent: ``True`` if no events should be triggered during removing
+        :type silent: ``bool``
+        """
+        old_sockets = [self.start_socket, self.end_socket]
+
+        # ugly hack, since I noticed that even when you remove grEdge from scene,
+        # sometimes it stays there! How dare you Qt!
+        if DEBUG:
+            print(" - hide grEdge")
+        self.grEdge.hide()
+
+        if DEBUG:
+            print(" - remove grEdge", self.grEdge)
+        self.scene.grScene.removeItem(self.grEdge)
+        if DEBUG:
+            print("   grEdge:", self.grEdge)
+
+        self.scene.grScene.update()
+
+        if DEBUG:
+            print("# Removing Edge", self)
+        if DEBUG:
+            print(" - remove edge from all sockets")
+        self.remove_from_sockets()
+        if DEBUG:
+            print(" - remove edge from scene")
+        try:
+            self.scene.removeEdge(self)
+        except ValueError:
+            pass
+        if DEBUG:
+            print(" - everything is done.")
+
+        try:
+            # notify nodes from old sockets
+            for socket in old_sockets:
+                if socket and socket.node:
+                    if silent:
+                        continue
+                    if silent_for_socket is not None and socket == silent_for_socket:
+                        # if we requested silence for Socket and it's this one, skip notifications
+                        continue
+
+                    # notify Socket's Node
+                    socket.node.onEdgeConnectionChanged(self)
+                    if socket.is_input:
+                        socket.node.onInputChanged(socket)
+
+        except Exception as e:
+            dumpException(e)
+
+    def serialize(self) -> OrderedDict:
+        """
+        Serialize this `Edge` into an ``OrderedDict`` for storing in memory or on disk.
+
+        :return: data serialized in ``OrderedDict``
+        :rtype: ``OrderedDict``
+        """
+        return OrderedDict([
+            ('id', self.id),
+            ('edge_type', self.edge_type),
+            ('start', self.start_socket.id if self.start_socket is not None else None),
+            ('end', self.end_socket.id if self.end_socket is not None else None),
+            ('label', self.getLabel()),
+            ('input_index', self.input_index),
+        ])
+
+    def deserialize(self, data: dict, hashmap: dict = {}, restore_id: bool = True, *args, **kwargs) -> bool:
+        """
+        Deserialize this `Edge` from a ``dict`` of serialized data.
+
+        Both sockets are looked up in the ``hashmap``, so they have to be
+        deserialized before the edge that connects them.
+
+        :param data: Dictionary containing serialized data
+        :type data: ``dict``
+        :param hashmap: Helper dictionary containing references (by id == key) to existing objects
+        :type hashmap: ``dict``
+        :param restore_id: True if we are creating new Edges. False is useful when loading existing
+            Edges of which we want to keep the existing object's `id`.
+        :type restore_id: bool
+        :return: ``True`` if deserialization was successful, otherwise ``False``
+        :rtype: ``bool``
+        """
+        try:
+            if restore_id:
+                self.id = data['id']
+            # Restore the read position *before* attaching the sockets: an
+            # ordered input `Socket` inserts the `Edge` at this slot. Old files
+            # without the key load as -1, i.e. order of connection in the file.
+            self.input_index = data.get('input_index', -1)
+            try:
+                start_id = data.get('start', None)
+                end_id = data.get('end', None)
+            except Exception:
+                return False
+            if start_id not in hashmap or end_id not in hashmap:
+                return False
+            self.start_socket = hashmap[start_id]
+            self.end_socket = hashmap[end_id]
+            if self.start_socket is None or self.end_socket is None:
+                return False
+            self.edge_type = data['edge_type']
+            # 'label' is optional so old files without it still load
+            self.setLabel(data.get('label', "") or "")
+            return True
+        except Exception:
+            try:
+                dumpException()
+            except Exception:
+                pass
+            return False
+
+
+# Example: using validators for Edge
+# You can register edge validators wherever you want, even here...
+# However if you do use overridden Edge, you should call registerEdgeValidator on that overridden class
+#
+# from nodeeditor.node_edge_validators import *
+# Edge.registerEdgeValidator(edge_validator_debug)
+# Edge.registerEdgeValidator(edge_cannot_connect_two_outputs_or_two_inputs)
+# Edge.registerEdgeValidator(edge_cannot_connect_input_and_output_of_same_node)
+# Edge.registerEdgeValidator(edge_cannot_connect_input_and_output_of_different_color)

nodeeditor/node_edge_dragging.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Edge Dragging functionality
+"""
+from nodeeditor.node_graphics_socket import QDMGraphicsSocket
+from nodeeditor.node_edge import EDGE_TYPE_DEFAULT
+from nodeeditor.utils import dumpException
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qtpy.QtWidgets import QGraphicsItem
+    from nodeeditor.node_socket import Socket
+    from nodeeditor.node_edge import Edge
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+
+DEBUG = False
+
+
+class EdgeDragging:
+    """Class handling the dragging of a new :class:`~nodeeditor.node_edge.Edge` between sockets"""
+
+    def __init__(self, grView: 'QDMGraphicsView') -> None:
+        """
+        :param grView: reference to the :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+        :type grView: :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+
+        :Instance Attributes:
+
+        - **grView** - reference to the :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+        - **drag_edge** - the :class:`~nodeeditor.node_edge.Edge` currently being dragged
+        - **drag_start_socket** - the :class:`~nodeeditor.node_socket.Socket` where the drag started
+        """
+        self.grView = grView
+        # initializing these variable to know we're using them in this class...
+        self.drag_edge: Edge | None = None
+        self.drag_start_socket: Socket | None = None
+
+    def getEdgeClass(self):
+        """Helper function to get the Edge class. Using what Scene class provides"""
+        return self.grView.grScene.scene.getEdgeClass()
+
+    def updateDestination(self, x: float, y: float) -> None:
+        """
+        Update the end point of our dragging edge
+
+        :param x: new X scene position
+        :param y: new Y scene position
+        """
+        # according to sentry: 'NoneType' object has no attribute 'grEdge'
+        if self.drag_edge is None:
+            print(">>> Warning: drag_edge is None!")
+            return
+
+        if self.drag_edge.grEdge is None:
+            print(">>> Warning: drag_edge.grEdge is None!")
+            return
+
+        self.drag_edge.grEdge.setDestination(x, y)
+        self.drag_edge.grEdge.update()
+
+    def edgeDragStart(self, item: QDMGraphicsSocket) -> None:
+        """Code handling the start of a dragging an `Edge` operation"""
+        try:
+            if DEBUG:
+                print('View::edgeDragStart ~ Start dragging edge')
+            if DEBUG:
+                print('View::edgeDragStart ~   assign Start Socket to:', item.socket)
+            self.drag_start_socket = item.socket
+            self.drag_edge = self.getEdgeClass()(
+                item.socket.node.scene, item.socket, None, EDGE_TYPE_DEFAULT)
+
+            if self.drag_edge is None:
+                print(">>> Warning: Failed to create drag_edge")
+                return
+
+            if self.drag_edge.grEdge is None:
+                print(">>> Warning: drag_edge.grEdge is None")
+                return
+
+            self.drag_edge.grEdge.makeUnselectable()
+
+            if DEBUG:
+                print('View::edgeDragStart ~   dragEdge:', self.drag_edge)
+
+        except Exception as e:
+            dumpException(e)
+
+    def edgeDragEnd(self, item: 'QGraphicsItem'):
+        """Code handling the end of the dragging an `Edge` operation. If this code returns True then skip the
+        rest of the mouse event processing. Can be called with ``None`` to cancel the edge dragging mode
+
+        :param item: Item in the `Graphics Scene` where we ended dragging an `Edge`
+        :type item: ``QGraphicsItem``
+        """
+
+        # Cancel edge if clicking on empty space or receiving None (ESC pressed)
+        if item is None or not isinstance(item, QDMGraphicsSocket):
+            self.cancelDragEdge()
+            return False
+
+        # early out - clicked on something else than Socket
+        if not isinstance(item, QDMGraphicsSocket):
+            self.grView.resetMode()
+            if DEBUG:
+                print('View::edgeDragEnd ~ End dragging edge early')
+
+            # don't notify sockets about removing drag_edge
+            if self.drag_edge is not None:
+                self.drag_edge.remove(silent=True)
+            self.drag_edge = None
+            return
+
+        # clicked on socket
+        if isinstance(item, QDMGraphicsSocket):
+            if self.drag_edge is None or self.drag_start_socket is None:
+                return False
+
+            # check if edge would be valid
+            if not self.drag_edge.validateEdge(self.drag_start_socket, item.socket):
+                print("NOT VALID EDGE")
+                return False
+
+            # regular processing of drag edge
+            self.grView.resetMode()
+
+            if DEBUG:
+                print('View::edgeDragEnd ~ End dragging edge')
+            # don't notify sockets about removing drag_edge
+            self.drag_edge.remove(silent=True)
+            self.drag_edge = None
+
+            try:
+                if item.socket != self.drag_start_socket:
+                    # First verify both sockets exist
+                    if self.drag_start_socket is None:
+                        print(">>> Warning: drag_start_socket is None!")
+                        return False
+
+                    # First remove old edges / send notifications
+                    for socket in (item.socket, self.drag_start_socket):
+                        if socket is None:
+                            print(">>> Warning: socket is None!")
+                            continue
+
+                        if not socket.is_multi_edges:
+                            if socket.is_input:
+                                socket.removeAllEdges(silent=True)
+                            else:
+                                socket.removeAllEdges(silent=False)
+
+                    # Create new Edge
+                    new_edge = self.getEdgeClass()(item.socket.node.scene, self.drag_start_socket,
+                                                   item.socket, edge_type=EDGE_TYPE_DEFAULT)
+                    if DEBUG:
+                        print("View::edgeDragEnd ~  created new edge:", new_edge,
+                              "connecting", new_edge.start_socket, "<-->", new_edge.end_socket)
+
+                    # Send notifications for the new edge
+                    for socket in [self.drag_start_socket, item.socket]:
+                        # @TODO: Add possibility (ie when an input edge was replaced) to be silent and don't trigger change
+                        socket.node.onEdgeConnectionChanged(new_edge)
+                        if socket.is_input:
+                            socket.node.onInputChanged(socket)
+
+                    self.grView.grScene.scene.history.storeHistory(
+                        "Created new edge by dragging", setModified=True)
+                    return True
+            except Exception as e:
+                dumpException(e)
+
+        if DEBUG:
+            print('View::edgeDragEnd ~ everything done.')
+        return False
+
+    def cancelDragEdge(self) -> None:
+        """Cancel the edge dragging operation and clean up"""
+        self.grView.resetMode()
+        if DEBUG:
+            print('View::cancelDragEdge ~ Cancel dragging edge')
+
+        if self.drag_edge is not None:
+            self.drag_edge.remove(silent=True)
+            self.drag_edge = None
+        self.drag_start_socket = None