disable pipe collision #206

Author: jchanvfx

NodeGraphQt/base/graph.py

@@ -171,8 +171,8 @@ def _on_insert_node(self, pipe, node_id, prev_node_pos):
             return
         node = self.get_node_by_id(node_id)
 
-        # exclude the BackdropNode
-        if isinstance(node, BackdropNode):
+        # exclude if not a BaseNode
+        if not isinstance(node, BaseNode):
             return
 
         disconnected = [(pipe.input_port, pipe.output_port)]
@@ -735,6 +735,35 @@ def set_acyclic(self, mode=False):
         self._model.acyclic = mode
         self._viewer.acyclic = mode
 
+    def pipe_collision(self):
+        """
+        Returns if pipe collision is enabled.
+
+        See Also:
+            To enable/disable pipe collision
+            :meth:`NodeGraph.set_pipe_collision_enabled`
+
+        Returns:
+            bool: True if pipe collision is enabled.
+        """
+        return self._model.pipe_collision
+
+    def set_pipe_collision(self, mode=True):
+        """
+        Enable/Disable pipe collision.
+
+        When enabled dragging a node over a pipe will allow the node to be
+        inserted as a new connection between the pipe.
+
+        See Also:
+            :meth:`NodeGraph.pipe_collision`
+
+        Args:
+            mode (bool): False to disable pipe collision.
+        """
+        self._model.pipe_collision = mode
+        self._viewer.pipe_collision = mode
+
     def set_pipe_style(self, style=PIPE_LAYOUT_CURVED):
         """
         Set node graph pipes to be drawn as straight, curved or angled.
@@ -930,6 +959,8 @@ def format_color(clr):
     def add_node(self, node, pos=None, unique_name=True):
         """
         Add a node into the node graph.
+        unlike the :meth:`NodeGraph.create_node` function this will not
+        trigger the :attr:`NodeGraph.node_created` signal.
 
         Args:
             node (NodeGraphQt.BaseNode): node object.
@@ -956,7 +987,11 @@ def add_node(self, node, pos=None, unique_name=True):
         node.model._graph_model = self.model
         node.model.name = node.NODE_NAME
         node.update()
+
+        self._undo_stack.beginMacro('add node: "{}"'.format(node.name()))
         self._undo_stack.push(NodeAddedCmd(self, node, pos))
+        node.set_selected(True)
+        self._undo_stack.endMacro()
 
     def set_node_space(self, node):
         """
@@ -1214,11 +1249,20 @@ def clear_session(self):
         for n in self.all_nodes():
             if n is root_node:
                 continue
+            if isinstance(n, BaseNode):
+                for p in n.input_ports():
+                    if p.locked():
+                        p.set_locked(False, connected_ports=False)
+                    p.clear_connections()
+                for p in n.output_ports():
+                    if p.locked():
+                        p.set_locked(False, connected_ports=False)
+                    p.clear_connections()
             self._undo_stack.push(NodeRemovedCmd(self, n))
         self.set_node_space(root_node)
         self.clear_undo_stack()
-        self._model.session = None
-        self.session_changed.emit("")
+        self._model.session = ''
+        self.session_changed.emit('')
 
     def _serialize(self, nodes):
         """
@@ -1231,14 +1275,21 @@ def _serialize(self, nodes):
         Returns:
             dict: serialized data.
         """
-        serial_data = {'nodes': {}, 'connections': []}
+        serial_data = {'graph': {}, 'nodes': {}, 'connections': []}
         nodes_data = {}
+
+        # serialize graph session.
+        serial_data['graph']['acyclic'] = self.acyclic()
+        serial_data['graph']['pipe_collision'] = self.pipe_collision()
+
+        # serialize nodes.
         root_node = self.root_node()
         for n in nodes:
             if n is root_node:
                 continue
             # update the node model.
             n.update_model()
+
             node_dict = n.model.to_dict
 
             if isinstance(n, SubGraph):
@@ -1253,6 +1304,7 @@ def _serialize(self, nodes):
         for n_id, n_data in nodes_data.items():
             serial_data['nodes'][n_id] = n_data
 
+            # serialize connections
             inputs = n_data.pop('inputs') if n_data.get('inputs') else {}
             outputs = n_data.pop('outputs') if n_data.get('outputs') else {}
 
@@ -1294,6 +1346,13 @@ def _deserialize(self, data, relative_pos=False, pos=None, set_parent=True):
         if not self._editable:
             return
 
+        # update node graph properties.
+        for attr_name, attr_value in data.get('graph', {}).items():
+            if attr_name == 'acyclic':
+                self.set_acyclic(attr_value)
+            elif attr_name == 'pipe_collision':
+                self.set_pipe_collision(attr_value)
+
         _temp_auto_update = self._auto_update
         self._auto_update = False
 
@@ -1452,7 +1511,6 @@ def import_session(self, file_path):
         Args:
             file_path (str): path to the serialized layout file.
         """
-
         file_path = file_path.strip()
         if not os.path.isfile(file_path):
             raise IOError('file does not exist: {}'.format(file_path))
@@ -1746,7 +1804,7 @@ def question_dialog(self, text, title='Node Graph'):
         Returns:
             bool: true if user clicked yes.
         """
-        self._viewer.question_dialog(text, title)
+        return self._viewer.question_dialog(text, title)
 
     def message_dialog(self, text, title='Node Graph'):
         """

NodeGraphQt/base/model.py

@@ -320,25 +320,46 @@ def serial(self):
 
 
 class NodeGraphModel(object):
+    """
+    Data dump for a node graph.
+    """
 
     def __init__(self):
+        self.__common_node_props = {}
+
         self.nodes = {}
         self.session = ''
         self.acyclic = True
-        self.__common_node_props = {}
+        self.pipe_collision = False
 
     def common_properties(self):
+        """
+        Return all common node properties.
+
+        Returns:
+            dict: common node properties.
+                eg.
+                    {'nodeGraphQt.nodes.FooNode': {
+                        'my_property': {
+                            'widget_type': 0,
+                            'tab': 'Properties',
+                            'items': ['foo', 'bar', 'test'],
+                            'range': (0, 100)
+                            }
+                        }
+                    }
+        """
         return self.__common_node_props
 
     def set_node_common_properties(self, attrs):
         """
-        store common node properties.
+        Store common node properties.
 
         Args:
             attrs (dict): common node properties.
                 eg.
-                     {'nodeGraphQt.nodes.FooNode': {
-                        'my_property':{
+                    {'nodeGraphQt.nodes.FooNode': {
+                        'my_property': {
                             'widget_type': 0,
                             'tab': 'Properties',
                             'items': ['foo', 'bar', 'test'],
@@ -363,6 +384,8 @@ def set_node_common_properties(self, attrs):
 
     def get_node_common_properties(self, node_type):
         """
+        Return all the common properties for a registered node.
+
         Args:
             node_type (str): node type.
 

NodeGraphQt/constants.py

@@ -106,8 +106,8 @@
 VIEWER_GRID_COLOR = (45, 45, 45)
 VIEWER_GRID_SIZE = 50
 
-URI_SCHEME = 'ngqt://'
-URN_SCHEME = 'ngqt::'
+URI_SCHEME = 'NodeGraphQt://'
+URN_SCHEME = 'NodeGraphQt::'
 
 # === PATHS ===
 

NodeGraphQt/widgets/viewer.py

@@ -116,6 +116,8 @@ def __init__(self, parent=None):
         self._ctx_node_menu.setDisabled(True)
 
         self.acyclic = True
+        self.pipe_collision = False
+
         self.LMB_state = False
         self.RMB_state = False
         self.MMB_state = False
@@ -385,9 +387,8 @@ def mouseReleaseEvent(self, event):
         # emit signal if selected node collides with pipe.
         # Note: if collide state is true then only 1 node is selected.
         nodes, pipes = self.selected_items()
-        if self.COLLIDING_state:
-            if nodes and pipes:
-                self.insert_node.emit(pipes[0], nodes[0].id, moved_nodes)
+        if self.COLLIDING_state and nodes and pipes:
+            self.insert_node.emit(pipes[0], nodes[0].id, moved_nodes)
 
         # emit node selection changed signal.
         prev_ids = [n.id for n in self._prev_selection_nodes if not n.selected]
@@ -447,21 +448,25 @@ def mouseMoveEvent(self, event):
 
         elif self.LMB_state:
             self.COLLIDING_state = False
-            nodes = self.selected_nodes()
+            nodes, pipes = self.selected_items()
             if len(nodes) == 1:
                 node = nodes[0]
-                for pipe in self.selected_pipes():
-                    pipe.setSelected(False)
-                for item in node.collidingItems():
-                    if isinstance(item, Pipe) and item.isVisible():
-                        if not item.input_port:
+                [p.setSelected(False) for p in pipes]
+
+                if self.pipe_collision:
+                    colliding_pipes = [
+                        i for i in node.collidingItems()
+                        if isinstance(i, Pipe) and i.isVisible()
+                    ]
+                    for pipe in colliding_pipes:
+                        if not pipe.input_port:
                             continue
                         port_node_check = all([
-                            not item.input_port.node is node,
-                            not item.output_port.node is node
+                            not pipe.input_port.node is node,
+                            not pipe.output_port.node is node
                         ])
                         if port_node_check:
-                            item.setSelected(True)
+                            pipe.setSelected(True)
                             self.COLLIDING_state = True
                             break