remove pipe arro item & cleanup

Author: jchanvfx

NodeGraphQt/widgets/pipe.py

@@ -16,23 +16,6 @@
 }
 
 
-class PipeArrow(QtWidgets.QGraphicsPolygonItem):
-    """
-    Base pipe arrow item for indicating pipe direction.
-    """
-
-    def __init__(self, parent=None, size=5.0):
-        super(PipeArrow, self).__init__(parent)
-        self.set_size(size)
-
-    def set_size(self, size=5.0):
-        triangle = QtGui.QPolygonF()
-        triangle.append(QtCore.QPointF(-size, size))
-        triangle.append(QtCore.QPointF(0.0, -size*2))
-        triangle.append(QtCore.QPointF(size, size))
-        self.setPolygon(triangle)
-
-
 class Pipe(QtWidgets.QGraphicsPathItem):
     """
     Base Pipe item used for drawing node connections.
@@ -48,8 +31,11 @@ def __init__(self, input_port=None, output_port=None):
         self._highlight = False
         self._input_port = input_port
         self._output_port = output_port
-        self.__arrow = PipeArrow(self)
-        self.reset()
+        size = 5.0
+        self._arrow = QtGui.QPolygonF()
+        self._arrow.append(QtCore.QPointF(-size, size))
+        self._arrow.append(QtCore.QPointF(0.0, -size * 2))
+        self._arrow.append(QtCore.QPointF(size, size))
 
     def __str__(self):
         in_name = self._input_port.name if self._input_port else ''
@@ -88,6 +74,10 @@ def paint(self, painter, option, widget):
         pen_width = PIPE_WIDTH
         if self._active:
             color = QtGui.QColor(*PIPE_ACTIVE_COLOR)
+            if pen_style == QtCore.Qt.DashDotDotLine:
+                pen_width += 1
+            else:
+                pen_width += 0.35
         elif self._highlight:
             color = QtGui.QColor(*PIPE_HIGHLIGHT_COLOR)
             pen_style = PIPE_STYLES.get(PIPE_STYLE_DEFAULT)
@@ -106,6 +96,28 @@ def paint(self, painter, option, widget):
         painter.setRenderHint(painter.Antialiasing, True)
         painter.drawPath(self.path())
 
+        # draw arrow
+        if self.input_port and self.output_port:
+            transform = QtGui.QTransform()
+            transform.translate(self.path().pointAtPercent(0.5).x(),
+                                self.path().pointAtPercent(0.5).y())
+            loc_pt = self.path().pointAtPercent(0.49)
+            tgt_pt = self.path().pointAtPercent(0.51)
+            radians = math.atan2(tgt_pt.y() - loc_pt.y(),
+                                 tgt_pt.x() - loc_pt.x())
+            degrees = math.degrees(radians) - 90
+            transform.rotate(degrees)
+
+            color.setAlpha(255)
+            if self._highlight:
+                painter.setBrush(QtGui.QBrush(color.lighter(150)))
+            elif self._active or self.disabled():
+                painter.setBrush(QtGui.QBrush(color.darker(200)))
+            else:
+                painter.setBrush(QtGui.QBrush(color))
+            painter.setPen(QtGui.QPen(color, 0.6))
+            painter.drawPolygon(transform.map(self._arrow))
+
         painter.restore()  # QPaintDevice: Cannot destroy paint device that is being painted
 
     def draw_path(self, start_port, end_port, cursor_pos=None):
@@ -162,19 +174,6 @@ def draw_path(self, start_port, end_port, cursor_pos=None):
         path.cubicTo(ctr_point1, ctr_point2, pos2)
         self.setPath(path)
 
-        # draw arrow
-        if start_port.port_type == IN_PORT:
-            loc_pt = self.path().pointAtPercent(0.49)
-            tgt_pt = self.path().pointAtPercent(0.51)
-        else:
-            loc_pt = self.path().pointAtPercent(0.51)
-            tgt_pt = self.path().pointAtPercent(0.49)
-
-        radians = math.atan2(tgt_pt.y() - loc_pt.y(), tgt_pt.x() - loc_pt.x())
-        degrees = math.degrees(radians) - 90
-        self.__arrow.setPos(self.path().pointAtPercent(0.5))
-        self.__arrow.setRotation(degrees)
-
     def calc_distance(self, p1, p2):
         x = math.pow((p2.x() - p1.x()), 2)
         y = math.pow((p2.y() - p1.y()), 2)
@@ -199,10 +198,8 @@ def viewer_pipe_layout(self):
     def activate(self):
         self._active = True
         color = QtGui.QColor(*PIPE_ACTIVE_COLOR)
-        pen = QtGui.QPen(color, 2, PIPE_STYLES.get(PIPE_STYLE_DEFAULT))
+        pen = QtGui.QPen(color, 2.5, PIPE_STYLES.get(PIPE_STYLE_DEFAULT))
         self.setPen(pen)
-        self.__arrow.setBrush(QtGui.QBrush(color.darker(200)))
-        self.__arrow.setPen(QtGui.QPen(color, 0.8))
 
     def active(self):
         return self._active
@@ -212,8 +209,6 @@ def highlight(self):
         color = QtGui.QColor(*PIPE_HIGHLIGHT_COLOR)
         pen = QtGui.QPen(color, 2, PIPE_STYLES.get(PIPE_STYLE_DEFAULT))
         self.setPen(pen)
-        self.__arrow.setBrush(QtGui.QBrush(color.darker(200)))
-        self.__arrow.setPen(QtGui.QPen(color, 0.8))
 
     def highlighted(self):
         return self._highlight
@@ -224,8 +219,6 @@ def reset(self):
         color = QtGui.QColor(*self.color)
         pen = QtGui.QPen(color, 2, PIPE_STYLES.get(self.style))
         self.setPen(pen)
-        self.__arrow.setBrush(QtGui.QBrush(color.darker(130)))
-        self.__arrow.setPen(QtGui.QPen(color, 0.6))
 
     def set_connections(self, port1, port2):
         ports = {

NodeGraphQt/widgets/viewer.py

@@ -299,63 +299,47 @@ def sceneMousePressEvent(self, event):
             event (QtWidgets.QGraphicsScenePressEvent):
                 The event handler from the QtWidgets.QGraphicsScene
         """
-        alt_modifier = event.modifiers() == QtCore.Qt.AltModifier
-
-        # (NOTE) The `QtWidgets.QGraphicsSceneMouseEvent` class doesn't have
-        # `setModifiers` in PyQt, and can't find a workaround for it.
-        # So the only option to work with PyQt for now was to drop the modifier
-        # remapping, but judging from the event passing flow and running a few
-        # tests, it looks like those remapping code didn't have any affect to
-        # the UI function.
-        # Should be safe to comment out the code below.
-        """
-        ctrl_modifier = event.modifiers() == QtCore.Qt.ControlModifier
-        shift_modifier = event.modifiers() == QtCore.Qt.ShiftModifier
-        if shift_modifier:
-            event.setModifiers(QtCore.Qt.ControlModifier)
-        elif ctrl_modifier:
-            event.setModifiers(QtCore.Qt.ShiftModifier)
-        """
+        if event.modifiers() == QtCore.Qt.AltModifier:
+            return
 
-        if not alt_modifier:
-            pos = event.scenePos()
-            port_items = self._items_near(pos, PortItem, 5, 5)
-            if port_items:
-                port = port_items[0]
-                if not port.multi_connection and port.connected_ports:
-                    self._detached_port = port.connected_ports[0]
-                self.start_live_connection(port)
-                if not port.multi_connection:
-                    [p.delete() for p in port.connected_pipes]
-                return
+        pos = event.scenePos()
+        port_items = self._items_near(pos, PortItem, 5, 5)
+        if port_items:
+            port = port_items[0]
+            if not port.multi_connection and port.connected_ports:
+                self._detached_port = port.connected_ports[0]
+            self.start_live_connection(port)
+            if not port.multi_connection:
+                [p.delete() for p in port.connected_pipes]
+            return
 
-            node_items = self._items_near(pos, AbstractNodeItem, 3, 3)
-            if node_items:
-                node = node_items[0]
+        node_items = self._items_near(pos, AbstractNodeItem, 3, 3)
+        if node_items:
+            node = node_items[0]
 
-                # record the node positions at selection time.
-                for n in node_items:
-                    self._node_positions[n] = n.xy_pos
+            # record the node positions at selection time.
+            for n in node_items:
+                self._node_positions[n] = n.xy_pos
 
-                # emit selected node id with LMB.
-                if event.button() == QtCore.Qt.LeftButton:
-                    self.node_selected.emit(node.id)
+            # emit selected node id with LMB.
+            if event.button() == QtCore.Qt.LeftButton:
+                self.node_selected.emit(node.id)
 
-                if not isinstance(node, BackdropNodeItem):
-                    return
+            if not isinstance(node, BackdropNodeItem):
+                return
 
-            pipe_items = self._items_near(pos, Pipe, 3, 3)
-            if pipe_items:
-                if not self.LMB_state:
-                    return
-                pipe = pipe_items[0]
-                attr = {IN_PORT: 'output_port', OUT_PORT: 'input_port'}
-                from_port = pipe.port_from_pos(pos, True)
+        pipe_items = self._items_near(pos, Pipe, 3, 3)
+        if pipe_items:
+            if not self.LMB_state:
+                return
+            pipe = pipe_items[0]
+            attr = {IN_PORT: 'output_port', OUT_PORT: 'input_port'}
+            from_port = pipe.port_from_pos(pos, True)
 
-                self._detached_port = getattr(pipe, attr[from_port.port_type])
-                self.start_live_connection(from_port)
-                self._live_pipe.draw_path(self._start_port, None, pos)
-                pipe.delete()
+            self._detached_port = getattr(pipe, attr[from_port.port_type])
+            self.start_live_connection(from_port)
+            self._live_pipe.draw_path(self._start_port, None, pos)
+            pipe.delete()
 
     def sceneMouseReleaseEvent(self, event):
         """
@@ -366,14 +350,6 @@ def sceneMouseReleaseEvent(self, event):
             event (QtWidgets.QGraphicsSceneMouseEvent):
                 The event handler from the QtWidgets.QGraphicsScene
         """
-
-        # (NOTE) The `QtWidgets.QGraphicsSceneMouseEvent` class doesn't have
-        # `setModifiers` in PyQt, please see the note above.
-        """
-        if event.modifiers() == QtCore.Qt.ShiftModifier:
-            event.setModifiers(QtCore.Qt.ControlModifier)
-        """
-
         if not self._live_pipe:
             return
 
@@ -480,6 +456,8 @@ def establish_connection(self, start_port, end_port):
         self.scene().addItem(pipe)
         pipe.set_connections(start_port, end_port)
         pipe.draw_path(pipe.input_port, pipe.output_port)
+        if start_port.node.selected or end_port.node.selected:
+            pipe.highlight()
 
     def acyclic_check(self, start_port, end_port):
         """