refactored context menu setup and support for deserializing JSON menu files. #254

Author: jchanvfx

NodeGraphQt/base/graph.py

@@ -158,13 +158,28 @@ def __init__(self, parent=None, **kwargs):
             kwargs.get('viewer') or NodeViewer(undo_stack=self._undo_stack))
         self._viewer.set_layout_direction(layout_direction)
 
+        self._context_menu = {}
+
+        self._register_context_menu()
         self._register_builtin_nodes()
         self._wire_signals()
 
     def __repr__(self):
         return '<{}("root") object at {}>'.format(
             self.__class__.__name__, hex(id(self)))
 
+    def _register_context_menu(self):
+        """
+        Register the default context menus.
+        """
+        if not self._viewer:
+            return
+        menus = self._viewer.context_menus()
+        if menus.get('graph'):
+            self._context_menu['graph'] = NodeGraphMenu(self, menus['graph'])
+        if menus.get('nodes'):
+            self._context_menu['nodes'] = NodesMenu(self, menus['nodes'])
+
     def _register_builtin_nodes(self):
         """
         Register the default builtin nodes to the :meth:`NodeGraph.node_factory`
@@ -688,68 +703,62 @@ def get_context_menu(self, menu):
         Returns:
             NodeGraphQt.NodeGraphMenu or NodeGraphQt.NodesMenu: context menu object.
         """
-        menus = self._viewer.context_menus()
-        if menus.get(menu):
-            if menu == 'graph':
-                return NodeGraphMenu(self, menus[menu])
-            elif menu == 'nodes':
-                return NodesMenu(self, menus[menu])
+        return self._context_menu.get(menu)
 
-    @staticmethod
-    def _build_context_menu_command(menu, data):
+    def _deserialize_context_menu(self, menu, menu_data):
         """
-        Create context menu command from serialized data.
+        Populate context menu from a dictionary.
 
         Args:
             menu (NodeGraphQt.NodeGraphMenu or NodeGraphQt.NodesMenu):
-                menu object.
-            data (dict): serialized menu command data.
+                parent context menu.
+            menu_data (list[dict] or dict): serialized menu data.
         """
+        if not menu:
+            raise ValueError('No context menu named: "{}"'.format(menu))
+
         import sys
         import importlib.util
 
-        full_path = os.path.abspath(data['file'])
-        base_dir, file_name = os.path.split(full_path)
-        base_name = os.path.basename(base_dir)
-        file_name, _ = file_name.split('.')
+        def build_menu_command(menu, data):
+            """
+            Create menu command from serialized data.
 
-        mod_name = '{}.{}'.format(base_name, file_name)
+            Args:
+                menu (NodeGraphQt.NodeGraphMenu or NodeGraphQt.NodesMenu):
+                    menu object.
+                data (dict): serialized menu command data.
+            """
+            full_path = os.path.abspath(data['file'])
+            base_dir, file_name = os.path.split(full_path)
+            base_name = os.path.basename(base_dir)
+            file_name, _ = file_name.split('.')
 
-        spec = importlib.util.spec_from_file_location(mod_name, full_path)
-        mod = importlib.util.module_from_spec(spec)
-        sys.modules[mod_name] = mod
-        spec.loader.exec_module(mod)
+            mod_name = '{}.{}'.format(base_name, file_name)
 
-        cmd_func = getattr(mod, data['function_name'])
-        cmd_name = data.get('label') or '<command>'
-        cmd_shortcut = data.get('shortcut')
-        menu.add_command(cmd_name, cmd_func, cmd_shortcut)
+            spec = importlib.util.spec_from_file_location(mod_name, full_path)
+            mod = importlib.util.module_from_spec(spec)
+            sys.modules[mod_name] = mod
+            spec.loader.exec_module(mod)
 
-    def _build_context_menu(self, menu, menu_data):
-        """
-        Populate context menu from a dictionary.
-
-        Args:
-            menu (NodeGraphQt.NodeGraphMenu or NodeGraphQt.NodesMenu):
-                parent context menu.
-            menu_data (list[dict] or dict): serialized menu data.
-        """
-        if not menu:
-            raise ValueError('No context menu named: "{}"'.format(menu))
+            cmd_func = getattr(mod, data['function_name'])
+            cmd_name = data.get('label') or '<command>'
+            cmd_shortcut = data.get('shortcut')
+            menu.add_command(cmd_name, cmd_func, cmd_shortcut)
 
         if isinstance(menu_data, dict):
             item_type = menu_data.get('type')
             if item_type == 'separator':
                 menu.add_separator()
             elif item_type == 'command':
-                self._build_context_menu_command(menu, menu_data)
+                build_menu_command(menu, menu_data)
             elif item_type == 'menu':
                 sub_menu = menu.add_menu(menu_data['label'])
                 items = menu_data.get('items', [])
-                self._build_context_menu(sub_menu, items)
+                self._deserialize_context_menu(sub_menu, items)
         elif isinstance(menu_data, list):
             for item_data in menu_data:
-                self._build_context_menu(menu, item_data)
+                self._deserialize_context_menu(menu, item_data)
 
     def set_context_menu(self, menu_name, data):
         """
@@ -782,7 +791,7 @@ def set_context_menu(self, menu_name, data):
             data (dict): serialized menu data.
         """
         context_menu = self.get_context_menu(menu_name)
-        self._build_context_menu(context_menu, data)
+        self._deserialize_context_menu(context_menu, data)
 
     def set_context_menu_from_file(self, file_path, menu=None):
         """
@@ -803,8 +812,7 @@ def set_context_menu_from_file(self, file_path, menu=None):
         with open(file_path) as f:
             data = json.load(f)
         context_menu = self.get_context_menu(menu)
-        self._build_context_menu(context_menu, data)
-
+        self._deserialize_context_menu(context_menu, data)
 
     def disable_context_menu(self, disabled=True, name='all'):
         """
@@ -2126,6 +2134,9 @@ def __init__(self, parent=None, node=None, node_factory=None, **kwargs):
             del self._widget
             del self._sub_graphs
 
+        # clone context menu from the parent node graph.
+        self._clone_context_menu_from_parent()
+
     def __repr__(self):
         return '<{}("{}") object at {}>'.format(
             self.__class__.__name__, self._node.name(), hex(id(self)))
@@ -2136,6 +2147,46 @@ def _register_builtin_nodes(self):
         """
         return
 
+    def _clone_context_menu_from_parent(self):
+        """
+        Clone the context menus from the parent node graph.
+        """
+        undo_regex = re.compile(r'^\&Undo(?:| \w+)')
+        redo_regex = re.compile(r'^\&Redo(?:| \w+)')
+
+        def clone_menu(menu, menu_to_clone):
+            """
+            Args:
+                menu (NodeGraphQt.NodeGraphMenu):
+                menu_to_clone (NodeGraphQt.NodeGraphMenu):
+            """
+            sub_items = []
+            for idx, item in enumerate(menu_to_clone.get_items()):
+                if item is None:
+                    menu.add_separator()
+                    continue
+                name = item.name()
+                if isinstance(item, NodeGraphMenu):
+                    sub_menu = menu.add_menu(name)
+                    sub_items.append([sub_menu, item])
+                    continue
+
+                if idx <= 1:
+                    if undo_regex.match(name) or redo_regex.match(name):
+                        continue
+                menu.add_command(
+                    name,
+                    func=item.slot_function,
+                    shortcut=item.qaction.shortcut()
+                )
+
+            for sub_menu, to_clone in sub_items:
+                clone_menu(sub_menu, to_clone)
+
+        graph_menu = self.get_context_menu('graph')
+        parent_menu = self.parent_graph.get_context_menu('graph')
+        clone_menu(graph_menu, parent_menu)
+
     def _build_port_nodes(self):
         """
         Build the corresponding input & output nodes from the parent node ports

NodeGraphQt/base/menu.py

@@ -29,6 +29,10 @@ class NodeGraphMenu(object):
     def __init__(self, graph, qmenu):
         self._graph = graph
         self._qmenu = qmenu
+        self._name = qmenu.title()
+        self._menus = {}
+        self._commands = {}
+        self._items = []
 
     def __repr__(self):
         return '<{}("{}") object at {}>'.format(
@@ -37,10 +41,10 @@ def __repr__(self):
     @property
     def qmenu(self):
         """
-        The underlying qmenu.
+        The underlying QMenu.
 
         Returns:
-            BaseMenu: qmenu object.
+            BaseMenu: menu object.
         """
         return self._qmenu
 
@@ -51,7 +55,16 @@ def name(self):
         Returns:
             str: label name.
         """
-        return self.qmenu.title()
+        return self._name
+
+    def get_items(self):
+        """
+        Return the menu items in the order they were added.
+
+        Returns:
+            list: current menu items.
+        """
+        return self._items
 
     def get_menu(self, name):
         """
@@ -63,9 +76,7 @@ def get_menu(self, name):
         Returns:
             NodeGraphQt.NodeGraphMenu: menu item.
         """
-        menu = self.qmenu.get_menu(name)
-        if menu:
-            return NodeGraphMenu(self._graph, menu)
+        self._menus.get(name)
 
     def get_command(self, name):
         """
@@ -77,28 +88,7 @@ def get_command(self, name):
         Returns:
             NodeGraphQt.MenuCommand: context menu command.
         """
-        for action in self.qmenu.actions():
-            if not action.menu() and action.text() == name:
-                return NodeGraphCommand(self._graph, action)
-
-    def all_commands(self):
-        """
-        Returns all child and sub child commands from the current context menu.
-
-        Returns:
-            list[NodeGraphQt.MenuCommand]: list of commands.
-        """
-        def get_actions(menu):
-            actions = []
-            for action in menu.actions():
-                if not action.menu():
-                    if not action.isSeparator():
-                        actions.append(action)
-                else:
-                    actions += get_actions(action.menu())
-            return actions
-        child_actions = get_actions(self.qmenu)
-        return [NodeGraphCommand(self._graph, a) for a in child_actions]
+        return self._commands.get(name)
 
     def add_menu(self, name):
         """
@@ -110,9 +100,14 @@ def add_menu(self, name):
         Returns:
             NodeGraphQt.NodeGraphMenu: the appended menu item.
         """
-        menu = BaseMenu(name, self.qmenu)
-        self.qmenu.addMenu(menu)
-        return NodeGraphMenu(self._graph, menu)
+        if name in self._menus:
+            raise NodeMenuError('menu object "{}" already exists!'.format(name))
+        base_menu = BaseMenu(name, self.qmenu)
+        self.qmenu.addMenu(base_menu)
+        menu = NodeGraphMenu(self._graph, base_menu)
+        self._menus[name] = menu
+        self._items.append(menu)
+        return menu
 
     def add_command(self, name, func=None, shortcut=None):
         """
@@ -121,7 +116,7 @@ def add_command(self, name, func=None, shortcut=None):
         Args:
             name (str): command name.
             func (function): command function eg. "func(``graph``)".
-            shortcut (str): shotcut key.
+            shortcut (str): shortcut key.
 
         Returns:
             NodeGraphQt.NodeGraphCommand: the appended command.
@@ -146,14 +141,18 @@ def add_command(self, name, func=None, shortcut=None):
             action.setShortcut(shortcut)
         if func:
             action.executed.connect(func)
-        qaction = self.qmenu.addAction(action)
-        return NodeGraphCommand(self._graph, qaction)
+        self.qmenu.addAction(action)
+        command = NodeGraphCommand(self._graph, action, func)
+        self._commands[name] = command
+        self._items.append(command)
+        return command
 
     def add_separator(self):
         """
         Adds a separator to the menu.
         """
         self.qmenu.addSeparator()
+        self._items.append(None)
 
 
 class NodesMenu(NodeGraphMenu):
@@ -222,17 +221,22 @@ def add_command(self, name, func=None, node_type=None, node_class=None):
                 menu.addAction(action)
 
         qaction = node_menu.addAction(action)
-        return NodeGraphCommand(self._graph, qaction)
+        command = NodeGraphCommand(self._graph, qaction, func)
+        self._commands[name] = command
+        self._items.append(command)
+        return command
 
 
 class NodeGraphCommand(object):
     """
     Node graph menu command.
     """
 
-    def __init__(self, graph, qaction):
+    def __init__(self, graph, qaction, func=None):
         self._graph = graph
         self._qaction = qaction
+        self._name = qaction.text()
+        self._func = func
 
     def __repr__(self):
         return '<{}("{}") object at {}>'.format(
@@ -248,14 +252,24 @@ def qaction(self):
         """
         return self._qaction
 
+    @property
+    def slot_function(self):
+        """
+        The function executed by this command.
+
+        Returns:
+            function: command function.
+        """
+        return self._func
+
     def name(self):
         """
         Returns the name for the menu command.
 
         Returns:
             str: label name.
         """
-        return self.qaction.text()
+        return self._name
 
     def set_shortcut(self, shortcut=None):
         """