nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_graphics_edge.py

@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing the Graphics representation of an Edge
+"""
+from qtpy.QtWidgets import QGraphicsPathItem, QWidget, QGraphicsItem, QGraphicsSceneHoverEvent, QGraphicsSimpleTextItem
+from qtpy.QtGui import QColor, QPen, QBrush, QPainterPath, QFont
+from qtpy.QtCore import Qt, QRectF, QPointF
+
+from nodeeditor.node_graphics_edge_path import GraphicsEdgePathBezier, GraphicsEdgePathDirect, GraphicsEdgePathSquare, GraphicsEdgePathImprovedSharp, GraphicsEdgePathImprovedBezier
+from nodeeditor.node_colors_config import get_color_scheme
+
+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 QDMGraphicsEdge(QGraphicsPathItem):
+    """Base class for Graphics Edge"""
+
+    def __init__(self, edge: 'Edge', parent: QGraphicsPathItem = None) -> None:
+        """
+        :param edge: reference to :class:`~nodeeditor.node_edge.Edge`
+        :type edge: :class:`~nodeeditor.node_edge.Edge`
+        :param parent: parent widget
+        :type parent: ``QWidget``
+
+        :Instance attributes:
+
+            - **edge** - reference to :class:`~nodeeditor.node_edge.Edge`
+            - **posSource** - ``[x, y]`` source position in the `Scene`
+            - **posDestination** - ``[x, y]`` destination position in the `Scene`
+        """
+        super().__init__(parent)
+
+        self.edge = edge
+
+        # create instance of our path class
+        self.pathCalculator = self.determineEdgePathClass()(self)
+
+        # init our flags
+        self._last_selected_state = False
+        self.hovered = False
+
+        # init our variables
+        self.posSource: List[float] = [0, 0]
+        self.posDestination: List[float] = [200, 100]
+
+        # code-settable, user-read-only label drawn on top of the edge path.
+        # Never editable/selectable/movable: users cannot change it, code can
+        # via QDMGraphicsEdge.setLabel() / Edge.label.
+        self._label_offset = QPointF(0, -18)
+        self.labelItem = QGraphicsSimpleTextItem(self)
+        self.labelItem.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)
+        self.labelItem.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+        self.labelItem.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsFocusable, False)
+        self.labelItem.setAcceptedMouseButtons(Qt.MouseButton.NoButton)
+        self.labelItem.setAcceptHoverEvents(False)
+        # QGraphicsSimpleTextItem has no text-interaction/editing API at all,
+        # which is exactly what we want: code-only, never user-editable.
+        self.labelItem.setBrush(QBrush(QColor("#ffffff")))
+        self.labelItem.setZValue(1)
+        self.labelItem.setVisible(False)
+
+        self.initAssets()
+        self.initUI()
+
+    def initUI(self) -> None:
+        """Set up this ``QGraphicsPathItem``"""
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
+        self.setAcceptHoverEvents(True)
+        self.setZValue(-1)
+
+    def initAssets(self) -> None:
+        """Initialize ``QObjects`` like ``QColor``, ``QPen`` and ``QBrush``"""
+        # Get colors from global color scheme
+        scheme = get_color_scheme()
+        self._color = self._default_color = scheme.edges.default
+        self._color_selected = scheme.edges.selected
+        self._color_hovered = scheme.edges.hovered
+        self._pen = QPen(self._color)
+        self._pen_selected = QPen(self._color_selected)
+        self._pen_dragging = QPen(scheme.edges.dragging)
+        self._pen_hovered = QPen(self._color_hovered)
+        self._pen_dragging.setStyle(Qt.PenStyle.DashLine)
+        self._pen.setWidthF(3.0)
+        self._pen_selected.setWidthF(3.0)
+        self._pen_dragging.setWidthF(3.0)
+        self._pen_hovered.setWidthF(5.0)
+
+    def createEdgePathCalculator(self):
+        """Create instance of :class:`~nodeeditor.node_graphics_edge_path.GraphicsEdgePathBase`"""
+        self.pathCalculator = self.determineEdgePathClass()(self)
+        return self.pathCalculator
+
+    def determineEdgePathClass(self):
+        """Decide which GraphicsEdgePath class should be used to calculate path according to edge.edge_type value"""
+        from nodeeditor.node_edge import EDGE_TYPE_BEZIER, EDGE_TYPE_DIRECT, EDGE_TYPE_SQUARE, EDGE_TYPE_IMPROVED_SHARP, EDGE_TYPE_IMPROVED_BEZIER
+        if self.edge.edge_type == EDGE_TYPE_BEZIER:
+            return GraphicsEdgePathBezier
+        if self.edge.edge_type == EDGE_TYPE_DIRECT:
+            return GraphicsEdgePathDirect
+        if self.edge.edge_type == EDGE_TYPE_SQUARE:
+            return GraphicsEdgePathSquare
+        if self.edge.edge_type == EDGE_TYPE_IMPROVED_SHARP:
+            return GraphicsEdgePathImprovedSharp
+        if self.edge.edge_type == EDGE_TYPE_IMPROVED_BEZIER:
+            return GraphicsEdgePathImprovedBezier
+
+        else:
+            return GraphicsEdgePathImprovedBezier
+
+    def makeUnselectable(self) -> None:
+        """Used for drag edge to disable click detection over this graphics item"""
+        self.setFlag(QGraphicsItem.ItemIsSelectable, False)
+        self.setAcceptHoverEvents(False)
+
+    def changeColor(self, color) -> None:
+        """Change color of the edge from string hex value '#00ff00'"""
+        # print("^Called change color to:", color.red(), color.green(), color.blue(), "on edge:", self.edge)
+        self._color = QColor(color) if type(color) == str else color
+        self._pen = QPen(self._color)
+        self._pen.setWidthF(3.0)
+
+    def setColorFromSockets(self) -> bool:
+        """Change color according to connected sockets. Returns ``True`` if color can be determined"""
+        socket_type_start = self.edge.start_socket.socket_type
+        socket_type_end = self.edge.end_socket.socket_type
+        if socket_type_start != socket_type_end:
+            return False
+        self.changeColor(
+            self.edge.start_socket.grSocket.getSocketColor(socket_type_start))
+
+        return True
+
+    def label(self) -> str:
+        """Return the current code-set edge label (``""`` when unset)."""
+        return self.labelItem.text()
+
+    def setLabel(self, text: str) -> None:
+        """Set the text drawn on top of the edge.
+
+        Code-only API: the label item is not selectable, movable, focusable
+        and accepts no mouse buttons, so users cannot edit it directly.
+
+        :param text: label text, ``""``/``None`` hides the label
+        """
+        self.labelItem.setText(text or "")
+        self.labelItem.setVisible(bool(text))
+        self.updateLabelPosition()
+        self.update()
+
+    def setLabelColor(self, color) -> None:
+        """Set label text color from ``QColor`` or hex string."""
+        self.labelItem.setBrush(QBrush(QColor(color) if isinstance(color, str) else color))
+        self.update()
+
+    def setLabelFont(self, font: QFont) -> None:
+        """Set label font, then recenter it on the edge path."""
+        self.labelItem.setFont(font)
+        self.updateLabelPosition()
+        self.update()
+
+    def setLabelOffset(self, x: float, y: float) -> None:
+        """Offset (in px) applied to the centered label position."""
+        self._label_offset = QPointF(x, y)
+        self.updateLabelPosition()
+        self.update()
+
+    def updateLabelPosition(self) -> None:
+        """Center the label on top of the current edge path."""
+        if not self.labelItem.isVisible():
+            return
+        try:
+            path = self.path()
+            mid = path.pointAtPercent(0.5) if path.length() > 0 else QPointF(
+                (self.posSource[0] + self.posDestination[0]) / 2.0,
+                (self.posSource[1] + self.posDestination[1]) / 2.0,
+            )
+        except Exception:
+            mid = QPointF(
+                (self.posSource[0] + self.posDestination[0]) / 2.0,
+                (self.posSource[1] + self.posDestination[1]) / 2.0,
+            )
+        rect = self.labelItem.boundingRect()
+        self.labelItem.setPos(mid + self._label_offset - QPointF(rect.width() / 2.0, rect.height() / 2.0))
+
+    def onSelected(self) -> None:
+        """Our event handling when the edge was selected"""
+        self.edge.scene.grScene.itemSelected.emit()
+
+    def doSelect(self, new_state: bool = True) -> None:
+        """Safe version of selecting the `Graphics Node`. Takes care about the selection state flag used internally
+
+        :param new_state: ``True`` to select, ``False`` to deselect
+        :type new_state: ``bool``
+        """
+        self.setSelected(new_state)
+        self._last_selected_state = new_state
+        if new_state:
+            self.onSelected()
+
+    def mouseReleaseEvent(self, event) -> None:
+        """Overridden Qt's method to handle selecting and deselecting this `Graphics Edge`"""
+        super().mouseReleaseEvent(event)
+        if self._last_selected_state != self.isSelected():
+            self.edge.scene.resetLastSelectedStates()
+            self._last_selected_state = self.isSelected()
+            self.onSelected()
+
+    def hoverEnterEvent(self, event: Optional['QGraphicsSceneHoverEvent']) -> None:
+        """Handle hover effect
+
+        :param event: The hover event
+        :type event: Optional[QGraphicsSceneHoverEvent]
+        """
+        self.hovered = True
+        self.update()
+
+    def hoverLeaveEvent(self, event: Optional['QGraphicsSceneHoverEvent']) -> None:
+        """Handle hover effect
+
+        :param event: The hover event
+        :type event: Optional[QGraphicsSceneHoverEvent]
+        """
+        self.hovered = False
+        self.update()
+
+    def setSource(self, x: float, y: float) -> None:
+        """ Set source point
+
+        :param x: x position
+        :type x: ``float``
+        :param y: y position
+        :type y: ``float``
+        """
+        self.setPositions((x, y), self.posDestination)
+
+    def setDestination(self, x: float, y: float) -> None:
+        """ Set destination point
+
+        :param x: x position
+        :type x: ``float``
+        :param y: y position
+        :type y: ``float``
+        """
+        self.setPositions(self.posSource, (x, y))
+
+    def setPositions(self, source, destination) -> None:
+        """Set both ends and adopt the resulting path once.
+
+        A node move changes both ends. Adopting inside each setter would run the
+        route calculation twice per edge per move, and that calculation is the
+        expensive part of moving a node.
+
+        :param source: new source point
+        :param destination: new destination point
+        """
+        self.posSource = [source[0], source[1]]
+        self.posDestination = [destination[0], destination[1]]
+        self.adoptGeometry()
+
+    def adoptGeometry(self) -> None:
+        """Recompute the drawn path right away, so Qt invalidates the true rect.
+
+        The setters run before the caller repaints, and a path picked up only
+        while painting invalidates the *previous* geometry (see
+        :meth:`refreshPath`).
+        """
+        if getattr(self, "pathCalculator", None) is None:
+            return
+        if getattr(self, "labelItem", None) is None:
+            return
+        self.refreshPath()
+
+    def strokeMargin(self) -> float:
+        """Half the widest pen this edge can paint with, plus an antialias pixel.
+
+        ``paint`` strokes the path, and a stroke reaches half its width past the
+        path on both sides. A ``boundingRect`` of the bare path is therefore
+        smaller than what the item draws, and every repaint leaves the outer band
+        of the *previous* stroke on screen. That is not a one-pixel cosmetic
+        miss: while a node is dragged, each frame adds a band along the path's
+        old position, and dozens of frames accumulate into the smeared arcs and
+        loops the canvas was showing.
+        """
+        widest = 0.0
+        for name in ("_pen", "_pen_selected", "_pen_dragging", "_pen_hovered"):
+            pen = getattr(self, name, None)
+            if pen is not None:
+                widest = max(widest, pen.widthF())
+        return widest / 2.0 + 1.0
+
+    def boundingRect(self) -> QRectF:
+        """Defining Qt' bounding rectangle (path united with label rect)."""
+        margin = self.strokeMargin()
+        base = self.shape().boundingRect().adjusted(-margin, -margin, margin, margin)
+        try:
+            if self.labelItem.isVisible():
+                label_rect = self.labelItem.boundingRect().translated(self.labelItem.pos())
+                return base.united(label_rect)
+        except Exception:
+            pass
+        return base
+
+    def refreshPath(self) -> None:
+        """Adopt the current path and label position now.
+
+        Qt invalidates an item by its *declared* geometry, so an item that only
+        adopts a new path while painting invalidates the previous one and draws
+        the new one: whatever the old path covered outside both rectangles stays
+        on screen. Callers that know the edge moved (``updatePositions``) call
+        this first, which makes ``setPath`` repaint the union of old and new.
+        """
+        self.setPath(self.calcPath())
+        self.updateLabelPosition()
+
+    def shape(self) -> QPainterPath:
+        """Returns ``QPainterPath`` representation of this `Edge`
+
+        :return: path representation
+        :rtype: ``QPainterPath``
+        """
+        return self.calcPath()
+
+    def paint(self, painter, QStyleOptionGraphicsItem, widget=None) -> None:
+        """Qt's overridden method to paint this Graphics Edge. Path calculated
+            in :func:`~nodeeditor.node_graphics_edge.QDMGraphicsEdge.calcPath` method"""
+        # A no-op once refreshPath() has run for this geometry (Qt's setPath
+        # returns early on an unchanged path); kept for consumers that only ever
+        # paint.
+        self.setPath(self.calcPath())
+        self.updateLabelPosition()
+
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+
+        if self.hovered and self.edge.end_socket is not None:
+            painter.setPen(self._pen_hovered)
+            painter.drawPath(self.path())
+
+        if self.edge.end_socket is None:
+            painter.setPen(self._pen_dragging)
+        else:
+            painter.setPen(self._pen if not self.isSelected()
+                           else self._pen_selected)
+
+        painter.drawPath(self.path())
+
+    def intersectsWith(self, p1: QPointF, p2: QPointF) -> bool:
+        """Does this Graphics Edge intersect with the line between point A and point B ?
+
+        :param p1: point A
+        :type p1: ``QPointF``
+        :param p2: point B
+        :type p2: ``QPointF``
+        :return: ``True`` if this `Graphics Edge` intersects
+        :rtype: ``bool``
+        """
+        cutpath = QPainterPath(p1)
+        cutpath.lineTo(p2)
+        path = self.calcPath()
+        return cutpath.intersects(path)
+
+    def calcPath(self) -> QPainterPath:
+        """Will handle drawing QPainterPath from Point A to B. Internally there exist self.pathCalculator which
+        is an instance of derived :class:`~nodeeditor.node_graphics_edge_path.GraphicsEdgePathBase` class
+        containing the actual `calcPath()` function - computing how the edge should look like.
+
+        :returns: ``QPainterPath`` of the edge connecting `source` and `destination`
+        :rtype: ``QPainterPath``
+        """
+        return self.pathCalculator.calcPath()

nodeeditor/node_graphics_edge_path.py

@@ -0,0 +1,226 @@
+"""
+A module containing the classes that calculate the graphics path drawn for an Edge.
+
+Every class derives from :class:`GraphicsEdgePathBase` and implements
+:meth:`GraphicsEdgePathBase.calcPath`, which turns the positions of the edge's
+two sockets into the :class:`~qtpy.QtGui.QPainterPath` that gets painted.
+"""
+import math
+from qtpy.QtCore import QPointF
+from qtpy.QtGui import QPainterPath
+
+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
+    from nodeeditor.node_graphics_edge import QDMGraphicsEdge
+
+
+EDGE_CP_ROUNDNESS = 100     #: Bezier control point distance on the line
+#: factor for square edge to change the midpoint between start and end socket
+WEIGHT_SOURCE = 0.2
+
+#: Scale EDGE_CURVATURE with distance of the edge endpoints
+EDGE_IBCP_ROUNDNESS = 75
+NODE_DISTANCE = 12
+EDGE_CURVATURE = 2
+
+
+class GraphicsEdgePathBase:
+    """Base Class for calculating the graphics path to draw for an graphics Edge"""
+
+    def __init__(self, owner: 'QDMGraphicsEdge') -> None:
+        """
+        :param owner: the :class:`~nodeeditor.node_graphics_edge.QDMGraphicsEdge` this path belongs to
+        :type owner: :class:`~nodeeditor.node_graphics_edge.QDMGraphicsEdge`
+        """
+        # keep the reference to owner GraphicsEdge class
+        self.owner = owner
+
+    def calcPath(self):
+        """Calculate the Direct line connection
+
+        :returns: ``QPainterPath`` of the graphics path to draw
+        :rtype: ``QPainterPath`` or ``None``
+        """
+        return None
+
+
+class GraphicsEdgePathDirect(GraphicsEdgePathBase):
+    """Direct line connection Graphics Edge"""
+
+    def calcPath(self) -> QPainterPath:
+        """Calculate the Direct line connection
+
+        :returns: ``QPainterPath`` of the direct line
+        :rtype: ``QPainterPath``
+        """
+        path = QPainterPath(
+            QPointF(self.owner.posSource[0], self.owner.posSource[1]))
+        path.lineTo(self.owner.posDestination[0], self.owner.posDestination[1])
+        return path
+
+
+class GraphicsEdgePathBezier(GraphicsEdgePathBase):
+    """Cubic line connection Graphics Edge"""
+
+    def calcPath(self) -> QPainterPath:
+        """Calculate the cubic Bezier line connection with 2 control points
+
+        :returns: ``QPainterPath`` of the cubic Bezier line
+        :rtype: ``QPainterPath``
+        """
+        s = self.owner.posSource
+        d = self.owner.posDestination
+        dist = (d[0] - s[0]) * 0.5
+
+        cpx_s: float = +dist
+        cpx_d: float = -dist
+        cpy_s: float = 0.0
+        cpy_d: float = 0.0
+
+        if self.owner.edge.start_socket is not None:
+            ssin = self.owner.edge.start_socket.is_input
+            ssout = self.owner.edge.start_socket.is_output
+
+            if (s[0] > d[0] and ssout) or (s[0] < d[0] and ssin):
+                cpx_d *= -1
+                cpx_s *= -1
+
+                cpy_d = (
+                    (s[1] - d[1]) / math.fabs(
+                        (s[1] - d[1]) if (s[1] - d[1]) != 0 else 0.00001
+                    )
+                ) * EDGE_CP_ROUNDNESS
+                cpy_s = (
+                    (d[1] - s[1]) / math.fabs(
+                        (d[1] - s[1]) if (d[1] - s[1]) != 0 else 0.00001
+                    )
+                ) * EDGE_CP_ROUNDNESS
+
+        path = QPainterPath(
+            QPointF(self.owner.posSource[0], self.owner.posSource[1]))
+        path.cubicTo(s[0] + cpx_s, s[1] + cpy_s, d[0] + cpx_d, d[1] + cpy_d,
+                     self.owner.posDestination[0], self.owner.posDestination[1])
+
+        return path
+
+
+class GraphicsEdgePathSquare(GraphicsEdgePathBase):
+    """Square line connection Graphics Edge"""
+
+    def __init__(self, *args, handle_weight: float=0.5, **kwargs) -> None:
+        """
+        :param args: positional arguments passed on to the base class
+        :param handle_weight: where the vertical part of the square sits, ``0.5`` being the middle
+        :param kwargs: keyword arguments passed on to the base class
+        """
+        super().__init__(*args, **kwargs)
+        self.rand = None
+        self.handle_weight = handle_weight
+
+    def calcPath(self):
+        """Calculate the square edge line connection
+
+        :returns: ``QPainterPath`` of the edge square line
+        :rtype: ``QPainterPath``
+        """
+
+        s = self.owner.posSource
+        d = self.owner.posDestination
+
+        mid_x = s[0] + ((d[0] - s[0]) * self.handle_weight)
+
+        path = QPainterPath(QPointF(s[0], s[1]))
+        path.lineTo(mid_x, s[1])
+        path.lineTo(mid_x, d[1])
+        path.lineTo(d[0], d[1])
+
+        return path
+
+
+class GraphicsEdgePathImprovedSharp(GraphicsEdgePathBase):
+    """Better Cubic line connection Graphics Edge"""
+
+    def calcPath(self) -> QPainterPath:
+        """Calculate the Direct line connection
+
+        :returns: ``QPainterPath`` of the painting line
+        :rtype: ``QPainterPath``
+        """
+        sx, sy = self.owner.posSource
+        dx, dy = self.owner.posDestination
+        distx, disty = dx-sx, dy-sy
+        dist = math.sqrt(distx*distx + disty*disty)
+
+        # is start / end socket on left side?
+        sleft = self.owner.edge.start_socket.position <= 3
+
+        # if the drag edge started from input socket, we should connect to output socket...
+        eleft = self.owner.edge.start_socket.position > 3
+
+        if self.owner.edge.end_socket is not None:
+            eleft = self.owner.edge.end_socket.position <= 3
+
+        node_sdist = (-NODE_DISTANCE) if sleft else NODE_DISTANCE
+        node_edist = (-NODE_DISTANCE) if eleft else NODE_DISTANCE
+
+        path = QPainterPath(QPointF(sx, sy))
+
+        if abs(dist) > NODE_DISTANCE:
+            path.lineTo(sx + node_sdist, sy)
+            path.lineTo(dx + node_edist, dy)
+
+        path.lineTo(dx, dy)
+
+        return path
+
+
+class GraphicsEdgePathImprovedBezier(GraphicsEdgePathBase):
+    """Better Cubic line connection Graphics Edge"""
+
+    def calcPath(self) -> QPainterPath:
+        """Calculate the Direct line connection
+
+        :returns: ``QPainterPath`` of the painting line
+        :rtype: ``QPainterPath``
+        """
+        sx, sy = self.owner.posSource
+        dx, dy = self.owner.posDestination
+        distx, disty = dx-sx, dy-sy
+        dist = math.sqrt(distx*distx + disty*disty)
+
+        # is start / end socket on left side?
+        sleft = self.owner.edge.start_socket.position <= 3
+
+        # if the drag edge started from input socket, we should connect to output socket...
+        eleft = self.owner.edge.start_socket.position > 3
+
+        if self.owner.edge.end_socket is not None:
+            eleft = self.owner.edge.end_socket.position <= 3
+
+        path = QPainterPath(QPointF(sx, sy))
+
+        if abs(dist) > NODE_DISTANCE:
+            curvature = max(EDGE_CURVATURE, (EDGE_CURVATURE *
+                            abs(dist)) / EDGE_IBCP_ROUNDNESS)
+
+            node_sdist = (-NODE_DISTANCE) if sleft else NODE_DISTANCE
+            node_edist = (-NODE_DISTANCE) if eleft else NODE_DISTANCE
+
+            path.lineTo(sx + node_sdist, sy)
+
+            path.cubicTo(
+                QPointF(sx + node_sdist * curvature, sy),
+                QPointF(dx + node_edist * curvature, dy),
+                QPointF(dx + node_edist, dy)
+            )
+
+            path.lineTo(dx + node_edist, dy)
+
+        path.lineTo(dx, dy)
+
+        return path