add new tab search widget and upgrad the original one

Author: ArnoChenFx

NodeGraphQt/widgets/properties_bin.py

@@ -181,9 +181,7 @@ def add_node(self, node):
         Args:
             node (NodeGraphQt.NodeObject): node object.
         """
-        if self.limit() == 0:
-            return
-        if self._lock:
+        if self.limit() == 0 or self._lock:
             return
 
         itm_find = self._prop_list.findItems(node.id, QtCore.Qt.MatchExactly)

NodeGraphQt/widgets/tab_search.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python
-from NodeGraphQt import QtCore, QtWidgets
+from NodeGraphQt import QtCore, QtWidgets,QtGui
 
-from NodeGraphQt.widgets.stylesheet import STYLE_TABSEARCH, STYLE_TABSEARCH_LIST
+from NodeGraphQt.widgets.stylesheet import STYLE_TABSEARCH, STYLE_TABSEARCH_LIST, STYLE_QMENU
 
 
 class TabSearchCompleter(QtWidgets.QCompleter):
@@ -22,17 +22,20 @@ def __init__(self, nodes=None, parent=None):
     def splitPath(self, path):
         self._local_completion_prefix = path
         self.updateModel()
+
         if self._filter_model.rowCount() == 0:
             self._using_orig_model = False
-            self._filter_model.setSourceModel(QtCore.QStringListModel([path]))
-            return [path]
+            self._filter_model.setSourceModel(QtCore.QStringListModel([]))
+            return []
         return []
 
-    def updateModel(self):
+    def updateModel(self,text=None):
         if not self._using_orig_model:
             self._filter_model.setSourceModel(self._source_model)
 
-        pattern = QtCore.QRegExp(self._local_completion_prefix,
+        text = text or self._local_completion_prefix
+        print(text)
+        pattern = QtCore.QRegExp(text,
                                  QtCore.Qt.CaseInsensitive,
                                  QtCore.QRegExp.FixedString)
         self._filter_model.setFilterRegExp(pattern)
@@ -70,24 +73,35 @@ def __init__(self, parent=None, node_dict=None):
         popup.setStyleSheet(STYLE_TABSEARCH_LIST)
         popup.clicked.connect(self._on_search_submitted)
         self.returnPressed.connect(self._on_search_submitted)
+        self.textChanged.connect(self._on_text_changed)
 
     def __repr__(self):
         return '<{} at {}>'.format(self.__class__.__name__, hex(id(self)))
 
     def _on_search_submitted(self, index=0):
         node_type = self._node_dict.get(self.text())
+        if not node_type:
+            model = self._completer.popup().model()
+            text = model.data(model.index(0, 0))
+            node_type = self._node_dict.get(text)
+
         if node_type:
             self.search_submitted.emit(node_type)
+
         self.close()
         self.parentWidget().clearFocus()
 
+    def _on_text_changed(self, text):
+        if not text:
+            # TODO: show all items
+            pass
+
     def showEvent(self, event):
         super(TabSearchWidget, self).showEvent(event)
-        self.setSelection(0, len(self.text()))
         self.setFocus()
-        if not self.text():
-            self.completer().popup().show()
-            self.completer().complete()
+        self.setText("")
+        self.completer().popup().show()
+        self.completer().complete()
 
     def mousePressEvent(self, event):
         if not self.text():
@@ -104,3 +118,124 @@ def set_nodes(self, node_dict=None):
         node_names = sorted(self._node_dict.keys())
         self._model.setStringList(node_names)
         self._completer.setModel(self._model)
+
+
+class TabSearchMenuWidget(QtWidgets.QLineEdit):
+    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)
+
+        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)
+
+        self._actions = []
+        self._menus = {}
+        self._searched_actions = []
+
+        self.returnPressed.connect(self._on_search_submitted)
+        self.textChanged.connect(self._on_text_changed)
+
+    def __repr__(self):
+        return '<{} at {}>'.format(self.__class__.__name__, hex(id(self)))
+
+    def _on_text_changed(self,text):
+        self._clear_actions()
+
+        if not text:
+            self._set_menu_visible(True)
+            return
+
+        self._set_menu_visible(False)
+
+        self._searched_actions = [action for action in self._actions\
+                                 if text.lower() in action.text().lower()]
+
+        self.SearchMenu.addActions(self._searched_actions)
+
+    def _clear_actions(self):
+        for action in self._searched_actions:
+            self.SearchMenu.removeAction(action)
+        self._searched_actions = []
+
+    def _set_menu_visible(self,visible):
+        for menu in self._menus.values():
+            menu.menuAction().setVisible(visible)
+
+    def _close(self):
+        self._set_menu_visible(False)
+        self.SearchMenu.setVisible(False)
+        self.SearchMenu.menuAction().setVisible(False)
+
+    def _show(self):
+        self.SearchMenu.exec_(QtGui.QCursor.pos())
+        self.setText("")
+        self.setFocus()
+        self._set_menu_visible(True)
+
+    def _on_search_submitted(self):
+        action = self.sender()
+        if type(action) is not QtWidgets.QAction:
+            if len(self._searched_actions) > 0:
+                action = self._searched_actions[0]
+            else:
+                self._close()
+                return
+
+        text = action.text()
+        node_type = self._node_dict.get(text)
+        if node_type:
+            self.search_submitted.emit(node_type)
+
+        self._close()
+
+    def _generate_items_from_node_dict(self):
+        node_names = sorted(self._node_dict.keys())
+        node_types = sorted(self._node_dict.values())
+
+        for node_type in node_types:
+            menu_name = ".".join(node_type.split(".")[:-1])
+            if menu_name not in self._menus.keys():
+                new_menu = QtWidgets.QMenu(menu_name)
+                new_menu.setStyleSheet(STYLE_QMENU)
+                self._menus[menu_name] = new_menu
+                self.SearchMenu.addMenu(new_menu)
+
+        for name in node_names:
+            action = QtWidgets.QAction(name, self)
+            action.setText(name)
+            action.triggered.connect(self._on_search_submitted)
+            self._actions.append(action)
+
+            menu_name = self._node_dict[name]
+            menu_name = ".".join(menu_name.split(".")[:-1])
+
+            if menu_name in self._menus.keys():
+                self._menus[menu_name].addAction(action)
+            else:
+                self.SearchMenu.addAction(action)
+
+    def set_nodes(self, node_dict=None):
+        if not self._node_dict:
+            self._node_dict = {}
+            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._generate_items_from_node_dict()
+
+        self._show()
+

NodeGraphQt/widgets/viewer.py

@@ -14,7 +14,7 @@
 from NodeGraphQt.qgraphics.slicer import SlicerPipe
 from NodeGraphQt.widgets.actions import BaseMenu
 from NodeGraphQt.widgets.scene import NodeScene
-from NodeGraphQt.widgets.tab_search import TabSearchWidget
+from NodeGraphQt.widgets.tab_search import TabSearchWidget, TabSearchMenuWidget
 
 ZOOM_MIN = -0.95
 ZOOM_MAX = 2.0
@@ -73,7 +73,7 @@ def __init__(self, parent=None):
         self.scene().addItem(self._SLICER_PIPE)
 
         self._undo_stack = QtWidgets.QUndoStack(self)
-        self._search_widget = TabSearchWidget(self)
+        self._search_widget = TabSearchMenuWidget(self)
         self._search_widget.search_submitted.connect(self._on_search_submitted)
 
         # workaround fix for shortcuts from the non-native menu actions
@@ -652,6 +652,9 @@ def tab_search_set_nodes(self, nodes):
         self._search_widget.set_nodes(nodes)
 
     def tab_search_toggle(self):
+        if type(self._search_widget) is TabSearchMenuWidget:
+            return
+
         pos = self._previous_pos
         state = not self._search_widget.isVisible()
         if state: