Add vertical layout

Author: ArnoChenFx

NodeGraphQt/base/node.py

@@ -10,10 +10,13 @@
                          NODE_PROP_FILE,
                          NODE_PROP_FLOAT,
                          NODE_PROP_INT,
-                         IN_PORT, OUT_PORT)
+                         IN_PORT, OUT_PORT,
+                         NODE_LAYOUT_VERTICAL,
+                         NODE_LAYOUT_HORIZONTAL,
+                         NODE_LAYOUT_DIRECTION)
 from ..errors import PortRegistrationError
 from ..qgraphics.node_backdrop import BackdropNodeItem
-from ..qgraphics.node_base import NodeItem
+from ..qgraphics.node_base import NodeItem, NodeItemVertical
 from ..widgets.node_widgets import (NodeComboBox,
                                     NodeLineEdit,
                                     NodeFloatEdit,
@@ -514,7 +517,12 @@ def __init__(self):
     NODE_NAME = 'Base Node'
 
     def __init__(self):
-        super(BaseNode, self).__init__(NodeItem())
+        view = None
+        if NODE_LAYOUT_DIRECTION is NODE_LAYOUT_VERTICAL:
+            view = NodeItemVertical()
+        elif NODE_LAYOUT_DIRECTION is NODE_LAYOUT_HORIZONTAL:
+            view = NodeItem()
+        super(BaseNode, self).__init__(view)
         self._inputs = []
         self._outputs = []
         self._has_draw = False

NodeGraphQt/constants.py

@@ -112,11 +112,16 @@
 Z_VAL_PORT = 2
 Z_VAL_NODE_WIDGET = 3
 
-
 # === ITEM CACHE MODE ===
 
 # QGraphicsItem.NoCache
 # QGraphicsItem.DeviceCoordinateCache
 # QGraphicsItem.ItemCoordinateCache
 
-ITEM_CACHE_MODE = QtWidgets.QGraphicsItem.DeviceCoordinateCache
+ITEM_CACHE_MODE = QtWidgets.QGraphicsItem.DeviceCoordinateCache
+
+# === NODE LAYOUT DIRECTION ===
+
+NODE_LAYOUT_VERTICAL = 0
+NODE_LAYOUT_HORIZONTAL = 1
+NODE_LAYOUT_DIRECTION = NODE_LAYOUT_HORIZONTAL

NodeGraphQt/qgraphics/node_base.py

@@ -134,7 +134,7 @@ def __init__(self, name='node', parent=None):
         self._output_items = {}
         self._widgets = {}
         self._proxy_mode = False
-        self._porxy_mode_threshold = 70
+        self._proxy_mode_threshold = 70
 
     def paint(self, painter, option, widget):
         """
@@ -221,7 +221,7 @@ def itemChange(self, change, value):
         if change == self.ItemSelectedChange and self.scene():
             self.reset_pipes()
             if value:
-                self.hightlight_pipes()
+                self.highlight_pipes()
             self.setZValue(Z_VAL_NODE)
             if not self.selected:
                 self.setZValue(Z_VAL_NODE + 1)
@@ -274,7 +274,7 @@ def activate_pipes(self):
             for pipe in port.connected_pipes:
                 pipe.activate()
 
-    def hightlight_pipes(self):
+    def highlight_pipes(self):
         """
         highlight pipe color.
         """
@@ -497,7 +497,7 @@ def auto_switch_mode(self):
         # with is the node with in screen
         width = r.x() - l.x()
 
-        self.set_proxy_mode(width < self._porxy_mode_threshold)
+        self.set_proxy_mode(width < self._proxy_mode_threshold)
 
     def set_proxy_mode(self, mode):
         if mode is self._proxy_mode:
@@ -511,15 +511,13 @@ def set_proxy_mode(self, mode):
             w.widget.setVisible(visible)
         for port, text in self._input_items.items():
             port.setVisible(visible)
-            text.setVisible(visible)
-            # for pipe in port.connected_pipes:
-            #     pipe.setVisible(visible)
+            if text.visible_:
+                text.setVisible(visible)
 
         for port, text in self._output_items.items():
             port.setVisible(visible)
-            text.setVisible(visible)
-            # for pipe in port.connected_pipes:
-            #     pipe.setVisible(visible)
+            if text.visible_:
+                text.setVisible(visible)
 
         self.text_item.setVisible(visible)
         self._icon_item.setVisible(visible)
@@ -567,7 +565,7 @@ def disabled(self, state=False):
     def selected(self, selected=False):
         AbstractNodeItem.selected.fset(self, selected)
         if selected:
-            self.hightlight_pipes()
+            self.highlight_pipes()
 
     @AbstractNodeItem.name.setter
     def name(self, name=''):
@@ -625,6 +623,7 @@ def add_input(self, name='input', multi_port=False, display_name=True):
         text.font().setPointSize(8)
         text.setFont(text.font())
         text.setVisible(display_name)
+        text.visible_ = display_name
         text.setCacheMode(ITEM_CACHE_MODE)
         self._input_items[port] = text
         if self.scene():
@@ -650,6 +649,7 @@ def add_output(self, name='output', multi_port=False, display_name=True):
         text.font().setPointSize(8)
         text.setFont(text.font())
         text.setVisible(display_name)
+        text.visible_ = display_name
         text.setCacheMode(ITEM_CACHE_MODE)
         self._output_items[port] = text
         if self.scene():
@@ -731,3 +731,207 @@ def from_dict(self, node_dict):
         for name, value in widgets.items():
             if self._widgets.get(name):
                 self._widgets[name].value = value
+
+
+class NodeItemVertical(NodeItem):
+    def __init__(self, name='node', parent=None):
+        super(NodeItemVertical, self).__init__(name, parent)
+        font = QtGui.QFont()
+        font.setPointSize(15)
+        self.text_item.setFont(font)
+
+    def paint(self, painter, option, widget):
+        """
+        Draws the node base not the ports.
+
+        Args:
+            painter (QtGui.QPainter): painter used for drawing the item.
+            option (QtGui.QStyleOptionGraphicsItem):
+                used to describe the parameters needed to draw.
+            widget (QtWidgets.QWidget): not used.
+        """
+        self.auto_switch_mode()
+
+        painter.save()
+        bg_border = 1.0
+        rect = QtCore.QRectF(0.5 - (bg_border / 2),
+                             0.5 - (bg_border / 2),
+                             self._width + bg_border,
+                             self._height + bg_border)
+        radius = 2
+        border_color = QtGui.QColor(*self.border_color)
+
+        path = QtGui.QPainterPath()
+        path.addRoundedRect(rect, radius, radius)
+
+        rect = self.boundingRect()
+
+        bg_color = QtGui.QColor(*self.color)
+        painter.setBrush(bg_color)
+        painter.setPen(QtCore.Qt.NoPen)
+        painter.drawRoundedRect(rect, radius, radius)
+
+        if self.selected and NODE_SEL_COLOR:
+            painter.setBrush(QtGui.QColor(*NODE_SEL_COLOR))
+            painter.drawRoundedRect(rect, radius, radius)
+
+        label_rect = QtCore.QRectF(rect.left(), rect.top(), self._width, 15)
+        path = QtGui.QPainterPath()
+        path.addRoundedRect(label_rect, radius, radius)
+        painter.setBrush(QtGui.QColor(30, 30, 30, 200))
+        painter.fillPath(path, painter.brush())
+
+        label_rect = QtCore.QRectF(rect.left(), rect.bottom()-15, self._width, 15)
+        path = QtGui.QPainterPath()
+        path.addRoundedRect(label_rect, radius, radius)
+        painter.fillPath(path, painter.brush())
+
+        border_width = 0.8
+        if self.selected and NODE_SEL_BORDER_COLOR:
+            border_width = 1.2
+            border_color = QtGui.QColor(*NODE_SEL_BORDER_COLOR)
+        border_rect = QtCore.QRectF(rect.left() - (border_width / 2),
+                                    rect.top() - (border_width / 2),
+                                    rect.width() + border_width,
+                                    rect.height() + border_width)
+
+        pen = QtGui.QPen(border_color, border_width)
+        pen.setCosmetic(self.viewer().get_zoom() < 0.0)
+        path = QtGui.QPainterPath()
+        path.addRoundedRect(border_rect, radius, radius)
+        painter.setBrush(QtCore.Qt.NoBrush)
+        painter.setPen(pen)
+        painter.drawPath(path)
+
+        painter.restore()
+
+    def arrange_icon(self, h_offset=0.0, v_offset=0.0):
+        """
+        Arrange node icon to the default top left of the node.
+
+        Args:
+            v_offset (float): vertical offset.
+            h_offset (float): horizontal offset.
+        """
+        # icon_rect = self._icon_item.boundingRect()
+        # x = self._width / 2 - (icon_rect.width() / 2) + h_offset
+        # y = self._height / 2 - (icon_rect.height() / 2) + v_offset
+        x = 2.0 + h_offset
+        y = 17.0 + v_offset
+        self._icon_item.setPos(x, y)
+
+    def arrange_label(self, h_offset=0.0, v_offset=0.0):
+        """
+        Arrange node label to the default top center of the node.
+
+        Args:
+            v_offset (float): vertical offset.
+            h_offset (float): horizontal offset.
+        """
+        text_rect = self.text_item.boundingRect()
+        text_x = self._width + 10 + h_offset
+        text_y = self._height / 2 - (text_rect.height() / 2)
+        self.text_item.setPos(text_x, text_y)
+
+    def arrange_ports(self, v_offset=0.0):
+        """
+        Arrange input, output ports in the node layout.
+        """
+        # adjust input position
+        inputs = [p for p in self.inputs if p.isVisible()]
+        if inputs:
+            port_width = inputs[0].boundingRect().width()
+            port_height = inputs[0].boundingRect().height()
+            half_width = port_width/2
+            delta = self._width / (len(inputs)+1)
+            port_x = delta
+            port_y = (port_height / 2) * -1
+            for port in inputs:
+                port.setPos(port_x - half_width, port_y)
+                port_x += delta
+
+        # adjust output position
+        outputs = [p for p in self.outputs if p.isVisible()]
+        if outputs:
+            port_width = outputs[0].boundingRect().width()
+            port_height = outputs[0].boundingRect().height()
+            half_width = port_width / 2
+            delta = self._width / (len(outputs)+1)
+            port_x = delta
+            port_y = self._height - (port_height / 2)
+            for port in outputs:
+                port.setPos(port_x-half_width, port_y)
+                port_x += delta
+
+    def draw_node(self):
+        """
+        Draw the node item in the scene.
+        """
+        # setup initial base size.
+        self._set_base_size(add_w=0.0, add_h=0.0)
+        # set text color when node is initialized.
+        self._set_text_color(self.text_color)
+        # set the tooltip
+        self._tooltip_disable(self.disabled)
+
+        # --- setup node layout ---
+
+        # arrange label text
+        self.arrange_label(h_offset=0.0, v_offset=0.0)
+        # arrange icon
+        self.arrange_icon(h_offset=0.0, v_offset=0.0)
+        # arrange input and output ports.
+        self.arrange_ports()
+        # arrange node widgets
+        self.arrange_widgets(v_offset=0.0)
+        self.update()
+
+    def calc_size(self, add_w=0.0, add_h=0.0):
+        """
+        calculate minimum node size.
+
+        Args:
+            add_w (float): additional width.
+            add_h (float): additional height.
+        """
+        width = 0
+        height = 0
+
+        if self._widgets:
+            wid_width = max([
+                w.boundingRect().width() for w in self._widgets.values()
+            ])
+            width = max(width, wid_width)
+
+        port_width = 0.0
+        if self._input_items:
+            port = list(self._input_items.keys())[0]
+            height += port.boundingRect().height()
+            port_width = port.boundingRect().width()
+
+        if self._output_items:
+            port = list(self._output_items.keys())[0]
+            height += port.boundingRect().height()
+            port_width = port.boundingRect().width()
+
+        in_count = len([p for p in self.inputs if p.isVisible()])
+        out_count = len([p for p in self.outputs if p.isVisible()])
+        width = max(width, port_width * max(in_count, out_count))
+        if self._widgets:
+            wid_height = 0.0
+            for w in self._widgets.values():
+                wid_height += w.boundingRect().height()
+            wid_height += wid_height / len(self._widgets.values())
+            if wid_height > height:
+                height = wid_height
+
+        width += add_w
+        height += add_h + 15
+
+        return width, height
+
+    def add_input(self, name='input', multi_port=False, display_name=False):
+        return super(NodeItemVertical, self).add_input(name, multi_port, False)
+
+    def add_output(self, name='output', multi_port=False, display_name=False):
+        return super(NodeItemVertical, self).add_output(name, multi_port, False)