nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_edge_intersect.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the intersecting nodes functionality. If a node gets dragged and dropped on an existing edge
+it will intersect that edge.
+"""
+from qtpy.QtWidgets import QGraphicsView, QGraphicsItem
+from qtpy.QtCore import QRectF, QPointF
+from nodeeditor.node_edge import Edge
+from nodeeditor.node_graphics_edge import QDMGraphicsEdge
+
+from typing import TYPE_CHECKING, Union, List
+
+from nodeeditor.node_socket import Socket
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_node import Node
+    from nodeeditor.node_graphics_scene import QDMGraphicsScene
+
+
+class EdgeIntersect:
+    """Class handling the intersection of a dragged node with an existing edge"""
+
+    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`
+        - **grScene** - reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
+        - **draggedNode** - the :class:`~nodeeditor.node_node.Node` currently being dragged
+        - **hoveredList** - graphics items hovered by the dragged node
+        """
+        self.grView = grView
+        self.grScene: 'QDMGraphicsScene' = grView.grScene
+        self.draggedNode: Node | None = None
+        self.hoveredList: List[Union['QDMGraphicsEdge',
+                                     'QGraphicsItem', 'QGraphicsView', 'Socket', 'Node']] = []
+
+    def enterState(self, node: 'Node') -> None:
+        """
+        Initialize when we enter the state
+
+        :param node: :class:`~nodeeditor.node_node.Node` which we started to drag
+        :type node: :class:`~nodeeditor.node_node.Node`
+        """
+        self.hoveredList = []
+        self.draggedNode = node
+
+    def leaveState(self, scene_pos_x: float, scene_pos_y: float) -> None:
+        """
+        Deinit when we leave this state
+
+        :param scene_pos_x: scene position x
+        :type scene_pos_x: `float`
+        :param scene_pos_y: scene position y
+        :type scene_pos_y: `float`
+        """
+        if self.draggedNode is None:
+            print(">>> Warning: self.draggedNode is None")
+            return
+
+        self.dropNode(self.draggedNode, scene_pos_x, scene_pos_y)
+        self.draggedNode = None
+        self.hoveredList = []
+
+    def dropNode(self, node: "Node", scene_pos_x: float, scene_pos_y: float) -> None:
+        """
+        Code handling the dropping of a node on an existing edge.
+
+        :param scene_pos_x: scene position x
+        :type scene_pos_x: `float`
+        :param scene_pos_y: scene position y
+        :type scene_pos_y: `float`
+        """
+
+        node_box = self.hotZoneRect(node)
+
+        # check if the node is dropped on an existing edge
+        edge = self.intersect(node_box)
+        if edge is None:
+            return
+
+        if self.isConnected(node):
+            return
+
+        # determine the order of start and end
+        if edge.start_socket.is_output:
+            socket_start = edge.start_socket
+            socket_end = edge.end_socket
+        else:
+            socket_start = edge.end_socket
+            socket_end = edge.start_socket
+
+        new_node_socket_in = node.inputs[0]
+        new_node_socket_out = node.outputs[0]
+
+        # Validate like manual drag does before touching the original edge.
+        if not Edge.validateEdge(socket_start, new_node_socket_in):
+            return
+        if not Edge.validateEdge(new_node_socket_out, socket_end):
+            return
+
+        # Use the Scene's Edge class so subclasses survive splits
+        # (hardcoded Edge() would silently downgrade them).
+        edge_class = self.grScene.scene.getEdgeClass()
+
+        # The new edges will have the same edge_type as the intersected edge
+        edge_type = edge.edge_type
+        edge.remove()
+        self.grView.grScene.scene.history.storeHistory(
+            'Delete existing edge', setModified=True)
+
+        e1 = edge_class(self.grScene.scene, socket_start,
+                        new_node_socket_in, edge_type=edge_type)
+        e2 = edge_class(self.grScene.scene, new_node_socket_out,
+                        socket_end, edge_type=edge_type)
+
+        # Notify exactly like manual drag (EdgeDragging.edgeDragEnd) so nodes
+        # relying on onEdgeConnectionChanged/onInputChanged (dirty marking,
+        # re-eval, cached input data) behave identically for auto-splits.
+        for socket, new_edge in ((socket_start, e1), (new_node_socket_in, e1),
+                                 (new_node_socket_out, e2), (socket_end, e2)):
+            try:
+                socket.node.onEdgeConnectionChanged(new_edge)
+                if socket.is_input:
+                    socket.node.onInputChanged(socket)
+            except Exception:
+                continue
+
+        self.grView.grScene.scene.history.storeHistory(
+            'Created new edges by dropping node', setModified=True)
+
+    def hotZoneRect(self, node: 'Node') -> 'QRectF':
+        """
+        Returns A QRectF of creating a box around a node
+
+        :param node: :class:`~nodeeditor.node_node.Node` for which we want to get `QRectF` describing its position and area
+        :type node: :class:`~nodeeditor.node_node.Node`
+        :return: `QRectF` describing node's position and area
+        :rtype: `QRectF`
+        """
+        if node.grNode is None:
+            print(">>> Warning: node is None")
+            return QRectF()
+
+        nodePos: QPointF = node.grNode.scenePos()
+        x = nodePos.x()
+        y = nodePos.y()
+        w = node.grNode.width
+        h = node.grNode.height
+        return QRectF(x, y, w, h)
+
+    def update(self, scene_pos_x: float, scene_pos_y: float) -> None:
+        """
+        Updating during mouse move when grView is in this state
+
+        :param scene_pos_x: scene position x
+        :type scene_pos_x: `float`
+        :param scene_pos_y: scene position y
+        :type scene_pos_y: `float`
+        """
+        if self.draggedNode is None:
+            print(">>> Warning: self.draggedNode is None")
+            return
+
+        rect = self.hotZoneRect(self.draggedNode)
+        grItems = self.grScene.items(rect)
+
+        for grEdge in self.hoveredList:
+            if isinstance(grEdge, QDMGraphicsEdge):
+                grEdge.hovered = False
+
+        self.hoveredList = []
+
+        for grItem in grItems:
+            if hasattr(grItem, 'edge') and not self.draggedNode.hasConnectedEdge(grItem.edge):
+                self.hoveredList.append(grItem)
+                if hasattr(grItem, 'hovered'):
+                    grItem.hovered = True
+
+    def intersect(self, node_box: 'QRectF') -> Union['Edge', None]:
+        """
+        Checking for intersection of a rectangle (usually a `Node`) with edges in the scene
+
+        :param node_box: `QRectF` for which we want find intersecting `Edges`
+        :type node_box: `QRectF`
+        :return: :class:`~nodeeditor.node_edge.Edge` or `None` if the node is being cut by an `Edge`
+        :rtype: :class:`~nodeeditor.node_edge.Edge`
+        """
+
+        if self.draggedNode is None:
+            print(">>> Warning: self.draggedNode is None")
+            return None
+
+        # returns the first edge that intersects with the dropped node, ignores the rest
+        grItems = self.grScene.items(node_box)
+        for grItem in grItems:
+            if hasattr(grItem, 'edge') and not self.draggedNode.hasConnectedEdge(grItem.edge):
+                return grItem.edge
+        return None
+
+    def isConnected(self, node: 'Node'):
+        """
+        Return ``True`` if node got any connections
+
+        :param node: :class:`~nodeeditor.node_node.Node` which connections to check
+        :type node: :class:`~nodeeditor.node_node.Node`
+        :return:
+        """
+        # Nodes with only inputs or outputs are excluded
+        if node.inputs == [] or node.outputs == []:
+            return True
+
+        # Check if the node has edges connected
+        return node.getInput() or node.getOutputs()

nodeeditor/node_edge_rerouting.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Edge Rerouting functionality
+"""
+
+
+from typing import TYPE_CHECKING, List, Optional, Tuple, Any
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_edge import Edge
+    from nodeeditor.node_socket import Socket
+
+
+DEBUG_REROUTING = True
+
+
+class EdgeRerouting:
+    """Class handling the re-routing of existing edges to another socket"""
+
+    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`
+        - **start_socket** - the :class:`~nodeeditor.node_socket.Socket` where the re-routing started
+        - **rerouting_edges** - dashed edges representing the re-routing in progress
+        - **is_rerouting** - are we currently re-routing?
+        - **first_mb_release** - flag for detecting if we already clicked with the rerouting LMB release
+        """
+        self.grView = grView
+        # store where we started re-routing the edges
+        self.start_socket: Optional['Socket'] = None
+        # edges representing the re-routing (dashed edges)
+        self.rerouting_edges: List['Edge'] = []
+        self.is_rerouting: bool = False       # are we currently re-routing?
+        # flag for detecting if we already clicked with the rerouting LMB release
+        self.first_mb_release: bool = False
+
+    def print(self, *args) -> None:
+        """Helper function to better control debug printing to console for this feature"""
+        if DEBUG_REROUTING:
+            print("REROUTING:", *args)
+
+    def getEdgeClass(self):
+        """Helper function to get the Edge class. Using what the Scene class provides"""
+        return self.grView.grScene.scene.getEdgeClass()
+
+    def getAffectedEdges(self) -> list:
+        """
+        Get a list of all edges connected to the `self.start_socket` where we started the re-routing
+
+        :return: List of all edges affected by the rerouting started from this `self.start_socket` :class:`~nodeeditor.node_socket.Socket`
+        :rtype: ``list``
+        """
+        if self.start_socket is None:
+            return []       # no starting socket assigned, so no edges for us
+        # return edges connected to the socket
+        return self.start_socket.edges.copy()
+
+    def setAffectedEdgesVisible(self, visibility: bool = True) -> None:
+        """
+        Show/Hide all edges connected to the `self.start_socket` where we started the re-routing
+
+        :param visibility: ``True`` if all the affected :class:`~nodeeditor.node_edge.Edge` (s) should be shown or hidden
+        :type visibility: ``bool``
+        """
+        for edge in self.getAffectedEdges():
+            if visibility:
+                edge.grEdge.show()
+            else:
+                edge.grEdge.hide()
+
+    def resetRerouting(self) -> None:
+        """Reset to default state. Init this feature internal variables"""
+        self.is_rerouting = False
+        self.start_socket = None
+        self.first_mb_release = False
+        # holding all rerouting edges should be empty at this point...
+        # self.rerouting_edges = []
+
+    def clearReroutingEdges(self) -> None:
+        """Remove the helping dashed edges from the :class:`~nodeeditor.node_scene.Scene`"""
+        self.print("clean called")
+        while self.rerouting_edges != []:
+            edge = self.rerouting_edges.pop()
+            self.print("\twant to clean:", edge)
+            edge.remove()
+
+    def updateScenePos(self, x: float, y: float) -> None:
+        """
+        Update position of all the rerouting edges (dashed ones). Called from mouseMove event to update to new mouse position
+
+        :param x: new X position
+        :type x: ``float``
+        :param y: new Y position
+        :type y: ``float``
+        """
+        if self.is_rerouting:
+            for edge in self.rerouting_edges:
+                if edge and edge.grEdge:
+                    edge.grEdge.setDestination(x, y)
+                    edge.grEdge.update()
+
+    def startRerouting(self, socket: 'Socket') -> None:
+        """
+        Method to start the re-routing. Called from the grView's state machine.
+
+        :param socket: :class:`~nodeeditor.node_socket.Socket` where we started the re-routing
+        :type socket: :class:`~nodeeditor.node_socket.Socket`
+        """
+        self.print("startRerouting", socket)
+        self.is_rerouting = True
+        self.start_socket = socket
+
+        self.print("numEdges:", len(self.getAffectedEdges()))
+        self.setAffectedEdgesVisible(visibility=False)
+
+        start_position = self.start_socket.node.getSocketScenePosition(
+            self.start_socket)
+
+        for edge in self.getAffectedEdges():
+            other_socket = edge.getOtherSocket(self.start_socket)
+
+            new_edge = self.getEdgeClass()(self.start_socket.node.scene,
+                                           edge_type=edge.edge_type)
+            new_edge.start_socket = other_socket
+            new_edge.grEdge.setSource(
+                *other_socket.node.getSocketScenePosition(other_socket))
+            new_edge.grEdge.setDestination(*start_position)
+            new_edge.grEdge.update()
+            self.rerouting_edges.append(new_edge)
+
+    def stopRerouting(self, target: 'Socket' = None) -> None:
+        """
+        Method for stopping the re-routing
+
+        :param target: Target where we ended the rerouting (usually released mouse button). Provide ``Socket`` or ``None`` to cancel
+        :type target: :class:`~nodeeditor.node_socket.Socket` or ``None``
+        """
+        self.print("stopRerouting on:", target,
+                   "no change" if target == self.start_socket else "")
+
+        if self.start_socket is None:
+            return
+
+        # reset start socket highlight
+        self.start_socket.grSocket.isHighlighted = False
+
+        # collect all affected (node, edge) tuples in the meantime.. if necessary
+        affected_nodes = []
+
+        if target is None or target == self.start_socket:
+            # canceling -> no change
+            self.setAffectedEdgesVisible(visibility=True)
+
+        else:
+            # validate edges before doing anything else
+            valid_edges, invalid_edges = self.getAffectedEdges(), []
+            for edge in self.getAffectedEdges():
+                start_sock = edge.getOtherSocket(self.start_socket)
+                if not edge.validateEdge(start_sock, target):
+                    # not valid edge
+                    self.print("This edge rerouting is not valid!", edge)
+                    invalid_edges.append(edge)
+
+            # remove the invalidated edges from the list
+            for invalid_edge in invalid_edges:
+                valid_edges.remove(invalid_edge)
+
+            # reconnect to new socket
+            self.print("should reconnect from:",
+                       self.start_socket, "-->", target)
+
+            self.setAffectedEdgesVisible(visibility=True)
+
+            for edge in valid_edges:
+                for node in [edge.start_socket.node, edge.end_socket.node]:
+                    if node not in affected_nodes:
+                        affected_nodes.append((node, edge))
+
+                if target.is_input and not target.is_multi_edges:
+                    # single-edged input: the new edge replaces the old one.
+                    # Multi-edged inputs keep every other edge, and each moved
+                    # edge lands at the read position it had on the old socket.
+                    target.removeAllEdges(silent=True)
+
+                if edge.end_socket == self.start_socket:
+                    edge.end_socket = target
+                else:
+                    edge.start_socket = target
+
+                edge.updatePositions()
+
+        # hide rerouting edges
+        self.clearReroutingEdges()
+
+        # Send notifications for all affected nodes
+        for affected_node, edge in affected_nodes:
+            affected_node.onEdgeConnectionChanged(edge)
+            if edge.start_socket in affected_node.inputs:
+                affected_node.onInputChanged(edge.start_socket)
+            if edge.end_socket in affected_node.inputs:
+                affected_node.onInputChanged(edge.end_socket)
+
+        # store history stamp only if we have a valid start socket
+        if self.start_socket and self.start_socket.node:
+            self.start_socket.node.scene.history.storeHistory(
+                "Rerouted edges", setModified=True)
+
+        # reset variables of this rerouting state
+        self.resetRerouting()

nodeeditor/node_edge_snapping.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Edge Snapping functions which are used in :class:`~nodeeditor.node_graphics_view.QDMGraphicsView` class.
+"""
+
+
+from qtpy.QtCore import QPointF, QRectF
+from qtpy.QtGui import QMouseEvent
+
+from nodeeditor.node_graphics_socket import QDMGraphicsSocket
+
+from typing import TYPE_CHECKING, List, Optional, Tuple, Any
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_edge import Edge
+    from nodeeditor.node_socket import Socket
+
+
+class EdgeSnapping():
+    """Class handling the snapping of a dragged edge to a nearby socket"""
+
+    def __init__(self, grView: 'QDMGraphicsView', snapping_radius: float = 24) -> None:
+        """
+        :param grView: reference to the :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+        :type grView: :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+        :param snapping_radius: radius in scene units within which sockets are considered for snapping
+        :type snapping_radius: ``float``
+
+        :Instance Attributes:
+
+        - **grView** - reference to the :class:`~nodeeditor.node_graphics_view.QDMGraphicsView`
+        - **grScene** - reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
+        - **edge_snapping_radius** - radius in scene units within which sockets are considered for snapping
+        """
+        self.grView = grView
+        self.grScene = self.grView.grScene
+        self.edge_snapping_radius = snapping_radius
+
+    def getSnappedSocketItem(self, event: 'QMouseEvent') -> Optional['QDMGraphicsSocket']:
+        """Returns :class:`~nodeeditor.node_graphics_socket.QDMGraphicsSocket` which we should snap to"""
+        scenepos = self.grView.mapToScene(event.pos())
+        grSocket, pos = self.getSnappedToSocketPosition(scenepos)
+
+        if grSocket is None:
+            return None
+
+        return grSocket
+
+    def getSnappedToSocketPosition(self, scenepos: QPointF) -> Tuple[Optional['QDMGraphicsSocket'], QPointF]:
+        """
+        Returns grSocket and Scene position to nearest Socket or original position if no nearby Socket found
+
+        :param scenepos: From which point should I snap?
+        :type scenepos: ``QPointF``
+        :return: grSocket and Scene postion to nearest socket
+        """
+        scanrect = QRectF(
+            scenepos.x() - self.edge_snapping_radius,
+            scenepos.y() - self.edge_snapping_radius,
+            self.edge_snapping_radius * 2,
+            self.edge_snapping_radius * 2
+        )
+        items = self.grScene.items(scanrect)
+        socket_items = list(
+            filter(lambda x: isinstance(x, QDMGraphicsSocket), items))
+
+        if not socket_items:
+            return None, scenepos
+
+        selected_item = socket_items[0]
+        if len(socket_items) > 1:
+            # calculate the nearest socket
+            nearest = float('inf')
+            for grsock in socket_items:
+                if not isinstance(grsock, QDMGraphicsSocket) or not grsock.socket or not grsock.socket.node:
+                    continue
+
+                grsock_scenepos = grsock.socket.node.getSocketScenePosition(
+                    grsock.socket)
+                qpdist = QPointF(*grsock_scenepos) - scenepos
+                dist = qpdist.x() * qpdist.x() + qpdist.y() * qpdist.y()
+                if dist < nearest:
+                    nearest, selected_item = dist, grsock
+
+        if not isinstance(selected_item, QDMGraphicsSocket) or not selected_item.socket or not selected_item.socket.node:
+            return None, scenepos
+
+        selected_item.isHighlighted = True
+
+        calcpos = selected_item.socket.node.getSocketScenePosition(
+            selected_item.socket)
+
+        return selected_item, QPointF(*calcpos)

nodeeditor/node_edge_validators.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Edge Validator functions which can be registered as callbacks to
+:class:`~nodeeditor.node_edge.Edge` class.
+
+Example of registering Edge Validator callbacks:
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can register validation callbacks once for example on the bottom of node_edge.py file or on the
+application start with calling this:
+
+.. code-block:: python
+
+    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_type)
+
+
+"""
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_socket import Socket
+
+
+DEBUG = False
+
+
+def print_error(*args) -> None:
+    """Helper method which prints to console if `DEBUG` is set to `True`"""
+    if DEBUG:
+        print("Edge Validation Error:", *args)
+
+
+def edge_validator_debug(input: 'Socket', output: 'Socket') -> bool:
+    """This will consider edge always valid, however writes bunch of debug stuff into console"""
+    print("VALIDATING:")
+    print(input, "input" if input.is_input else "output",  "of node", input.node)
+    for s in input.node.inputs+input.node.outputs:
+        print("\t", s, "input" if s.is_input else "output")
+    print(output, "input" if input.is_input else "output", "of node", output.node)
+    for s in output.node.inputs+output.node.outputs:
+        print("\t", s, "input" if s.is_input else "output")
+
+    return True
+
+
+def edge_cannot_connect_two_outputs_or_two_inputs(input: 'Socket', output: 'Socket') -> bool:
+    """Edge is invalid if it connects 2 output sockets or 2 input sockets"""
+    if input.is_output and output.is_output:
+        print_error("Connecting 2 outputs")
+        return False
+
+    if input.is_input and output.is_input:
+        print_error("Connecting 2 inputs")
+        return False
+
+    return True
+
+
+def edge_cannot_connect_input_and_output_of_same_node(input: 'Socket', output: 'Socket') -> bool:
+    """Edge is invalid if it connects the same node"""
+    if input.node == output.node:
+        print_error("Connecting the same node")
+        return False
+
+    return True
+
+
+def edge_cannot_connect_input_and_output_of_different_type(input: 'Socket', output: 'Socket') -> bool:
+    """Edge is invalid if it connects sockets with different colors"""
+
+    if input.socket_type != output.socket_type:
+        print_error("Connecting sockets with different colors")
+        return False
+
+    return True