refactored property bin signals.

Author: jchanvfx

NodeGraphQt/__init__.py

@@ -41,11 +41,11 @@
 __url__ = 'https://github.com/jchanvfx/NodeGraphQt'
 
 __all__ = [
-    'NodeGraph', 'NodeObject', 'BaseNode', 'BackdropNode', 'Port',
-    'Menu', 'MenuCommand', 'setup_context_menu'
+    'BackdropNode', 'BaseNode', 'Menu', 'MenuCommand', 'NodeGraph',
+    'NodeObject', 'Port', 'PropertiesBinWidget', 'constants',
+    'setup_context_menu'
 ]
 
-
 try:
     from Qt import QtWidgets, QtGui, QtCore, QtCompat
 except ImportError as ie:
@@ -61,3 +61,6 @@
 
 # functions
 from .base.actions import setup_context_menu
+
+# widgets
+from .widgets.properties_bin import PropertiesBinWidget

NodeGraphQt/base/commands.py

@@ -50,29 +50,21 @@ def set_node_prop(self, name, value):
                 name = 'xy_pos'
             setattr(view, name, value)
 
-    def update_prop_bin(self, name, value):
-        """
-        updates the property bin widget.
-        """
-        graph = self.node.graph
-        prop_bin = graph.properties_bin()
-        properties_wgt = prop_bin.prop_widget(self.node)
-        if properties_wgt:
-            prop_wgt = properties_wgt.get_widget(name)
-            # check if previous value is identical to current value,
-            # prevent signals from causing a infinite loop.
-            if prop_wgt and prop_wgt.get_value() != value:
-                prop_wgt.set_value(value)
-
     def undo(self):
         if self.old_val != self.new_val:
             self.set_node_prop(self.name, self.old_val)
-            self.update_prop_bin(self.name, self.old_val)
+
+            # emit property changed signal.
+            graph = self.node.graph
+            graph.property_changed.emit(self.node, self.name, self.old_val)
 
     def redo(self):
         if self.old_val != self.new_val:
             self.set_node_prop(self.name, self.new_val)
-            self.update_prop_bin(self.name, self.new_val)
+
+            # emit property changed signal.
+            graph = self.node.graph
+            graph.property_changed.emit(self.node, self.name, self.new_val)
 
 
 class NodeMovedCmd(QtWidgets.QUndoCommand):

NodeGraphQt/base/graph.py

@@ -16,16 +16,12 @@
 from NodeGraphQt.base.port import Port
 from NodeGraphQt.constants import DRAG_DROP_ID
 from NodeGraphQt.widgets.node_tree import NodeTreeWidget
-from NodeGraphQt.widgets.properties_bin import PropertiesBinWidget
 from NodeGraphQt.widgets.viewer import NodeViewer
 
 
 class NodeGraph(QtCore.QObject):
     """
     base node graph controller.
-
-    Args:
-        tab_search_key(str): hotkey for the tab search widget (default: "tab").
     """
 
     #: signal for when a node has been created in the node graph.
@@ -49,7 +45,6 @@ def __init__(self, parent=None):
         self._node_factory = NodeFactory()
         self._undo_stack = QtWidgets.QUndoStack(self)
 
-        self._properties_bin = None
         self._nodes_tree = None
 
         tab = QtWidgets.QAction('Search Nodes', self)
@@ -80,9 +75,9 @@ def _toggle_tab_search(self):
         self._viewer.tab_search_set_nodes(self._node_factory.names)
         self._viewer.tab_search_toggle()
 
-    def _on_property_changed(self, node_id, prop_name, prop_value):
+    def _on_property_bin_changed(self, node_id, prop_name, prop_value):
         """
-        called when a property widget has changed in the properties bin.
+        called when a property widget has changed in a properties bin.
         (emits the node object, property name, property value)
 
         Args:
@@ -91,8 +86,10 @@ def _on_property_changed(self, node_id, prop_name, prop_value):
             prop_value (object): python object.
         """
         node = self.get_node_by_id(node_id)
-        node.set_property(prop_name, prop_value)
-        self.property_changed.emit(node, prop_name, prop_value)
+
+        # prevent signals from causing a infinite loop.
+        if node.get_property(prop_name) != prop_value:
+            node.set_property(prop_name, prop_value)
 
     def _on_node_double_clicked(self, node_id):
         """
@@ -103,9 +100,6 @@ def _on_node_double_clicked(self, node_id):
             node_id (str): node id emitted by the viewer.
         """
         node = self.get_node_by_id(node_id)
-        if self._properties_bin:
-            self._properties_bin.add_node(node)
-
         self.node_double_clicked.emit(node)
 
     def _on_node_selected(self, node_id):
@@ -237,20 +231,14 @@ def scene(self):
         """
         return self._viewer.scene()
 
-    def properties_bin(self):
+    def add_properties_bin(self, prop_bin):
         """
-        Initializes the node properties bin widget when first called.
+        Wire up a properties bin widget to the node graph.
 
-        Returns:
-            PropBinWidget: the initialized widget.
-        """
-        if self._properties_bin is None:
-            self._properties_bin = PropertiesBinWidget()
-            # wire up widget.
-            self._properties_bin.property_changed.connect(
-                self._on_property_changed
-            )
-        return self._properties_bin
+        Args:
+            prop_bin (NodeGraphQt.PropertiesBinWidget): properties widget.
+        """
+        prop_bin.property_changed.connect(self._on_property_bin_changed)
 
     def nodes_tree(self):
         """

NodeGraphQt/base/node.py

@@ -264,6 +264,8 @@ def set_property(self, name, value):
             name (str): name of the property.
             value (object): property data.
         """
+
+        # prevent signals from causing a infinite loop.
         if self.get_property(name) == value:
             return
 

NodeGraphQt/widgets/properties.py

@@ -330,7 +330,7 @@ class NodePropWidget(QtWidgets.QWidget):
     Node properties widget for display a Node object.
 
     Args:
-        parent:
+        parent (QtWidgets.QWidget): parent object.
         node (NodeGraphQt.BaseNode): node.
     """
 

NodeGraphQt/widgets/properties_bin.py

@@ -52,23 +52,29 @@ def __init__(self, parent=None):
 class PropertiesBinWidget(QtWidgets.QWidget):
     """
     Node properties bin for displaying properties.
+
+    Args:
+        parent (QtWidgets.QWidget): parent object.
+        node_graph (NodeGraphQt.NodeGraph): node graph.
     """
 
     #: Signal emitted (node_id, prop_name, prop_value)
     property_changed = QtCore.Signal(str, str, object)
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, node_graph=None):
         super(PropertiesBinWidget, self).__init__(parent)
         self.setWindowTitle('Properties Bin')
         self._prop_list = PropertiesList()
         self._limit = QtWidgets.QSpinBox()
-        self._limit.setToolTip('Set node limit to display.')
+        self._limit.setToolTip('Set display nodes limit.')
         self._limit.setMaximum(10)
         self._limit.setMinimum(0)
         self._limit.setValue(5)
         self._limit.valueChanged.connect(self.__on_limit_changed)
         self.resize(400, 400)
 
+        self._block_signal = False
+
         btn_clr = QtWidgets.QPushButton('clear')
         btn_clr.setToolTip('Clear the properties bin.')
         btn_clr.clicked.connect(self.clear_bin)
@@ -82,6 +88,11 @@ def __init__(self, parent=None):
         layout.addLayout(top_layout)
         layout.addWidget(self._prop_list, 1)
 
+        # wire up node graph.
+        node_graph.add_properties_bin(self)
+        node_graph.node_double_clicked.connect(self.add_node)
+        node_graph.property_changed.connect(self.__on_graph_property_changed)
+
     def __repr__(self):
         return '<{} object at {}>'.format(self.__class__.__name__, hex(id(self)))
 
@@ -94,6 +105,37 @@ def __on_limit_changed(self, value):
         if rows > value:
             self._prop_list.removeRow(rows - 1)
 
+    def __on_graph_property_changed(self, node, prop_name, prop_value):
+        """
+        Slot function that updates the property bin from the node graph signal.
+
+        Args:
+            node (NodeGraphQt.NodeObject):
+            prop_name (str):
+            prop_value (object):
+        """
+        properties_widget = self.prop_widget(node)
+        if not properties_widget:
+            return
+
+        property_window = properties_widget.get_widget(prop_name)
+        if prop_value != property_window.get_value():
+            self._block_signal = True
+            property_window.set_value(prop_value)
+            self._block_signal = False
+
+    def __on_property_widget_changed(self, node_id, prop_name, prop_value):
+        """
+        Slot function triggered when a property widget value has changed.
+
+        Args:
+            node_id (str):
+            prop_name (str):
+            prop_value (object):
+        """
+        if not self._block_signal:
+            self.property_changed.emit(node_id, prop_name, prop_value)
+
     def limit(self):
         """
         Returns the limit for how many nodes can be loaded into the bin.
@@ -132,7 +174,7 @@ def add_node(self, node):
 
         self._prop_list.insertRow(0)
         prop_widget = NodePropWidget(node=node)
-        prop_widget.property_changed.connect(self.property_changed.emit)
+        prop_widget.property_changed.connect(self.__on_property_widget_changed)
         prop_widget.property_closed.connect(self.__on_prop_close)
         self._prop_list.setCellWidget(0, 0, prop_widget)
 

docs/widgets.rst

@@ -11,17 +11,17 @@ PropertiesBinWidget
 .. code-block:: python
     :linenos:
 
-    from NodeGraphQt import NodeGraph
+    from NodeGraphQt import NodeGraph, PropertiesBinWidget
 
     graph = NodeGraph()
 
     # create properties bin widget.
-    properties_bin = graph.properties_bin()
+    properties_bin = PropertiesBinWidget(node_graph=graph)
     properties_bin.show()
 
 ----
 
-.. autoclass:: NodeGraphQt.widgets.properties_bin.PropertiesBinWidget
+.. autoclass:: NodeGraphQt.PropertiesBinWidget
     :members:
     :exclude-members: property_changed
 

example.py

@@ -7,7 +7,7 @@
                          BaseNode,
                          BackdropNode,
                          setup_context_menu)
-from NodeGraphQt import QtWidgets, QtCore
+from NodeGraphQt import QtWidgets, QtCore, PropertiesBinWidget
 
 # import example nodes from the "example_nodes" package
 from example_nodes import basic_nodes, widget_nodes
@@ -49,7 +49,7 @@ def __init__(self):
 
 
     # show the properties bin when a node is "double clicked" in the graph.
-    properties_bin = graph.properties_bin()
+    properties_bin = PropertiesBinWidget(node_graph=graph)
     properties_bin.setWindowFlags(QtCore.Qt.Tool)
     def show_prop_bin(node):
         if not properties_bin.isVisible():