add node publish

Author: ArnoChenFx

NodeGraphQt/__init__.py

@@ -94,6 +94,7 @@ def __init__(self):
 # widgets
 from .widgets.node_tree import NodeTreeWidget
 from .widgets.properties_bin import PropertiesBinWidget
+from .widgets.node_publish_widget import NodePublishWidget
 
 __version__ = VERSION
 __all__ = [
@@ -110,6 +111,7 @@ def __init__(self):
     'PropertiesBinWidget',
     'VERSION',
     'constants',
-    'setup_context_menu'
+    'setup_context_menu',
+    'NodePublishWidget'
 ]
 

NodeGraphQt/base/graph.py

@@ -717,6 +717,7 @@ def register_node(self, node, alias=None):
             alias (str): custom alias name for the node type.
         """
         self._node_factory.register_node(node, alias)
+        self._viewer.rebuild_tab_search()
 
     def create_node(self, node_type, name=None, selected=True, color=None,
                     text_color=None, pos=None):
@@ -815,7 +816,6 @@ def add_node(self, node, pos=None, unique_name=True):
             for pname, pattrs in prop_attrs.items():
                 node_attrs[node.type_][pname].update(pattrs)
             self.model.set_node_common_properties(node_attrs)
-
         node.set_graph(self)
         if unique_name:
             node.NODE_NAME = self.get_unique_name(node.NODE_NAME)
@@ -1072,9 +1072,13 @@ def _serialize(self, nodes):
             node_dict = n.model.to_dict
 
             if isinstance(n, SubGraph):
-                children = n.children()
-                if children:
-                    node_dict[n.model.id]['sub_graph'] = self._serialize(children)
+                published = n.has_property('published')
+                if published:
+                    published = n.get_property('published')
+                if not published:
+                    children = n.children()
+                    if children:
+                        node_dict[n.model.id]['sub_graph'] = self._serialize(children)
 
             nodes_data.update(node_dict)
 
@@ -1135,13 +1139,18 @@ def _deserialize(self, data, relative_pos=False, pos=None, set_parent=True):
                     node.model.set_property(prop, val)
                 nodes[n_id] = node
                 self.add_node(node, n_data.get('pos'), unique_name=set_parent)
-                node.set_graph(self)
+                # node.set_graph(self)
 
                 if isinstance(node, SubGraph):
-                    sub_graph = n_data.get('sub_graph', None)
-                    if sub_graph:
-                        children = self._deserialize(sub_graph, relative_pos, pos, False)
-                        [child.set_parent(node) for child in children]
+                    if n_data.get('custom', None):
+                        published = n_data['custom'].get('published', False)
+                    else:
+                        published = False
+                    if not published:
+                        sub_graph = n_data.get('sub_graph', None)
+                        if sub_graph:
+                            children = self._deserialize(sub_graph, relative_pos, pos, False)
+                            [child.set_parent(node) for child in children]
 
                 if n_data.get('dynamic_port', None):
                     node.set_ports({'input_ports': n_data['input_ports'], 'output_ports': n_data['output_ports']})
@@ -1203,18 +1212,21 @@ def save_session(self, file_path):
         Args:
             file_path (str): path to the saved node layout.
         """
+
         root_node = self.root_node()
         if root_node is not None:
             nodes = root_node.children()
         else:
             nodes = self.all_nodes()
+
         serialized_data = self._serialize(nodes)
 
         node_space = self.get_node_space()
         if node_space is not None:
             node_space = node_space.id
         serialized_data['graph'] = {'node_space': node_space, 'pipe_layout': self._viewer.get_pipe_layout()}
         serialized_data['graph']['graph_rect'] = self._viewer.scene_rect()
+
         file_path = file_path.strip()
         with open(file_path, 'w') as file_out:
             json.dump(serialized_data, file_out, indent=2, separators=(',', ':'))

NodeGraphQt/constants.py

@@ -71,18 +71,20 @@
 NODE_PROP_SLIDER = 9
 #: Property type represented with a file selector widget in the properties bin.
 NODE_PROP_FILE = 10
+#: Property type represented with a file save widget in the properties bin.
+NODE_PROP_FILE_SAVE = 11
 #: Property type represented with a vector2 widget in the properties bin.
-NODE_PROP_VECTOR2 = 11
+NODE_PROP_VECTOR2 = 12
 #: Property type represented with vector3 widget in the properties bin.
-NODE_PROP_VECTOR3 = 12
+NODE_PROP_VECTOR3 = 13
 #: Property type represented with vector4 widget in the properties bin.
-NODE_PROP_VECTOR4 = 13
+NODE_PROP_VECTOR4 = 14
 #: Property type represented with float widget in the properties bin.
-NODE_PROP_FLOAT = 14
+NODE_PROP_FLOAT = 15
 #: Property type represented with int widget in the properties bin.
-NODE_PROP_INT = 15
+NODE_PROP_INT = 16
 #: Property type represented with button widget in the properties bin.
-NODE_PROP_BUTTON = 16
+NODE_PROP_BUTTON = 17
 
 # === NODE VIEWER ===
 

NodeGraphQt/widgets/node_publish_widget.py

@@ -0,0 +1,89 @@
+# from .. import QtWidgets
+from PySide2 import QtWidgets
+import os
+from NodeGraphQt.widgets.properties import PropFileSavePath
+
+
+class _element_widget(QtWidgets.QWidget):
+    def __init__(self):
+        super(_element_widget, self).__init__()
+        self.layout = QtWidgets.QHBoxLayout(self)
+
+
+class NodePublishWidget(QtWidgets.QDialog):
+    def __init__(self, node):
+        super(NodePublishWidget, self).__init__()
+        self.setWindowTitle("Publish Node")
+        self.published = False
+
+        layout = QtWidgets.QVBoxLayout(self)
+        self.layout = QtWidgets.QHBoxLayout(self)
+        self.node = node
+        self.node_name = QtWidgets.QLineEdit(node.name())
+        self.node_class_name = QtWidgets.QLineEdit(node.name().replace(" ", "_"))
+        self.node_identifier = QtWidgets.QLineEdit('Custom')
+
+        path = os.getcwd() + "/example_auto_nodes/published_nodes"
+        if not os.path.exists(path):
+            path = os.getcwd()
+        path += "/" + self.node_class_name.text() + ".node"
+        path = path.replace('\\', '/')
+
+        self.file_path_widget = PropFileSavePath()
+        self.file_path_widget.set_file_dir(path)
+        self.file_path_widget.set_ext('*.json;*.node')
+        self.file_path_widget.set_value(path)
+
+        publish_btn = QtWidgets.QPushButton('Publish')
+        publish_btn.pressed.connect(lambda: self.publish())
+
+        cancel_btn = QtWidgets.QPushButton('Cancel')
+        cancel_btn.pressed.connect(lambda: self.close())
+
+        name_widget = _element_widget()
+        name_widget.layout.addWidget(QtWidgets.QLabel('Node Name'))
+        name_widget.layout.addWidget(self.node_name)
+
+        identifier_widget = _element_widget()
+        identifier_widget.layout.addWidget(QtWidgets.QLabel('Node Identifier'))
+        identifier_widget.layout.addWidget(self.node_identifier)
+
+        class_name_widget = _element_widget()
+        class_name_widget.layout.addWidget(QtWidgets.QLabel('Node Class Name'))
+        class_name_widget.layout.addWidget(self.node_class_name)
+
+        layout.addWidget(name_widget)
+        layout.addWidget(class_name_widget)
+        layout.addWidget(identifier_widget)
+        layout.addWidget(self.file_path_widget)
+        layout.addWidget(publish_btn)
+        layout.addWidget(cancel_btn)
+
+        layout.addStretch()
+
+    def publish(self):
+        if self.published:
+            return
+        file_path = self.file_path_widget.get_value()
+        node_name = self.node_name.text()
+        node_identifier = self.node_identifier.text()
+        node_class_name = self.node_class_name.text()
+        self.node.publish(file_path, node_name, node_identifier, node_class_name)
+        self.published = True
+        self.close()
+
+
+if __name__ == '__main__':
+    import sys
+
+    class node(object):
+        def __init__(self):
+            pass
+
+        def name(self):
+            return 'node name'
+
+    app = QtWidgets.QApplication()
+    wid = NodePublishWidget(None, node())
+    wid.show()
+    sys.exit(app.exec_())

NodeGraphQt/widgets/properties.py

@@ -11,6 +11,7 @@
                          NODE_PROP_COLORPICKER,
                          NODE_PROP_SLIDER,
                          NODE_PROP_FILE,
+                         NODE_PROP_FILE_SAVE,
                          NODE_PROP_VECTOR2,
                          NODE_PROP_VECTOR3,
                          NODE_PROP_VECTOR4,
@@ -289,12 +290,16 @@ def __init__(self, parent=None):
         self._ledit.setStyleSheet("QLineEdit{border:1px solid}")
         _button.setStyleSheet("QPushButton{border:1px solid}")
         self._ext = "*"
+        self._file_dir = None
 
     def set_ext(self, ext):
         self._ext = ext
 
+    def set_file_dir(self, dir):
+        self._file_dir = dir
+
     def _on_select_file(self):
-        file_path = file_dialog.getOpenFileName(self, ext_filter=self._ext)
+        file_path = file_dialog.getOpenFileName(self, file_dir=self._file_dir, ext_filter=self._ext)
         file = file_path[0] or None
         if file:
             self.set_value(file)
@@ -314,6 +319,17 @@ def set_value(self, value):
             self._on_value_change(_value)
 
 
+class PropFileSavePath(PropFilePath):
+    def __init__(self, parent=None):
+        super(PropFileSavePath, self).__init__(parent)
+
+    def _on_select_file(self):
+        file_path = file_dialog.getSaveFileName(self, file_dir=self._file_dir, ext_filter=self._ext)
+        file = file_path[0] or None
+        if file:
+            self.set_value(file)
+
+
 class _valueMenu(QtWidgets.QMenu):
     mouseMove = QtCore.Signal(object)
     mouseRelease = QtCore.Signal(object)
@@ -676,6 +692,7 @@ def get_value(self):
     NODE_PROP_COLORPICKER: PropColorPicker,
     NODE_PROP_SLIDER: PropSlider,
     NODE_PROP_FILE: PropFilePath,
+    NODE_PROP_FILE_SAVE: PropFileSavePath,
     NODE_PROP_VECTOR2: PropVector2,
     NODE_PROP_VECTOR3: PropVector3,
     NODE_PROP_VECTOR4: PropVector4,

NodeGraphQt/widgets/tab_search.py

@@ -125,37 +125,39 @@ def fuzzyFinder(key, collection):
     return [x for _, _, x in sorted(suggestions)]
 
 
-class TabSearchMenuWidget(QtWidgets.QLineEdit):
+class TabSearchMenuWidget(QtWidgets.QMenu):
     search_submitted = QtCore.Signal(str)
 
-    def __init__(self, parent=None, node_dict=None):
-        super(TabSearchMenuWidget, self).__init__(parent)
-        self.setAttribute(QtCore.Qt.WA_MacShowFocusRect, 0)
-        self.setStyleSheet(STYLE_TABSEARCH)
-        self.setMinimumSize(200, 22)
-        self.setTextMargins(2, 0, 2, 0)
+    def __init__(self, node_dict=None):
+        super(TabSearchMenuWidget, self).__init__()
+
+        self.line_edit = QtWidgets.QLineEdit()
+        self.line_edit.setAttribute(QtCore.Qt.WA_MacShowFocusRect, 0)
+        self.line_edit.setStyleSheet(STYLE_TABSEARCH)
+        self.line_edit.setMinimumSize(200, 22)
+        self.line_edit.setTextMargins(2, 0, 2, 0)
 
         self._node_dict = node_dict or {}
         if self._node_dict:
             self._generate_items_from_node_dict()
 
-        self.SearchMenu = QtWidgets.QMenu()
-        searchWidget = QtWidgets.QWidgetAction(self)
-        searchWidget.setDefaultWidget(self)
-        self.SearchMenu.addAction(searchWidget)
-        self.SearchMenu.setStyleSheet(STYLE_QMENU)
+        searchWidget = QtWidgets.QWidgetAction(self.line_edit)
+        searchWidget.setDefaultWidget(self.line_edit)
+        self.addAction(searchWidget)
+        self.setStyleSheet(STYLE_QMENU)
 
         self._actions = {}
         self._menus = {}
         self._searched_actions = []
 
-        self.returnPressed.connect(self._on_search_submitted)
-        self.textChanged.connect(self._on_text_changed)
+        self.line_edit.returnPressed.connect(self._on_search_submitted)
+        self.line_edit.textChanged.connect(self._on_text_changed)
+        self.rebuild = False
 
     def __repr__(self):
         return '<{} at {}>'.format(self.__class__.__name__, hex(id(self)))
 
-    def _on_text_changed(self,text):
+    def _on_text_changed(self, text):
         self._clear_actions()
 
         if not text:
@@ -167,32 +169,32 @@ def _on_text_changed(self,text):
         action_names = fuzzyFinder(text, self._actions.keys())
 
         self._searched_actions = [self._actions[name] for name in action_names]
-        self.SearchMenu.addActions(self._searched_actions)
+        self.addActions(self._searched_actions)
 
         if self._searched_actions:
-            self.SearchMenu.setActiveAction(self._searched_actions[0])
+            self.setActiveAction(self._searched_actions[0])
 
     def _clear_actions(self):
-        for action in self._searched_actions:
-            self.SearchMenu.removeAction(action)
+        [self.removeAction(action) for action in self._searched_actions]
         self._searched_actions = []
 
     def _set_menu_visible(self, visible):
         [menu.menuAction().setVisible(visible) for menu in self._menus.values()]
 
     def _close(self):
         self._set_menu_visible(False)
-        self.SearchMenu.setVisible(False)
-        self.SearchMenu.menuAction().setVisible(False)
+        self.setVisible(False)
+        self.menuAction().setVisible(False)
 
     def _show(self):
-        self.setText("")
-        self.setFocus()
+        self.line_edit.setText("")
+        self.line_edit.setFocus()
         self._set_menu_visible(True)
-        self.SearchMenu.exec_(QtGui.QCursor.pos())
+        self.exec_(QtGui.QCursor.pos())
 
     def _on_search_submitted(self):
         action = self.sender()
+        print(action)
         if type(action) is not QtWidgets.QAction:
             if len(self._searched_actions) > 0:
                 action = self._searched_actions[0]
@@ -237,7 +239,7 @@ def build_menu_tree(self):
             for menu_path, menu in menus.items():
                 self._menus[menu_path] = menu
                 if i == 0:
-                    self.SearchMenu.addMenu(menu)
+                    self.addMenu(menu)
                 else:
                     parentMenu = self._menus[menu.parentPath]
                     parentMenu.addMenu(menu)
@@ -254,18 +256,24 @@ def build_menu_tree(self):
             if menu_path in self._menus.keys():
                 self._menus[menu_path].addAction(action)
             else:
-                self.SearchMenu.addAction(action)
+                self.addAction(action)
 
     def set_nodes(self, node_dict=None):
-        if not self._node_dict:
+        if not self._node_dict or self.rebuild:
             self._node_dict.clear()
+            self._clear_actions()
+            self._set_menu_visible(False)
+            [self.removeAction(menu.menuAction()) for menu in self._menus.values()]
+            self._actions.clear()
+            self._menus.clear()
             for name, node_types in node_dict.items():
                 if len(node_types) == 1:
                     self._node_dict[name] = node_types[0]
                     continue
                 for node_id in node_types:
                     self._node_dict['{} ({})'.format(name, node_id)] = node_id
             self.build_menu_tree()
+            self.rebuild = False
 
         self._show()