Split into multiple files

BuiltInSearchResults.py

@@ -0,0 +1,33 @@
+# You can add your own result proviers and action/tooltip handlers, by importing this module and calling the registration functions as follows.
+# We use wrapper functions which import the actual implementation and call it, in order to avoid loading too much code during startup.
+
+import SearchResults
+
+SearchResults.registerResultProvider('refreshTools',
+                                     getItemGroupsCached   = lambda: __import__('ResultsRefreshTools').refreshToolsResultsProvider(),
+                                     getItemGroupsUncached = lambda: [])
+SearchResults.registerResultProvider('document',
+                                     getItemGroupsCached   = lambda: [],
+                                     getItemGroupsUncached = lambda: __import__('ResultsDocument').documentResultsProvider())
+SearchResults.registerResultProvider('toolbar',
+                                     getItemGroupsCached   = lambda: __import__('ResultsToolbar').toolbarResultsProvider(),
+                                     getItemGroupsUncached = lambda: [])
+
+SearchResults.registerResultHandler('refreshTools',
+                                    action  = lambda nfo:            __import__('ResultsRefreshTools').refreshToolsAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsRefreshTools').refreshToolsToolTip(nfo, setParent))
+SearchResults.registerResultHandler('toolbar',
+                                    action  = lambda nfo:            __import__('ResultsToolbar').toolbarAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsToolbar').toolbarToolTip(nfo, setParent))
+SearchResults.registerResultHandler('tool',
+                                    action  = lambda nfo           : __import__('ResultsToolbar').subToolAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsToolbar').subToolToolTip(nfo, setParent))
+SearchResults.registerResultHandler('subtool',
+                                    action  = lambda nfo           : __import__('ResultsToolbar').subToolAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsToolbar').subToolToolTip(nfo, setParent))
+SearchResults.registerResultHandler('document',
+                                    action  = lambda nfo           : __import__('ResultsDocument').documentAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsDocument').documentToolTip(nfo, setParent))
+SearchResults.registerResultHandler('documentObject',
+                                    action  = lambda nfo           : __import__('ResultsDocument').documentObjectAction(nfo),
+                                    toolTip = lambda nfo, setParent: __import__('ResultsDocument').documentObjectToolTip(nfo, setParent))

GetItemGroups.py

@@ -0,0 +1,57 @@
+globalGroups = []
+
+itemGroups = None
+serializedItemGroups = None
+
+def onResultSelected(index, groupId):
+  global globalGroups
+  nfo = globalGroups[groupId]
+  handlerName = nfo['action']['handler']
+  import SearchResults
+  if handlerName in SearchResults.actionHandlers:
+    SearchResults.actionHandlers[handlerName](nfo)
+  else:
+    from PySide import QtGui
+    QtGui.QMessageBox.warning(None, 'Could not execute this action', 'Could not execute this action, it could be from a Mod that has been uninstalled. Try refreshing the list of tools.')
+
+def getToolTip(groupId, setParent):
+  global globalGroups
+  nfo = globalGroups[int(groupId)]
+  handlerName = nfo['action']['handler']
+  import SearchResults
+  if handlerName in SearchResults.toolTipHandlers:
+    return SearchResults.toolTipHandlers[handlerName](nfo, setParent)
+  else:
+    return 'Could not load tooltip for this tool, it could be from a Mod that has been uninstalled. Try refreshing the list of tools.'
+
+def getItemGroups():
+  global itemGroups, serializedItemGroups, globalGroups
+  
+  # Import the tooltip+action handlers and search result providers that are bundled with this Mod.
+  # Other providers should import SearchResults and register their handlers and providers
+  import BuiltInSearchResults
+
+  # Load the list of tools, preferably from the cache, if it has not already been loaded:
+  if itemGroups is None:
+    if serializedItemGroups is None:
+      import RefreshTools
+      itemGroups = RefreshTools.refreshToolbars(doLoadAllWorkbenches = False)
+    else:
+      import Serialize
+      itemGroups = Serialize.deserialize(serializedItemGroups)
+
+  # Aggregate the tools (cached) and document objects (not cached), and assign an index to each
+  import SearchResults
+  igs = itemGroups
+  for providerName, provider in SearchResults.resultProvidersUncached.items():
+    igs = igs + provider()
+  globalGroups = []
+  def addId(group):
+    globalGroups.append(group)
+    group['id'] = len(globalGroups) - 1
+    for subitem in group['subitems']:
+      addId(subitem)
+  for ig in igs:
+    addId(ig)
+  
+  return igs

IndentedItemDelegate.py

@@ -0,0 +1,12 @@
+from PySide import QtGui
+
+# Inspired by https://stackoverflow.com/a/5443220/324969
+# Inspired by https://forum.qt.io/topic/69807/qtreeview-indent-entire-row
+class IndentedItemDelegate(QtGui.QStyledItemDelegate):
+  def __init__(self):
+    super(IndentedItemDelegate, self).__init__()
+  def paint(self, painter, option, index):
+    depth = int(option.widget.model().itemData(index.siblingAtColumn(1))[0])
+    indent = 16 * depth
+    option.rect.adjust(indent, 0, 0, 0)
+    super(IndentedItemDelegate, self).paint(painter, option, index)

InitGui.py

@@ -1 +1,27 @@
-import SearchTools
+# Avoid garbage collection by storing the action in a global variable
+wax = None
+
+def addToolSearchBox():
+  import FreeCADGui
+  from PySide import QtGui
+  import SearchBox
+  global wax, sea
+  mw = FreeCADGui.getMainWindow()
+  mbr = mw.findChildren(QtGui.QToolBar, 'File')
+  # The toolbar will be unavailable if this file is loaded during startup, because no workbench is active and no toolbars are visible.
+  if len(mbr) > 0:
+    # Get the first toolbar named 'File', and add 
+    mbr = mbr[0]
+    # Create search box widget
+    sea = SearchBox.SearchBox(getItemGroups   = lambda: __import__('GetItemGroups').getItemGroups(),
+                              getToolTip      = lambda groupId, setParent: __import__('GetItemGroups').getToolTip(groupId, setParent),
+                              getItemDelegate = lambda: __import__('IndentedItemDelegate').IndentedItemDelegate())
+    sea.resultSelected.connect(lambda index, groupId: __import__('GetItemGroups').onResultSelected(index, groupId))
+    wax = QtGui.QWidgetAction(None)
+    wax.setDefaultWidget(sea)
+    #mbr.addWidget(sea)
+    mbr.addAction(wax)
+
+addToolSearchBox()
+import FreeCADGui
+FreeCADGui.getMainWindow().workbenchActivated.connect(addToolSearchBox)

RefreshTools.py

@@ -0,0 +1,81 @@
+import os
+import FreeCAD as App
+
+def loadAllWorkbenches():
+  from PySide import QtGui
+  import FreeCADGui
+  activeWorkbench = FreeCADGui.activeWorkbench().name()
+  lbl = QtGui.QLabel('Loading workbench … (…/…)')
+  lbl.show()
+  lst = FreeCADGui.listWorkbenches()
+  for i, wb in enumerate(lst):
+    msg = 'Loading workbench ' + wb + ' (' + str(i) + '/' + str(len(lst)) + ')'
+    print(msg)
+    lbl.setText(msg)
+    geo = lbl.geometry()
+    geo.setSize(lbl.sizeHint())
+    lbl.setGeometry(geo)
+    lbl.repaint()
+    FreeCADGui.updateGui() # Probably slower with this, because it redraws the entire GUI with all tool buttons changed etc. but allows the label to actually be updated, and it looks nice and gives a quick overview of all the workbenches…
+    try:
+      FreeCADGui.activateWorkbench(wb)
+    except:
+      pass
+  lbl.hide()
+  FreeCADGui.activateWorkbench(activeWorkbench)
+
+def cachePath():
+  return os.path.join(App.getUserAppDataDir(), 'Cache_SearchToolsMod')
+
+def gatherTools():
+  itemGroups = []
+  import SearchResults
+  for providerName, provider in SearchResults.resultProvidersCached.items():
+    itemGroups = itemGroups + provider()
+  return itemGroups
+
+def writeCacheTools():
+  import Serialize
+  serializedItemGroups = Serialize.serialize(gatherTools())
+  # Todo: use wb and a specific encoding.
+  with open(cachePath(), 'w') as cache:
+    cache.write(serializedItemGroups)
+  # I prefer to systematically deserialize, instead of taking the original version,
+  # this avoids possible inconsistencies between the original and the cache and
+  # makes sure cache-related bugs are noticed quickly.
+  import Serialize
+  itemGroups = Serialize.deserialize(serializedItemGroups)
+  print('SearchBox: Cache has been written.')
+  return itemGroups
+
+def readCacheTools():
+  # Todo: use rb and a specific encoding.
+  with open(cachePath(), 'r') as cache:
+    serializedItemGroups = cache.read()
+  import Serialize
+  itemGroups = Serialize.deserialize(serializedItemGroups)
+  print('SearchBox: Tools were loaded from the cache.')
+  return itemGroups
+
+
+def refreshToolbars(doLoadAllWorkbenches = True):
+  if doLoadAllWorkbenches:
+    loadAllWorkbenches()
+    return writeCacheTools()
+  else:
+    try:
+      return readCacheTools()
+    except:
+      return writeCacheTools()
+
+def refreshToolsAction():
+  from PySide import QtGui
+  print('Refresh list of tools')
+  fw = QtGui.QApplication.focusWidget()
+  if fw is not None:
+    fw.clearFocus()
+  reply = QtGui.QMessageBox.question(None, "Load all workbenches?", "Load all workbenches? This can cause FreeCAD to become unstable, and this \"reload tools\" feature contained a bug that crashed freecad systematically, so please make sure you save your work before. It's a good idea to restart FreeCAD after this operation.", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
+  if reply == QtGui.QMessageBox.Yes:
+    refreshToolbars()
+  else:
+    print('cancelled')

ResultsDocument.py

@@ -0,0 +1,118 @@
+from PySide import QtGui
+from PySide import QtCore
+import FreeCAD as App
+import FreeCADGui
+import SafeViewer
+import SearchBox
+
+def documentAction(nfo):
+  act = nfo['action']
+    # Todo: this should also select the document in the tree view
+  print('switch to document ' + act['document'])
+  App.setActiveDocument(act['document'])
+
+def documentObjectAction(nfo):
+  act = nfo['action']
+  print('select object ' + act['document'] + '.' + act['object'])
+  FreeCADGui.Selection.addSelection(act['document'], act['object'])
+
+# For some reason, the viewer always works except when used for two consecutive items in the search results: it then disappears after a short zoom-in+zoom-out animation.
+# I'm giving up on getting this viewer to work in a clean way, and will try swapping two instances so that the same one is never used twice in a row.
+# Also, in order to avoid segfaults when the module is reloaded (which causes the previous viewer to be garbage collected at some point), we're using a global property that will survive module reloads.
+if not hasattr(App, '_SearchTools3DViewer'):
+  # Toggle between 
+  App._SearchTools3DViewer = None
+  App._SearchTools3DViewerB = None
+
+class DocumentObjectToolTipWidget(QtGui.QWidget):
+  def __init__(self, nfo, setParent):
+    import pivy
+    super(DocumentObjectToolTipWidget, self).__init__()
+    html = '<p>' + nfo['toolTip']['label'] + '</p><p><code>App.getDocument(' + repr(str(nfo['toolTip']['docName'])) + ').getObject(' + repr(str(nfo['toolTip']['name'])) + ')</code></p>'
+    description = QtGui.QTextEdit()
+    description.setReadOnly(True)
+    description.setAlignment(QtCore.Qt.AlignTop)
+    description.setText(html)
+
+    if App._SearchTools3DViewer is None:
+      oldFocus = QtGui.QApplication.focusWidget()
+      SearchBox.globalIgnoreFocusOut
+      SearchBox.globalIgnoreFocusOut = True
+      App._SearchTools3DViewer = SafeViewer.SafeViewer()
+      App._SearchTools3DViewerB = SafeViewer.SafeViewer()
+      oldFocus.setFocus()
+      SearchBox.globalIgnoreFocusOut = False
+      # Tried setting the preview to a fixed size to prevent it from disappearing when changing its contents, this sets it to a fixed size but doesn't actually pick the size, .resize does that but isn't enough to fix the bug.
+      #safeViewerInstance.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed))
+    self.preview = App._SearchTools3DViewer
+    App._SearchTools3DViewer, App._SearchTools3DViewerB = App._SearchTools3DViewerB, App._SearchTools3DViewer
+
+    obj = App.getDocument(str(nfo['toolTip']['docName'])).getObject(str(nfo['toolTip']['name']))
+
+    # This is really a bad way to do this… to prevent the setExtraInfo function from
+    # finalizing the object, we remove the parent ourselves.
+    oldParent = self.preview.parent()
+    lay = QtGui.QVBoxLayout()
+    lay.setContentsMargins(0,0,0,0)
+    lay.setSpacing(0)
+    self.setLayout(lay)
+    lay.addWidget(description)
+    lay.addWidget(self.preview)
+    #if oldParent is not None:
+    #  oldParent.hide() # hide before detaching, or we have widgets floating as their own window that appear for a split second in some cases.
+    #  oldParent.setParent(None)
+  
+    # Tried hiding/detaching the preview to prevent it from disappearing when changing its contents
+    #self.preview.viewer.stopAnimating()
+    self.preview.viewer.getViewer().setSceneGraph(obj.ViewObject.RootNode)
+    self.preview.viewer.setCameraOrientation(App.Rotation(1,1,0, 0.2))
+    self.preview.viewer.fitAll()
+
+    setParent(self)
+    # Let the GUI recompute the side of the description based on its horizontal size.
+    FreeCADGui.updateGui()
+    siz = description.document().size().toSize()
+    description.setFixedHeight(siz.height() + 5)
+
+  def finalizer(self):
+    #self.preview.finalizer()
+    # Detach the widget so that it may be reused without getting deleted
+    self.preview.setParent(None)
+
+def documentToolTip(nfo, setParent):
+  return '<p>' + nfo['toolTip']['label'] + '</p><p><code>App.getDocument(' + repr(str(nfo['toolTip']['name'])) + ')</code></p><p><img src="data:image/png;base64,.............."></p>'
+
+def documentObjectToolTip(nfo, setParent):
+  return DocumentObjectToolTipWidget(nfo, setParent)
+
+def documentResultsProvider():
+  itemGroups = []
+  def document(doc):
+    group = []
+    for o in doc.Objects:
+      #all_actions.append(lambda: )
+      action = { 'handler': 'documentObject', 'document': o.Document.Name, 'object': o.Name }
+      item = {
+        'icon': o.ViewObject.Icon if o.ViewObject and o.ViewObject.Icon else None,
+        'text': o.Label + ' (' + o.Name + ')',
+        # TODO: preview of the object
+        'toolTip': { 'label': o.Label, 'name': o.Name, 'docName': o.Document.Name},
+        'action': action,
+        'subitems': []
+      }
+      group.append(item)
+
+    action = { 'handler': 'document', 'document': doc.Name }
+    itemGroups.append({
+      'icon': QtGui.QIcon(':/icons/Document.svg'),
+      'text': doc.Label + ' (' + doc.Name + ')',
+      # TODO: preview of the document
+      'toolTip': { 'label': doc.Label, 'name': doc.Name},
+      'action':action,
+      'subitems': group })
+  if App.ActiveDocument:
+    document(App.ActiveDocument)
+  for docname, doc in App.listDocuments().items():
+    if not App.activeDocument or docname != App.ActiveDocument.Name:
+      document(doc)
+  return itemGroups

ResultsRefreshTools.py

@@ -0,0 +1,22 @@
+import os
+from PySide import QtGui
+import Serialize
+
+def refreshToolsAction(nfo):
+  import RefreshTools
+  RefreshTools.refreshToolsAction()
+
+def refreshToolsToolTip(nfo, setParent):
+  return Serialize.iconToHTML(genericToolIcon) + '<p>Load all workbenches to refresh this list of tools. This may take a minute, depending on the number of installed workbenches.</p>'
+
+genericToolIcon = QtGui.QIcon(QtGui.QIcon(os.path.dirname(__file__) + '/Tango-Tools-spanner-hammer.svg'))
+def refreshToolsResultsProvider():
+  return [
+    {
+      'icon': genericToolIcon,
+      'text': 'Refresh list of tools',
+      'toolTip': '',
+      'action': {'handler': 'refreshTools'},
+      'subitems': []
+    }
+  ]

ResultsToolbar.py

@@ -0,0 +1,103 @@
+from PySide import QtGui
+import FreeCADGui
+import Serialize
+
+def toolbarAction(nfo):
+  act = nfo['action']
+  print('show toolbar ' + act['toolbar'] + ' from workbenches ' + repr(act['workbenches']))
+
+def subToolAction(nfo):
+  act = nfo['action']
+  toolPath = act['toolbar'] + '.' + act['tool']
+  if 'subTool' in act:
+    toolPath = toolPath + '.' + act['subTool']
+  def runTool():
+    mw = FreeCADGui.getMainWindow()
+    for the_toolbar in mw.findChildren(QtGui.QToolBar, act['toolbar']):
+      for tbt in the_toolbar.findChildren(QtGui.QToolButton):
+        if tbt.text() == act['tool']:
+          action = None
+          if 'subTool' in act:
+            men = tbt.menu()
+            if men:
+              for mac in men.actions():
+                if mac.text() == act['subTool']:
+                  action = mac
+                  break
+          else:
+            action = tbt.defaultAction()
+          if 'showMenu' in act and act['showMenu']:
+            print('Popup submenu of tool ' + toolPath + ' available in workbenches ' + repr(act['workbenches']))
+            the_toolbar.show()
+            tbt.showMenu()
+            return True
+          elif action is not None:
+            print('Run action of tool ' + toolPath + ' available in workbenches ' + repr(act['workbenches']))
+            action.trigger()
+            return True
+    return False
+  if runTool():
+    return
+  else:
+    for workbench in act['workbenches']:
+      print('Activating workbench ' + workbench + ' to access tool ' + toolPath)
+      FreeCADGui.activateWorkbench(workbench)
+      if runTool():
+        return
+  print('Tool ' + toolPath + ' not found, was it offered by an extension that is no longer present?')
+
+def toolbarToolTip(nfo, setParent):
+  return '<p>Display toolbar ' + nfo['toolTip'] + '</p><p>This toolbar appears in the following workbenches: <ul>' + ''.join(['<li>' + Serialize.iconToHTML(QtGui.QIcon(FreeCADGui.listWorkbenches()[wb].Icon)) + wb + '</li>' for wb in nfo['action']['workbenches']]) + '</ul></p>'
+
+def subToolToolTip(nfo, setParent):
+  return Serialize.iconToHTML(nfo['icon'], 32) + '<p>' + nfo['toolTip'] + '</p>'
+
+def getAllToolbars():
+  all_tbs = dict()
+  for wbname, workbench in FreeCADGui.listWorkbenches().items():
+    try:
+      tbs = workbench.listToolbars()
+    except:
+      continue
+    # careful, tbs contains all the toolbars of the workbench, including shared toolbars
+    for tb in tbs:
+      if tb not in all_tbs:
+        all_tbs[tb] = set()
+      all_tbs[tb].add(wbname)
+  return all_tbs
+
+def toolbarResultsProvider():
+  itemGroups = []
+  all_tbs = getAllToolbars()
+  mw = FreeCADGui.getMainWindow()
+  for toolbarName, toolbarIsInWorkbenches in all_tbs.items():
+    toolbarIsInWorkbenches = sorted(list(toolbarIsInWorkbenches))
+    for the_toolbar in mw.findChildren(QtGui.QToolBar, toolbarName):
+      group = []
+      for tbt in the_toolbar.findChildren(QtGui.QToolButton):
+        text = tbt.text()
+        act = tbt.defaultAction()
+        if text != '':
+            # TODO: there also is the tooltip
+            icon = tbt.icon()
+            men = tbt.menu()
+            subgroup = []
+            if men:
+              subgroup = []
+              for mac in men.actions():
+                if mac.text():
+                  action = { 'handler': 'subTool', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName, 'tool': text, 'subTool': mac.text() }
+                  subgroup.append({'icon':mac.icon(), 'text':mac.text(), 'toolTip': mac.toolTip(), 'action':action, 'subitems':[]})
+            # The default action of a menu changes dynamically, instead of triggering the last action, just show the menu.
+            action = { 'handler': 'tool', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName, 'tool': text, 'showMenu': bool(men) }
+            group.append({'icon':icon, 'text':text, 'toolTip': tbt.toolTip(), 'action': action, 'subitems': subgroup})
+      # TODO: move the 'workbenches' field to the itemgroup
+      action = { 'handler': 'toolbar', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName }
+      itemGroups.append({
+        'icon': QtGui.QIcon(':/icons/Group.svg'),
+        'text': toolbarName,
+        'toolTip': '',
+        'action': action,
+        'subitems': group
+      })
+  return itemGroups

SafeViewer.py

@@ -0,0 +1,71 @@
+from PySide import QtGui
+
+class SafeViewer(QtGui.QWidget):
+  """FreeCAD uses a modified version of QuarterWidget, so the import pivy.quarter one will cause segfaults.
+     FreeCAD's FreeCADGui.createViewer() puts the viewer widget inside an MDI window, and detaching it without causing segfaults on exit is tricky.
+     This class contains some kludges to extract the viewer as a standalone widget and destroy it safely."""
+  def __init__(self, parent = None):
+    super(SafeViewer, self).__init__()
+    import FreeCADGui
+    self.viewer = FreeCADGui.createViewer()
+    self.graphicsView = self.viewer.graphicsView()
+    self.oldGraphicsViewParent = self.graphicsView.parent()
+    self.oldGraphicsViewParentParent = self.oldGraphicsViewParent.parent()
+    self.oldGraphicsViewParentParentParent = self.oldGraphicsViewParentParent.parent()
+
+    # Avoid segfault but still hide the undesired window by moving it to a new hidden MDI area.
+    self.hiddenQMDIArea = QtGui.QMdiArea()
+    self.hiddenQMDIArea.addSubWindow(self.oldGraphicsViewParentParentParent)
+
+    self.private_widget = self.oldGraphicsViewParent
+    self.private_widget.setParent(parent)
+
+    self.setLayout(QtGui.QVBoxLayout())
+    self.layout().addWidget(self.private_widget)
+    self.layout().setContentsMargins(0,0,0,0)
+
+    def fin(slf):
+      slf.finalizer()
+
+    import weakref
+    weakref.finalize(self, fin, self)
+
+    self.destroyed.connect(self.finalizer)
+
+  def finalizer(self):
+    # Cleanup in an order that doesn't cause a segfault:
+    self.private_widget.setParent(self.oldGraphicsViewParentParent)
+    self.oldGraphicsViewParentParentParent.close()
+    self.oldGraphicsViewParentParentParent = None
+    self.oldGraphicsViewParentParent = None
+    self.oldGraphicsViewParent = None
+    self.graphicsView = None
+    self.viewer = None
+    #self.parent = None
+    self.hiddenQMDIArea = None
+
+"""
+# Example use:
+from PySide import QtGui
+import pivy
+def mk(v):
+  w = QtGui.QMainWindow()
+  oldFocus = QtGui.QApplication.focusWidget()
+  sv.widget.setParent(w)
+  oldFocus.setFocus()
+  w.show()
+  col = pivy.coin.SoBaseColor()
+  col.rgb = (1, 0, 0)
+  trans = pivy.coin.SoTranslation()
+  trans.translation.setValue([0, 0, 0])
+  cub = pivy.coin.SoCube()
+  myCustomNode = pivy.coin.SoSeparator()
+  myCustomNode.addChild(col)
+  myCustomNode.addChild(trans)
+  myCustomNode.addChild(cub)
+  sv.viewer.getViewer().setSceneGraph(myCustomNode)
+  sv.viewer.fitAll()
+  return w
+sv = SafeViewer()
+ww=mk(sv)
+"""

SearchBox.py

@@ -1,109 +1,269 @@
-if True:
+import os
-    from PySide import QtGui
+from PySide import QtGui
-    class SearchBox(QtGui.QLineEdit):
+from PySide import QtCore
-        def __init__(self, model, maxVisibleRows, parent):
+
-            # Call parent cosntructor
+globalIgnoreFocusOut = False
-            super(SearchBox, self).__init__(parent)
+
-            # Save arguments
+genericToolIcon = QtGui.QIcon(QtGui.QIcon(os.path.dirname(__file__) + '/Tango-Tools-spanner-hammer.svg'))
-            self.model = model
+
-            self.maxVisibleRows = maxVisibleRows
+def easyToolTipWidget(html):
-            # Create list view
+  foo = QtGui.QTextEdit()
-            self.listView = QtGui.QListView(self)
+  foo.setReadOnly(True)
-            self.listView.setWindowFlags(QtGui.Qt.ToolTip)
+  foo.setAlignment(QtCore.Qt.AlignTop)
-            self.listView.setWindowFlag(QtGui.Qt.FramelessWindowHint)
+  foo.setText(html)
-            self.listView.setModel(self.model)
+  return foo
-            # make the QListView non-editable
+
-            self.listView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
+class SearchBox(QtGui.QLineEdit):
-            # Connect signals and slots
+  resultSelected = QtCore.Signal(int, int)
-            self.textChanged.connect(self.filterList)
+  def __init__(self, getItemGroups, getToolTip, getItemDelegate, maxVisibleRows = 20, parent = None):
-            self.listView.clicked.connect(self.selectResult)
+    # Call parent cosntructor
-            self.listView.selectionModel().selectionChanged.connect(self.showExtraInfo)
+    super(SearchBox, self).__init__(parent)
-        def focusInEvent(self, qFocusEvent):
+    # Save arguments
-            self.showList()
+    #self.model = model
-            super(SearchBox, self).focusInEvent(qFocusEvent)
+    self.getItemGroups = getItemGroups
-        def focusOutEvent(self, qFocusEvent):
+    self.getToolTip = getToolTip
-            self.listView.hide()
+    self.itemGroups = None # Will be initialized by calling getItemGroups() the first time the search box gains focus, through focusInEvent and refreshItemGroups
-            super(SearchBox, self).focusOutEvent(qFocusEvent)
+    self.maxVisibleRows = maxVisibleRows # TODO: use this to compute the correct height
-        def keyPressEvent(self, qKeyEvent):
+    # Create proxy model
-            key = qKeyEvent.key()
+    self.proxyModel = QtCore.QIdentityProxyModel()
-            listMovementKeys = {
+    # Filtered model to which items are manually added. Store it as a property of the object instead of a local variable, to prevent grbage collection.
-                QtCore.Qt.Key_Down:     lambda current, nbRows: (current + 1) % nbRows,
+    self.mdl = QtGui.QStandardItemModel()
-                QtCore.Qt.Key_Up:       lambda current, nbRows: (current - 1) % nbRows,
+    #self.proxyModel.setModel(self.model)
-                QtCore.Qt.Key_PageDown: lambda current, nbRows: max(current + min(1, self.maxVisibleRows / 2), nbRows),
+    # Create list view
-                QtCore.Qt.Key_PageUp:   lambda current, nbRows: min(current - min(1, self.maxVisibleRows / 2), 0),
+    self.listView = QtGui.QListView(self)
-            }
+    self.listView.setWindowFlags(QtGui.Qt.ToolTip)
-            acceptKeys = {
+    self.listView.setWindowFlag(QtGui.Qt.FramelessWindowHint)
-                QtCore.Qt.Key_Enter:  'select',
+    self.listView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
-                QtCore.Qt.Key_Return: 'select',
+    self.listView.setModel(self.proxyModel)
-                # space on a toolbar/category should toggle the entire category in the search results
+    self.listView.setItemDelegate(getItemDelegate()) # https://stackoverflow.com/a/65930408/324969
-                QtCore.Qt.Key_Space:  'toggle',
+    # make the QListView non-editable
-            }
+    self.listView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
-            cancelKeys = {
+    # Create pane for showing extra info about the currently-selected tool
-                QtCore.Qt.Key_Escape: True,
+    #self.extraInfo = QtGui.QLabel()
-            }
+    self.extraInfo = QtGui.QWidget()
-            
+    self.extraInfo.setWindowFlags(QtGui.Qt.ToolTip)
-            currentIndex = self.listView.currentIndex()
+    self.extraInfo.setWindowFlag(QtGui.Qt.FramelessWindowHint)
-            if key in listMovementKeys:
+    self.extraInfo.setLayout(QtGui.QVBoxLayout())
-                self.showList()
+    self.extraInfo.layout().setContentsMargins(0,0,0,0)
-                if self.listView.isEnabled():
+    self.setExtraInfoIsActive = False
-                    currentRow = currentIndex.row()
+    self.pendingExtraInfo = None
-                    nbRows = self.listView.model().rowCount()
+    # Connect signals and slots
-                    newRow = listMovementKeys[key](currentRow, nbRows)
+    self.textChanged.connect(self.filterModel)
-                    index = self.listView.model().index(newRow, 0)
+    self.listView.clicked.connect(lambda x: self.selectResult('select', x))
-                    self.listView.setCurrentIndex(index)
+    self.listView.selectionModel().selectionChanged.connect(self.onSelectionChanged)
-            elif key in acceptKeys:
+    # Thanks to https://saurabhg.com/programming/search-box-using-qlineedit/ for indicating a few useful options
-                self.showList()
+    ico = QtGui.QIcon(':/icons/help-browser.svg')
-                if currentIndex.isValid():
+    #ico = QtGui.QIcon(':/icons/WhatsThis.svg')
-                    self.selectResult(acceptKeys[key], currentIndex, currentIndex.data())
+    self.addAction(ico, QtGui.QLineEdit.LeadingPosition)
-            elif key in cancelKeys:
+    self.setClearButtonEnabled(True)
-                self.listView.hide()
+    self.setPlaceholderText('Search tools, prefs & tree')
-                self.clearFocus()
+    self.setFixedWidth(200) # needed to avoid a change of width when the clear button appears/disappears
-            else:
+    # Initialize the model with the full list (assuming the text() is empty)
-                self.showList()
+    #self.filterModel(self.text()) # This is done by refreshItemGroups on focusInEvent, because the initial loading from cache can take time
-                super(SearchBox, self).keyPressEvent(qKeyEvent)
+  def refreshItemGroups(self):
-        def showList(self):
+    self.itemGroups = self.getItemGroups()
-            def getScreenPosition(widget):
+    self.filterModel(self.text())
-                geo = widget.geometry()
+  def focusInEvent(self, qFocusEvent):
-                print(geo)
+    global globalIgnoreFocusOut
-                parent = widget.parent()
+    if not globalIgnoreFocusOut:
-                parentPos = getScreenPosition(parent) if parent is not None else QtCore.QPoint(0,0)
+      self.refreshItemGroups()
-                return QtCore.QPoint(geo.x() + parentPos.x(), geo.y() + parentPos.y())
+    self.showList()
-            pos = getScreenPosition(self)
+    super(SearchBox, self).focusInEvent(qFocusEvent)
-            siz = self.size()
+  def focusOutEvent(self, qFocusEvent):
-            screen = QtGui.QGuiApplication.screenAt(pos)
+    global globalIgnoreFocusOut
-            print(pos, siz, screen)
+    if not globalIgnoreFocusOut:
-            x = pos.x()
+      self.hideList()
-            y = pos.y() + siz.height()
+      super(SearchBox, self).focusOutEvent(qFocusEvent)
-            hint_w = self.listView.sizeHint().width()
+  def keyPressEvent(self, qKeyEvent):
-            # TODO: this can still bump into the bottom of the screen, in that case we should flip
+    key = qKeyEvent.key()
-            w = max(siz.width(), hint_w)
+    listMovementKeys = {
-            h = 100
+      QtCore.Qt.Key_Down:     lambda current, nbRows: (current + 1) % nbRows,
-            if screen is not None:
+      QtCore.Qt.Key_Up:       lambda current, nbRows: (current - 1) % nbRows,
-                scr = screen.geometry()
+      QtCore.Qt.Key_PageDown: lambda current, nbRows: min(current + max(1, self.maxVisibleRows / 2), nbRows - 1),
-                x = min(scr.x() + scr.width() - hint_w, x)
+      QtCore.Qt.Key_PageUp:   lambda current, nbRows: max(current - max(1, self.maxVisibleRows / 2), 0),
-            self.listView.setGeometry(x, y, w, h)
+      QtCore.Qt.Key_Home:     lambda current, nbRows: 0,
-            self.listView.show()
+      QtCore.Qt.Key_End:      lambda current, nbRows: nbRows - 1,
-        def selectResult(self):
+    }
-            self.listView.hide()
+    acceptKeys = {
-            # TODO: allow other options, e.g. some items could act as combinators / cumulative filters
+      QtCore.Qt.Key_Enter:  'select',
-            self.setText('')
+      QtCore.Qt.Key_Return: 'select',
-            self.filterList(self.text())
+      # space on a toolbar/category should toggle the entire category in the search results
-        def filterList(self, query):
+      QtCore.Qt.Key_Space:  'toggle',
-            print('TODO: do the actual filtering')
+    }
-            flt = QtCore.QSortFilterProxyModel()
+    cancelKeys = {
-            flt.setSourceModel(self.model)
+      QtCore.Qt.Key_Escape: True,
-            flt.setFilterCaseSensitivity(QtCore.Qt.CaseSensitivity.CaseInsensitive)
+    }
-            flt.setFilterWildcard(query)
+    
-            self.listView.setModel(flt)
+    currentIndex = self.listView.currentIndex()
-            # TODO: try to find the already-highlighted item
+    if key in listMovementKeys:
-            nbRows = self.listView.model().rowCount()
+      self.showList()
-            if nbRows > 0:
+      if self.listView.isEnabled():
-                index = self.listView.model().index(0, 0)
+          currentRow = currentIndex.row()
-                self.listView.setCurrentIndex(index)
+          nbRows = self.listView.model().rowCount()
-            #self.showList()
+          if nbRows > 0:
-        def showExtraInfo(selected, deselected):
+            newRow = listMovementKeys[key](currentRow, nbRows)
-            print('show extra info...')
+            index = self.listView.model().index(newRow, 0)
-            pass
+            self.listView.setCurrentIndex(index)
-    mdl = QtCore.QStringListModel(['aaa', 'aab', 'aac', 'bxy', 'bac'])
+    elif key in acceptKeys:
-    sbx = SearchBox(mdl, 10, None)
+      self.showList()
-    sbx.show()
+      if currentIndex.isValid():
+          self.selectResult(acceptKeys[key], currentIndex)
+    elif key in cancelKeys:
+      self.hideList()
+      self.clearFocus()
+    else:
+      self.showList()
+      super(SearchBox, self).keyPressEvent(qKeyEvent)
+  def showList(self):
+    self.setFloatingWidgetsGeometry()
+    if not self.listView.isVisible():
+      self.listView.show()
+    self.showExtraInfo()
+  def hideList(self):
+    self.listView.hide()
+    self.hideExtraInfo()
+  def hideExtraInfo(self):
+    self.extraInfo.hide()
+  def selectResult(self, mode, index):
+    groupIdx = int(index.model().itemData(index.siblingAtColumn(2))[0])
+    self.hideList()
+    # TODO: allow other options, e.g. some items could act as combinators / cumulative filters
+    self.setText('')
+    self.filterModel(self.text())
+    # TODO: emit index relative to the base model
+    self.resultSelected.emit(index, groupIdx)
+  def filterModel(self, userInput):
+    # TODO: this will cause a race condition if it is accessed while being modified
+    def matches(s):
+      return userInput.lower() in s.lower()
+    def filterGroup(group):
+      if matches(group['text']):
+        # If a group matches, include the entire subtree (might need to disable this if it causes too much noise)
+        return group
+      else:
+        subitems = filterGroups(group['subitems'])
+        if len(subitems) > 0 or matches(group['text']):
+          return { 'id': group['id'], 'text': group['text'], 'icon': group['icon'], 'action': group['action'], 'toolTip':group['toolTip'], 'subitems': subitems }
+        else:
+          return None
+    def filterGroups(groups):
+      groups = (filterGroup(group) for group in groups)
+      return [group for group in groups if group is not None]
+    self.mdl = QtGui.QStandardItemModel()
+    self.mdl.appendColumn([])
+    def addGroups(filteredGroups, depth=0):
+      for group in filteredGroups:
+        # TODO: this is not very clean, we should memorize the index from the original itemgroups
+        self.mdl.appendRow([QtGui.QStandardItem(group['icon'] or genericToolIcon, group['text']),
+                            QtGui.QStandardItem(str(depth)),
+                            QtGui.QStandardItem(str(group['id']))])
+        addGroups(group['subitems'], depth+1)
+    addGroups(filterGroups(self.itemGroups))
+    self.proxyModel.setSourceModel(self.mdl)
+    # TODO: try to find the already-highlighted item
+    nbRows = self.listView.model().rowCount()
+    if nbRows > 0:
+      index = self.listView.model().index(0, 0)
+      self.listView.setCurrentIndex(index)
+      self.setExtraInfo(index)
+    else:
+      self.clearExtraInfo()
+    #self.showList()
+  def setFloatingWidgetsGeometry(self):
+    def getScreenPosition(widget):
+      geo = widget.geometry()
+      parent = widget.parent()
+      parentPos = getScreenPosition(parent) if parent is not None else QtCore.QPoint(0,0)
+      return QtCore.QPoint(geo.x() + parentPos.x(), geo.y() + parentPos.y())
+    pos = getScreenPosition(self)
+    siz = self.size()
+    screen = QtGui.QGuiApplication.screenAt(pos)
+    x = pos.x()
+    y = pos.y() + siz.height()
+    hint_w = self.listView.sizeHint().width()
+    # TODO: this can still bump into the bottom of the screen, in that case we should flip
+    w = max(siz.width(), hint_w)
+    h = 200 # TODO: set height / size here according to desired number of items
+    extraw = w # choose a preferred width that doesn't change all the time,
+                # self.extraInfo.sizeHint().width() would change for every item.
+    extrax = x - extraw
+    if screen is not None:
+      scr = screen.geometry()
+      x = min(scr.x() + scr.width() - hint_w, x)
+      extraleftw = x - scr.x()
+      extrarightw = scr.x() + scr.width() - x
+      # flip the extraInfo if it doesn't fit on the screen
+      if extraleftw < extraw and extrarightw > extraleftw:
+        extrax = x + w
+        extraw = min(extrarightw, extraw)
+      else:
+        extrax = x - extraw
+        extraw = min(extraleftw, extraw)
+    self.listView.setGeometry(x, y, w, h)
+    self.extraInfo.setGeometry(extrax, y, extraw, h)
+  def onSelectionChanged(self, selected, deselected):
+    # The list has .setSelectionMode(QtGui.QAbstractItemView.SingleSelection),
+    # so there is always at most one index in selected.indexes() and at most one
+    # index in deselected.indexes()
+    selected = selected.indexes()
+    deselected = deselected.indexes()
+    if len(selected) > 0:
+      index = selected[0]
+      self.setExtraInfo(index)
+      # Poor attempt to circumvent a glitch where the extra info pane stays visible after pressing Return
+      if not self.listView.isHidden():
+        self.showExtraInfo()
+    elif len(deselected) > 0:
+      self.hideExtraInfo()
+  def setExtraInfo(self, index):
+    # TODO: use an atomic swap or mutex if possible
+    if self.setExtraInfoIsActive:
+      self.pendingExtraInfo = index
+      #print("boom")
+    else:
+      self.setExtraInfoIsActive = True
+      #print("lock")
+      # setExtraInfo can be called multiple times while this function is running,
+      # so just before existing we check for the latest pending call and execute it,
+      # if during that second execution some other calls are made the latest of those will
+      # be queued by the code a few lines above this one, and the loop will continue processing
+      # until an iteration during which no further call was made.
+      while True:
+        groupId = str(index.model().itemData(index.siblingAtColumn(2))[0])
+        # TODO: move this outside of this class, probably use a single metadata
+        # This is a hack to allow some widgets to set the parent and recompute their size
+        # during their construction.
+        parentIsSet = False
+        def setParent(toolTipWidget):
+          nonlocal parentIsSet
+          parentIsSet = True
+          w = self.extraInfo.layout().takeAt(0)
+          while w:
+            if hasattr(w.widget(), 'finalizer'):
+              # The 3D viewer segfaults very easily if it is used after being destroyed, and some Python/C++ interop seems to overzealously destroys some widgets, including this one, too soon?
+              # Ensuring that we properly detacth the 3D viewer widget before discarding its parent seems to avoid these crashes.
+              #print('FINALIZER')
+              w.widget().finalizer()
+            if w.widget() is not None:
+              w.widget().hide() # hide before detaching, or we have widgets floating as their own window that appear for a split second in some cases.
+              w.widget().setParent(None)
+            w = self.extraInfo.layout().takeAt(0)
+          self.extraInfo.layout().addWidget(toolTipWidget)
+          self.setFloatingWidgetsGeometry()
+        toolTipWidget = self.getToolTip(groupId, setParent)
+        if isinstance(toolTipWidget, str):
+            toolTipWidget = easyToolTipWidget(toolTipWidget)
+        if not parentIsSet:
+          setParent(toolTipWidget)
+        if self.pendingExtraInfo is not None:
+          index = self.pendingExtraInfo
+          self.pendingExtraInfo = None
+        else:
+          break
+      #print("unlock")
+      self.setExtraInfoIsActive = False
+  def clearExtraInfo(self):
+    # TODO: just clear the contents but keep the widget visible.
+    self.extraInfo.hide()
+  def showExtraInfo(self):
+    self.extraInfo.show()

SearchResults.py

@@ -0,0 +1,18 @@
+actionHandlers = { }
+toolTipHandlers = { }
+resultProvidersCached = { }
+resultProvidersUncached = { }
+
+# name : string
+# getItemGroupsCached: () -> [itemGroup]
+# getItemGroupsUncached: () -> [itemGroup]
+def registerResultProvider(name, getItemGroupsCached, getItemGroupsUncached):
+  resultProvidersCached[name] = getItemGroupsCached
+  resultProvidersUncached[name] = getItemGroupsUncached
+
+# name : str
+# action : act -> None
+# toolTip : groupId, setParent -> (str or QWidget)
+def registerResultHandler(name, action, toolTip):
+  actionHandlers[name] = action
+  toolTipHandlers[name] = toolTip

SearchTools.py

@@ -1,812 +0,0 @@
-import os
-import FreeCAD as App
-import FreeCADGui
-from PySide import QtGui
-from PySide import QtCore
-
-"""
-# Reload with:
-import SearchTools; from importlib import reload; reload(SearchTools)
-
-
-TODO for this project:
-OK find a way to use the FreeCAD 3D viewer without segfaults or disappearing widgets
-OK fix sync problem when moving too fast
-OK split the list of tools vs. document objects
-OK save to disk the list of tools
-OK always display including when switching workbenches
-OK slightly larger popup widget to avoid scrollbar for the extra info for document objects
-OK turn this into a standalone mod
-OK Optimize so that it's not so slow
-OK speed up startup to show the box instantly and do the slow loading on first click.
-OK One small bug: when the 3D view is initialized, it causes a loss of focus on the drop-down. We restore it, but the currently-selected index is left unchanged, so the down or up arrow has to be pressed twice.
-* split into several files, try to keep the absolute minimum of code possible in the main file to speed up startup
-OK segfault when reloading
-* Disable the spacebar shortcut (can't type space in the search field…)
-* Possibly disable the home and end, and use ctrl+home and ctrl+end instead?
-"""
-
-################################""
-
-class SafeViewer(QtGui.QWidget):
-  """FreeCAD uses a modified version of QuarterWidget, so the import pivy.quarter one will cause segfaults.
-     FreeCAD's FreeCADGui.createViewer() puts the viewer widget inside an MDI window, and detaching it without causing segfaults on exit is tricky.
-     This class contains some kludges to extract the viewer as a standalone widget and destroy it safely."""
-  def __init__(self, parent = None):
-    super(SafeViewer, self).__init__()
-    self.viewer = FreeCADGui.createViewer()
-    self.graphicsView = self.viewer.graphicsView()
-    self.oldGraphicsViewParent = self.graphicsView.parent()
-    self.oldGraphicsViewParentParent = self.oldGraphicsViewParent.parent()
-    self.oldGraphicsViewParentParentParent = self.oldGraphicsViewParentParent.parent()
-
-    # Avoid segfault but still hide the undesired window by moving it to a new hidden MDI area.
-    self.hiddenQMDIArea = QtGui.QMdiArea()
-    self.hiddenQMDIArea.addSubWindow(self.oldGraphicsViewParentParentParent)
-
-    self.private_widget = self.oldGraphicsViewParent
-    self.private_widget.setParent(parent)
-
-    self.setLayout(QtGui.QVBoxLayout())
-    self.layout().addWidget(self.private_widget)
-    self.layout().setContentsMargins(0,0,0,0)
-
-    def fin(slf):
-      slf.finalizer()
-
-    import weakref
-    weakref.finalize(self, fin, self)
-
-    self.destroyed.connect(self.finalizer)
-
-  def finalizer(self):
-    # Cleanup in an order that doesn't cause a segfault:
-    self.private_widget.setParent(self.oldGraphicsViewParentParent)
-    self.oldGraphicsViewParentParentParent.close()
-    self.oldGraphicsViewParentParentParent = None
-    self.oldGraphicsViewParentParent = None
-    self.oldGraphicsViewParent = None
-    self.graphicsView = None
-    self.viewer = None
-    #self.parent = None
-    self.hiddenQMDIArea = None
-
-"""
-# Example use:
-from PySide import QtGui
-import pivy
-def mk(v):
-  w = QtGui.QMainWindow()
-  oldFocus = QtGui.QApplication.focusWidget()
-  sv.widget.setParent(w)
-  oldFocus.setFocus()
-  w.show()
-  col = pivy.coin.SoBaseColor()
-  col.rgb = (1, 0, 0)
-  trans = pivy.coin.SoTranslation()
-  trans.translation.setValue([0, 0, 0])
-  cub = pivy.coin.SoCube()
-  myCustomNode = pivy.coin.SoSeparator()
-  myCustomNode.addChild(col)
-  myCustomNode.addChild(trans)
-  myCustomNode.addChild(cub)
-  sv.viewer.getViewer().setSceneGraph(myCustomNode)
-  sv.viewer.fitAll()
-  return w
-sv = SafeViewer()
-ww=mk(sv)
-"""
-
-genericToolIcon = QtGui.QIcon(QtGui.QIcon(os.path.dirname(__file__) + '/Tango-Tools-spanner-hammer.svg'))
-
-def iconToBase64(icon, sz = QtCore.QSize(64,64), mode = QtGui.QIcon.Mode.Normal, state = QtGui.QIcon.State.On):
-  buf = QtCore.QBuffer()
-  buf.open(QtCore.QIODevice.WriteOnly)
-  icon.pixmap(sz, mode, state).save(buf, 'PNG')
-  return QtCore.QTextCodec.codecForName('UTF-8').toUnicode(buf.data().toBase64())
-def iconToHTML(icon, sz = 12, mode = QtGui.QIcon.Mode.Normal, state = QtGui.QIcon.State.On):
-  return '<img width="'+str(sz)+'" height="'+str(sz)+'" src="data:image/png;base64,' + iconToBase64(icon, QtCore.QSize(sz,sz), mode, state) + '" />'
-def refreshToolsAction(act):
-  print('Refresh list of tools')
-  fw = QtGui.QApplication.focusWidget()
-  if fw is not None:
-    fw.clearFocus()
-  reply = QtGui.QMessageBox.question(None, "Load all workbenches?", "Load all workbenches? This can cause FreeCAD to become unstable, and this \"reload tools\" feature contained a bug that crashed freecad systematically, so please make sure you save your work before. It's a good idea to restart FreeCAD after this operation.", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
-  if reply == QtGui.QMessageBox.Yes:
-    refreshToolbars()
-  else:
-    print('cancelled')
-def toolbarAction(act):
-  print('show toolbar ' + act['toolbar'] + ' from workbenches ' + repr(act['workbenches']))
-def subToolAction(act):
-  toolPath = act['toolbar'] + '.' + act['tool']
-  if 'subTool' in act:
-    toolPath = toolPath + '.' + act['subTool']
-  def runTool():
-    mw = FreeCADGui.getMainWindow()
-    for the_toolbar in mw.findChildren(QtGui.QToolBar, act['toolbar']):
-      for tbt in the_toolbar.findChildren(QtGui.QToolButton):
-        if tbt.text() == act['tool']:
-          action = None
-          if 'subTool' in act:
-            men = tbt.menu()
-            if men:
-              for mac in men.actions():
-                if mac.text() == act['subTool']:
-                  action = mac
-                  break
-          else:
-            action = tbt.defaultAction()
-          if 'showMenu' in act and act['showMenu']:
-            print('Popup submenu of tool ' + toolPath + ' available in workbenches ' + repr(act['workbenches']))
-            the_toolbar.show()
-            tbt.showMenu()
-            return True
-          elif action is not None:
-            print('Run action of tool ' + toolPath + ' available in workbenches ' + repr(act['workbenches']))
-            action.trigger()
-            return True
-    return False
-  if runTool():
-    return
-  else:
-    for workbench in act['workbenches']:
-      print('Activating workbench ' + workbench + ' to access tool ' + toolPath)
-      FreeCADGui.activateWorkbench(workbench)
-      if runTool():
-        return
-  print('Tool ' + toolPath + ' not found, was it offered by an extension that is no longer present?')
-def documentObjectAction(act):
-  print('select object ' + act['document'] + '.' + act['object'])
-  FreeCADGui.Selection.addSelection(act['document'], act['object'])
-def documentAction(act):
-  # Todo: this should also select the document in the tree view
-  print('switch to document ' + act['document'])
-  App.setActiveDocument(act['document'])
-actionHandlers = {
-  'refreshTools': refreshToolsAction,
-  'toolbar': toolbarAction,
-  'tool': subToolAction,
-  'subTool': subToolAction,
-  'documentObject': documentObjectAction,
-  'document': documentAction
-}
-
-# For some reason, the viewer always works except when used for two consecutive items in the search results: it then disappears after a short zoom-in+zoom-out animation.
-# I'm giving up on getting this viewer to work in a clean way, and will try swapping two instances so that the same one is never used twice in a row.
-# Also, in order to avoid segfaults when the module is reloaded (which causes the previous viewer to be garbage collected at some point), we're using a global property that will survive module reloads.
-if not hasattr(App, '_SearchTools3DViewer'):
-  # Toggle between 
-  App._SearchTools3DViewer = None
-  App._SearchTools3DViewerB = None
-
-globalIgnoreFocusOut = False
-
-import pivy
-class DocumentObjectToolTipWidget(QtGui.QWidget):
-  def __init__(self, nfo, setParent):
-    super(DocumentObjectToolTipWidget, self).__init__()
-    html = '<p>' + nfo['toolTip']['label'] + '</p><p><code>App.getDocument(' + repr(str(nfo['toolTip']['docName'])) + ').getObject(' + repr(str(nfo['toolTip']['name'])) + ')</code></p>'
-    description = QtGui.QTextEdit()
-    description.setReadOnly(True)
-    description.setAlignment(QtCore.Qt.AlignTop)
-    description.setText(html)
-
-    if App._SearchTools3DViewer is None:
-      oldFocus = QtGui.QApplication.focusWidget()
-      global globalIgnoreFocusOut
-      globalIgnoreFocusOut = True
-      App._SearchTools3DViewer = SafeViewer()
-      App._SearchTools3DViewerB = SafeViewer()
-      oldFocus.setFocus()
-      globalIgnoreFocusOut = False
-      # Tried setting the preview to a fixed size to prevent it from disappearing when changing its contents, this sets it to a fixed size but doesn't actually pick the size, .resize does that but isn't enough to fix the bug.
-      #safeViewerInstance.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed))
-    self.preview = App._SearchTools3DViewer
-    App._SearchTools3DViewer, App._SearchTools3DViewerB = App._SearchTools3DViewerB, App._SearchTools3DViewer
-
-    obj = App.getDocument(str(nfo['toolTip']['docName'])).getObject(str(nfo['toolTip']['name']))
-    ## dummy preview:
-    #col = pivy.coin.SoBaseColor()
-    #col.rgb = (1, 0, 0)
-    #trans = pivy.coin.SoTranslation()
-    #trans.translation.setValue([0, 0, 0])
-    #cub = pivy.coin.SoCube()
-    #myCustomNode = pivy.coin.SoSeparator()
-    #myCustomNode.addChild(col)
-    #myCustomNode.addChild(trans)
-    #myCustomNode.addChild(cub)
-    #self.preview.viewer.getViewer().setSceneGraph(myCustomNode)
-
-    # This is really a bad way to do this… to prevent the setExtraInfo function from
-    # finalizing the object, we remove the parent ourselves.
-    oldParent = self.preview.parent()
-    lay = QtGui.QVBoxLayout()
-    lay.setContentsMargins(0,0,0,0)
-    lay.setSpacing(0)
-    self.setLayout(lay)
-    lay.addWidget(description)
-    lay.addWidget(self.preview)
-    #if oldParent is not None:
-    #  oldParent.hide() # hide before detaching, or we have widgets floating as their own window that appear for a split second in some cases.
-    #  oldParent.setParent(None)
-  
-    # Tried hiding/detaching the preview to prevent it from disappearing when changing its contents
-    #self.preview.viewer.stopAnimating()
-    self.preview.viewer.getViewer().setSceneGraph(obj.ViewObject.RootNode)
-    self.preview.viewer.setCameraOrientation(App.Rotation(1,1,0, 0.2))
-    self.preview.viewer.fitAll()
-
-    setParent(self)
-    # Let the GUI recompute the side of the description based on its horizontal size.
-    FreeCADGui.updateGui()
-    siz = description.document().size().toSize()
-    description.setFixedHeight(siz.height() + 5)
-
-  def finalizer(self):
-    #self.preview.finalizer()
-    # Detach the widget so that it may be reused without getting deleted
-    self.preview.setParent(None)
-
-
-def easyToolTipWidget(html):
-  foo = QtGui.QTextEdit()
-  foo.setReadOnly(True)
-  foo.setAlignment(QtCore.Qt.AlignTop)
-  foo.setText(html)
-  return foo
-def refreshToolsToolTip(nfo, setParent):
-  return easyToolTipWidget(iconToHTML(genericToolIcon) + '<p>Load all workbenches to refresh this list of tools. This may take a minute, depending on the number of installed workbenches.</p>')
-def toolbarToolTip(nfo, setParent):
-  return easyToolTipWidget('<p>Display toolbar ' + nfo['toolTip'] + '</p><p>This toolbar appears in the following workbenches: <ul>' + ''.join(['<li>' + iconToHTML(QtGui.QIcon(FreeCADGui.listWorkbenches()[wb].Icon)) + wb + '</li>' for wb in nfo['action']['workbenches']]) + '</ul></p>')
-def subToolToolTip(nfo, setParent):
-  return easyToolTipWidget(iconToHTML(nfo['icon'], 32) + '<p>' + nfo['toolTip'] + '</p>')
-def documentObjectToolTip(nfo, setParent):
-  return DocumentObjectToolTipWidget(nfo, setParent)
-def documentToolTip(nfo, setParent):
-  return easyToolTipWidget('<p>' + nfo['toolTip']['label'] + '</p><p><code>App.getDocument(' + repr(str(nfo['toolTip']['name'])) + ')</code></p><p><img src="data:image/png;base64,.............."></p>')
-toolTipHandlers = {
-  'refreshTools': refreshToolsToolTip,
-  'toolbar': toolbarToolTip,
-  'tool': subToolToolTip,
-  'subTool': subToolToolTip,
-  'documentObject': documentObjectToolTip,
-  'document': documentToolTip
-}
-
-# Inspired by https://stackoverflow.com/a/5443220/324969
-# Inspired by https://forum.qt.io/topic/69807/qtreeview-indent-entire-row
-class IndentedItemDelegate(QtGui.QStyledItemDelegate):
-  def __init__(self):
-    super(IndentedItemDelegate, self).__init__()
-  def paint(self, painter, option, index):
-    depth = int(option.widget.model().itemData(index.siblingAtColumn(1))[0])
-    indent = 16 * depth
-    option.rect.adjust(indent, 0, 0, 0)
-    super(IndentedItemDelegate, self).paint(painter, option, index)
-#
-globalGroups = []
-class SearchBox(QtGui.QLineEdit):
-  resultSelected = QtCore.Signal(int, dict)
-  def __init__(self, getItemGroups, itemDelegate = IndentedItemDelegate(), maxVisibleRows = 20, parent = None):
-    # Call parent cosntructor
-    super(SearchBox, self).__init__(parent)
-    # Save arguments
-    #self.model = model
-    self.getItemGroups = getItemGroups
-    self.itemGroups = None # Will be initialized by calling getItemGroups() the first time the search box gains focus, through focusInEvent and refreshItemGroups
-    self.maxVisibleRows = maxVisibleRows # TODO: use this to compute the correct height
-    # Create proxy model
-    self.proxyModel = QtCore.QIdentityProxyModel()
-    # Filtered model to which items are manually added. Store it as a property of the object instead of a local variable, to prevent grbage collection.
-    self.mdl = QtGui.QStandardItemModel()
-    #self.proxyModel.setModel(self.model)
-    # Create list view
-    self.listView = QtGui.QListView(self)
-    self.listView.setWindowFlags(QtGui.Qt.ToolTip)
-    self.listView.setWindowFlag(QtGui.Qt.FramelessWindowHint)
-    self.listView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
-    self.listView.setModel(self.proxyModel)
-    self.listView.setItemDelegate(itemDelegate) # https://stackoverflow.com/a/65930408/324969
-    # make the QListView non-editable
-    self.listView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
-    # Create pane for showing extra info about the currently-selected tool
-    #self.extraInfo = QtGui.QLabel()
-    self.extraInfo = QtGui.QWidget()
-    self.extraInfo.setWindowFlags(QtGui.Qt.ToolTip)
-    self.extraInfo.setWindowFlag(QtGui.Qt.FramelessWindowHint)
-    self.extraInfo.setLayout(QtGui.QVBoxLayout())
-    self.extraInfo.layout().setContentsMargins(0,0,0,0)
-    self.setExtraInfoIsActive = False
-    self.pendingExtraInfo = None
-    # Connect signals and slots
-    self.textChanged.connect(self.filterModel)
-    self.listView.clicked.connect(lambda x: self.selectResult('select', x))
-    self.listView.selectionModel().selectionChanged.connect(self.onSelectionChanged)
-    # Thanks to https://saurabhg.com/programming/search-box-using-qlineedit/ for indicating a few useful options
-    ico = QtGui.QIcon(':/icons/help-browser.svg')
-    #ico = QtGui.QIcon(':/icons/WhatsThis.svg')
-    self.addAction(ico, QtGui.QLineEdit.LeadingPosition)
-    self.setClearButtonEnabled(True)
-    self.setPlaceholderText('Search tools, prefs & tree')
-    self.setFixedWidth(200) # needed to avoid a change of width when the clear button appears/disappears
-    # Initialize the model with the full list (assuming the text() is empty)
-    #self.filterModel(self.text()) # This is done by refreshItemGroups on focusInEvent, because the initial loading from cache can take time
-  def refreshItemGroups(self):
-    self.itemGroups = self.getItemGroups()
-    self.filterModel(self.text())
-  def focusInEvent(self, qFocusEvent):
-    global globalIgnoreFocusOut
-    if not globalIgnoreFocusOut:
-      self.refreshItemGroups()
-    self.showList()
-    super(SearchBox, self).focusInEvent(qFocusEvent)
-  def focusOutEvent(self, qFocusEvent):
-    global globalIgnoreFocusOut
-    if not globalIgnoreFocusOut:
-      self.hideList()
-      super(SearchBox, self).focusOutEvent(qFocusEvent)
-  def keyPressEvent(self, qKeyEvent):
-    key = qKeyEvent.key()
-    listMovementKeys = {
-      QtCore.Qt.Key_Down:     lambda current, nbRows: (current + 1) % nbRows,
-      QtCore.Qt.Key_Up:       lambda current, nbRows: (current - 1) % nbRows,
-      QtCore.Qt.Key_PageDown: lambda current, nbRows: min(current + max(1, self.maxVisibleRows / 2), nbRows - 1),
-      QtCore.Qt.Key_PageUp:   lambda current, nbRows: max(current - max(1, self.maxVisibleRows / 2), 0),
-      QtCore.Qt.Key_Home:     lambda current, nbRows: 0,
-      QtCore.Qt.Key_End:      lambda current, nbRows: nbRows - 1,
-    }
-    acceptKeys = {
-      QtCore.Qt.Key_Enter:  'select',
-      QtCore.Qt.Key_Return: 'select',
-      # space on a toolbar/category should toggle the entire category in the search results
-      QtCore.Qt.Key_Space:  'toggle',
-    }
-    cancelKeys = {
-      QtCore.Qt.Key_Escape: True,
-    }
-    
-    currentIndex = self.listView.currentIndex()
-    if key in listMovementKeys:
-      self.showList()
-      if self.listView.isEnabled():
-          currentRow = currentIndex.row()
-          nbRows = self.listView.model().rowCount()
-          if nbRows > 0:
-            newRow = listMovementKeys[key](currentRow, nbRows)
-            index = self.listView.model().index(newRow, 0)
-            self.listView.setCurrentIndex(index)
-    elif key in acceptKeys:
-      self.showList()
-      if currentIndex.isValid():
-          self.selectResult(acceptKeys[key], currentIndex)
-    elif key in cancelKeys:
-      self.hideList()
-      self.clearFocus()
-    else:
-      self.showList()
-      super(SearchBox, self).keyPressEvent(qKeyEvent)
-  def showList(self):
-    self.setFloatingWidgetsGeometry()
-    if not self.listView.isVisible():
-      self.listView.show()
-    self.showExtraInfo()
-  def hideList(self):
-    self.listView.hide()
-    self.hideExtraInfo()
-  def hideExtraInfo(self):
-    self.extraInfo.hide()
-  def selectResult(self, mode, index):
-    groupIdx = int(index.model().itemData(index.siblingAtColumn(2))[0])
-    nfo = globalGroups[groupIdx]
-    self.hideList()
-    # TODO: allow other options, e.g. some items could act as combinators / cumulative filters
-    self.setText('')
-    self.filterModel(self.text())
-    # TODO: emit index relative to the base model
-    self.resultSelected.emit(index, nfo)
-  def filterModel(self, userInput):
-    # TODO: this will cause a race condition if it is accessed while being modified
-    def matches(s):
-      return userInput.lower() in s.lower()
-    def filterGroup(group):
-      if matches(group['text']):
-        # If a group matches, include the entire subtree (might need to disable this if it causes too much noise)
-        return group
-      else:
-        subitems = filterGroups(group['subitems'])
-        if len(subitems) > 0 or matches(group['text']):
-          return { 'id': group['id'], 'text': group['text'], 'icon': group['icon'], 'action': group['action'], 'toolTip':group['toolTip'], 'subitems': subitems }
-        else:
-          return None
-    def filterGroups(groups):
-      groups = (filterGroup(group) for group in groups)
-      return [group for group in groups if group is not None]
-    self.mdl = QtGui.QStandardItemModel()
-    self.mdl.appendColumn([])
-    def addGroups(filteredGroups, depth=0):
-      for group in filteredGroups:
-        # TODO: this is not very clean, we should memorize the index from the original itemgroups
-        #globalGroups[groupIdx] = json.dumps(serializeItemGroup(group))
-        self.mdl.appendRow([QtGui.QStandardItem(group['icon'] or genericToolIcon, group['text']),
-                            QtGui.QStandardItem(str(depth)),
-                            QtGui.QStandardItem(str(group['id']))])
-        addGroups(group['subitems'], depth+1)
-    addGroups(filterGroups(self.itemGroups))
-    self.proxyModel.setSourceModel(self.mdl)
-    # TODO: try to find the already-highlighted item
-    nbRows = self.listView.model().rowCount()
-    if nbRows > 0:
-      index = self.listView.model().index(0, 0)
-      self.listView.setCurrentIndex(index)
-      self.setExtraInfo(index)
-    else:
-      self.clearExtraInfo()
-    #self.showList()
-  def setFloatingWidgetsGeometry(self):
-    def getScreenPosition(widget):
-      geo = widget.geometry()
-      parent = widget.parent()
-      parentPos = getScreenPosition(parent) if parent is not None else QtCore.QPoint(0,0)
-      return QtCore.QPoint(geo.x() + parentPos.x(), geo.y() + parentPos.y())
-    pos = getScreenPosition(self)
-    siz = self.size()
-    screen = QtGui.QGuiApplication.screenAt(pos)
-    x = pos.x()
-    y = pos.y() + siz.height()
-    hint_w = self.listView.sizeHint().width()
-    # TODO: this can still bump into the bottom of the screen, in that case we should flip
-    w = max(siz.width(), hint_w)
-    h = 200 # TODO: set height / size here according to desired number of items
-    extraw = w # choose a preferred width that doesn't change all the time,
-                # self.extraInfo.sizeHint().width() would change for every item.
-    extrax = x - extraw
-    if screen is not None:
-      scr = screen.geometry()
-      x = min(scr.x() + scr.width() - hint_w, x)
-      extraleftw = x - scr.x()
-      extrarightw = scr.x() + scr.width() - x
-      # flip the extraInfo if it doesn't fit on the screen
-      if extraleftw < extraw and extrarightw > extraleftw:
-        extrax = x + w
-        extraw = min(extrarightw, extraw)
-      else:
-        extrax = x - extraw
-        extraw = min(extraleftw, extraw)
-    self.listView.setGeometry(x, y, w, h)
-    self.extraInfo.setGeometry(extrax, y, extraw, h)
-  def onSelectionChanged(self, selected, deselected):
-    # The list has .setSelectionMode(QtGui.QAbstractItemView.SingleSelection),
-    # so there is always at most one index in selected.indexes() and at most one
-    # index in deselected.indexes()
-    selected = selected.indexes()
-    deselected = deselected.indexes()
-    if len(selected) > 0:
-      index = selected[0]
-      self.setExtraInfo(index)
-      # Poor attempt to circumvent a glitch where the extra info pane stays visible after pressing Return
-      if not self.listView.isHidden():
-        self.showExtraInfo()
-    elif len(deselected) > 0:
-      self.hideExtraInfo()
-  def setExtraInfo(self, index):
-    global globalGroups
-    # TODO: use an atomic swap or mutex if possible
-    if self.setExtraInfoIsActive:
-      self.pendingExtraInfo = index
-      #print("boom")
-    else:
-      self.setExtraInfoIsActive = True
-      #print("lock")
-      # setExtraInfo can be called multiple times while this function is running,
-      # so just before existing we check for the latest pending call and execute it,
-      # if during that second execution some other calls are made the latest of those will
-      # be queued by the code a few lines above this one, and the loop will continue processing
-      # until an iteration during which no further call was made.
-      while True:
-        nfo = str(index.model().itemData(index.siblingAtColumn(2))[0])
-        # TODO: move this outside of this class, probably use a single metadata
-        nfo = globalGroups[int(nfo)]# TODO: used to be deserializeItemGroup(json.loads(nfo))
-        #TODO: used to be: nfo['action'] = json.loads(nfo['action'])
-        #while len(self.extraInfo.children()) > 0:
-        #  self.extraInfo.children()[0].setParent(None)
-        # This is a hack to allow some widgets to set the parent and recompute their size
-        # during their construction.
-        parentIsSet = False
-        def setParent(toolTipWidget):
-          nonlocal parentIsSet
-          parentIsSet = True
-          w = self.extraInfo.layout().takeAt(0)
-          while w:
-            if hasattr(w.widget(), 'finalizer'):
-              # The 3D viewer segfaults very easily if it is used after being destroyed, and some Python/C++ interop seems to overzealously destroys some widgets, including this one, too soon?
-              # Ensuring that we properly detacth the 3D viewer widget before discarding its parent seems to avoid these crashes.
-              #print('FINALIZER')
-              w.widget().finalizer()
-            if w.widget() is not None:
-              w.widget().hide() # hide before detaching, or we have widgets floating as their own window that appear for a split second in some cases.
-              w.widget().setParent(None)
-            w = self.extraInfo.layout().takeAt(0)
-          self.extraInfo.layout().addWidget(toolTipWidget)
-          #toolTipHTML = toolTipHandlers[nfo['action']['handler']](nfo)
-          #self.extraInfo.setText(toolTipHTML)
-          self.setFloatingWidgetsGeometry()
-        toolTipWidget = toolTipHandlers[nfo['action']['handler']](nfo, setParent)
-        if not parentIsSet:
-          setParent(toolTipWidget)
-        if self.pendingExtraInfo is not None:
-          index = self.pendingExtraInfo
-          self.pendingExtraInfo = None
-        else:
-          break
-      #print("unlock")
-      self.setExtraInfoIsActive = False
-  def clearExtraInfo(self):
-    # TODO: just clear the contents but keep the widget visible.
-    self.extraInfo.hide()
-  def showExtraInfo(self):
-    self.extraInfo.show()
-
-def getAllToolbars():
-  all_tbs = dict()
-  for wbname, workbench in FreeCADGui.listWorkbenches().items():
-    try:
-      tbs = workbench.listToolbars()
-    except:
-      continue
-    # careful, tbs contains all the toolbars of the workbench, including shared toolbars
-    for tb in tbs:
-      if tb not in all_tbs:
-        all_tbs[tb] = set()
-      all_tbs[tb].add(wbname)
-  return all_tbs
-
-import json
-def serializeIcon(icon):
-  iconPixmaps = {}
-  for sz in icon.availableSizes():
-    strW = str(sz.width())
-    strH = str(sz.height())
-    iconPixmaps[strW] = {}
-    iconPixmaps[strW][strH] = {}
-    for strMode, mode in {'normal':QtGui.QIcon.Mode.Normal, 'disabled':QtGui.QIcon.Mode.Disabled, 'active':QtGui.QIcon.Mode.Active, 'selected':QtGui.QIcon.Mode.Selected}.items():
-      iconPixmaps[strW][strH][strMode] = {}
-      for strState, state in {'off':QtGui.QIcon.State.Off, 'on':QtGui.QIcon.State.On}.items():
-        iconPixmaps[strW][strH][strMode][strState] = iconToBase64(icon, sz, mode, state)
-  return iconPixmaps
-# workbenches is a list(str), toolbar is a str, text is a str, icon is a QtGui.QIcon
-def serializeTool(tool):
-  return {
-    'workbenches': tool['workbenches'],
-    'toolbar': tool['toolbar'],
-    'text': tool['text'],
-    'toolTip': tool['toolTip'],
-    'icon': serializeIcon(tool['icon']),
-  }
-
-def deserializeIcon(iconPixmaps):
-  ico = QtGui.QIcon()
-  for strW, wPixmaps in iconPixmaps.items():
-    for strH, hPixmaps in wPixmaps.items():
-      for strMode, modePixmaps in hPixmaps.items():
-        mode = {'normal':QtGui.QIcon.Mode.Normal, 'disabled':QtGui.QIcon.Mode.Disabled, 'active':QtGui.QIcon.Mode.Active, 'selected':QtGui.QIcon.Mode.Selected}[strMode]
-        for strState, statePixmap in modePixmaps.items():
-          state = {'off':QtGui.QIcon.State.Off, 'on':QtGui.QIcon.State.On}[strState]
-          pxm = QtGui.QPixmap()
-          pxm.loadFromData(QtCore.QByteArray.fromBase64(QtCore.QTextCodec.codecForName('UTF-8').fromUnicode(statePixmap)))
-          ico.addPixmap(pxm, mode, state)
-  return ico
-
-def deserializeTool(tool):
-  return {
-    'workbenches': tool['workbenches'],
-    'toolbar': tool['toolbar'],
-    'text': tool['text'],
-    'toolTip': tool['toolTip'],
-    'icon': deserializeIcon(tool['icon']),
-  }
-
-def gatherTools():
-  itemGroups = []
-  itemGroups.append({
-    'icon': genericToolIcon,
-    'text': 'Refresh list of tools',
-    'toolTip': '',
-    'action': {'handler': 'refreshTools'},
-    'subitems': []
-  })
-  all_tbs = getAllToolbars()
-  mw = FreeCADGui.getMainWindow()
-  for toolbarName, toolbarIsInWorkbenches in all_tbs.items():
-    toolbarIsInWorkbenches = sorted(list(toolbarIsInWorkbenches))
-    for the_toolbar in mw.findChildren(QtGui.QToolBar, toolbarName):
-      group = []
-      for tbt in the_toolbar.findChildren(QtGui.QToolButton):
-        text = tbt.text()
-        act = tbt.defaultAction()
-        if text != '':
-            # TODO: there also is the tooltip
-            icon = tbt.icon()
-            men = tbt.menu()
-            subgroup = []
-            if men:
-              subgroup = []
-              for mac in men.actions():
-                if mac.text():
-                  action = { 'handler': 'subTool', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName, 'tool': text, 'subTool': mac.text() }
-                  subgroup.append({'icon':mac.icon(), 'text':mac.text(), 'toolTip': mac.toolTip(), 'action':action, 'subitems':[]})
-            # The default action of a menu changes dynamically, instead of triggering the last action, just show the menu.
-            action = { 'handler': 'tool', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName, 'tool': text, 'showMenu': bool(men) }
-            group.append({'icon':icon, 'text':text, 'toolTip': tbt.toolTip(), 'action': action, 'subitems': subgroup})
-      # TODO: move the 'workbenches' field to the itemgroup
-      action = { 'handler': 'toolbar', 'workbenches': toolbarIsInWorkbenches, 'toolbar': toolbarName }
-      itemGroups.append({
-        'icon': QtGui.QIcon(':/icons/Group.svg'),
-        'text': toolbarName,
-        'toolTip': '',
-        'action': action,
-        'subitems': group
-      })
-  return itemGroups
-
-def gatherDocumentObjects():
-  itemGroups = []
-  def document(doc):
-    group = []
-    for o in doc.Objects:
-      #all_actions.append(lambda: )
-      action = { 'handler': 'documentObject', 'document': o.Document.Name, 'object': o.Name }
-      item = {
-        'icon': o.ViewObject.Icon if o.ViewObject and o.ViewObject.Icon else None,
-        'text': o.Label + ' (' + o.Name + ')',
-        # TODO: preview of the object
-        'toolTip': { 'label': o.Label, 'name': o.Name, 'docName': o.Document.Name},
-        'action': action,
-        'subitems': []
-      }
-      group.append(item)
-
-    action = { 'handler': 'document', 'document': doc.Name }
-    itemGroups.append({
-      'icon': QtGui.QIcon(':/icons/Document.svg'),
-      'text': doc.Label + ' (' + doc.Name + ')',
-      # TODO: preview of the document
-      'toolTip': { 'label': doc.Label, 'name': doc.Name},
-      'action':action,
-      'subitems': group })
-  if App.ActiveDocument:
-    document(App.ActiveDocument)
-  for docname, doc in App.listDocuments().items():
-    if not App.activeDocument or docname != App.ActiveDocument.Name:
-      document(doc)
-  return itemGroups
-
-def serializeItemGroup(itemGroup):
-  return {
-    'icon': serializeIcon(itemGroup['icon']),
-    'text': itemGroup['text'],
-    'toolTip': itemGroup['toolTip'],
-    'action': itemGroup['action'],
-    'subitems': serializeItemGroups(itemGroup['subitems'])
-  }
-def serializeItemGroups(itemGroups):
-  return [serializeItemGroup(itemGroup) for itemGroup in itemGroups]
-def serialize(itemGroups):
-  return json.dumps(serializeItemGroups(itemGroups))
-def deserializeItemGroup(itemGroup):
-  return {
-    'icon': deserializeIcon(itemGroup['icon']),
-    'text': itemGroup['text'],
-    'toolTip': itemGroup['toolTip'],
-    'action': itemGroup['action'],
-    'subitems': deserializeItemGroups(itemGroup['subitems'])
-  }
-def deserializeItemGroups(serializedItemGroups):
-  return [deserializeItemGroup(itemGroup) for itemGroup in serializedItemGroups]
-def deserialize(serializeItemGroups):
-  return deserializeItemGroups(json.loads(serializedItemGroups))
-
-itemGroups = None
-serializedItemGroups = None
-
-def loadAllWorkbenches():
-  activeWorkbench = FreeCADGui.activeWorkbench().name()
-  lbl = QtGui.QLabel('Loading workbench … (…/…)')
-  lbl.show()
-  lst = FreeCADGui.listWorkbenches()
-  for i, wb in enumerate(lst):
-    msg = 'Loading workbench ' + wb + ' (' + str(i) + '/' + str(len(lst)) + ')'
-    print(msg)
-    lbl.setText(msg)
-    geo = lbl.geometry()
-    geo.setSize(lbl.sizeHint())
-    lbl.setGeometry(geo)
-    lbl.repaint()
-    FreeCADGui.updateGui() # Probably slower with this, because it redraws the entire GUI with all tool buttons changed etc. but allows the label to actually be updated, and it looks nice and gives a quick overview of all the workbenches…
-    try:
-      FreeCADGui.activateWorkbench(wb)
-    except:
-      pass
-  lbl.hide()
-  FreeCADGui.activateWorkbench(activeWorkbench)
-
-def cachePath():
-  return os.path.join(App.getUserAppDataDir(), 'Cache_SearchToolsMod')
-def writeCacheTools():
-  global itemGroups, serializedItemGroups
-  serializedItemGroups = serialize(gatherTools())
-  # Todo: use wb and a specific encoding.
-  with open(cachePath(), 'w') as cache:
-    cache.write(serializedItemGroups)
-  # I prefer to systematically deserialize, instead of taking the original version,
-  # this avoids possible inconsistencies between the original and the cache and
-  # makes sure cache-related bugs are noticed quickly.
-  itemGroups = deserialize(serializedItemGroups)
-  print('SearchBox: Cache has been written.')
-
-def readCacheTools():
-  global itemGroups, serializedItemGroups
-  # Todo: use rb and a specific encoding.
-  with open(cachePath(), 'r') as cache:
-    serializedItemGroups = cache.read()
-  itemGroups = deserialize(serializedItemGroups)
-  print('SearchBox: Tools were loaded from the cache.')
-
-
-def refreshToolbars(doLoadAllWorkbenches = True):
-  if doLoadAllWorkbenches:
-    loadAllWorkbenches()
-    writeCacheTools()
-  else:
-    try:
-      readCacheTools()
-    except:
-      writeCacheTools()
-
-# Avoid garbage collection by storing the action in a global variable
-wax = None
-
-def getItemGroups():
-  global itemGroups, serializedItemGroups, globalGroups
-  # Load the list of tools, preferably from the cache, if it has not already been loaded:
-  if itemGroups is None:
-    if serializedItemGroups is None:
-      refreshToolbars(doLoadAllWorkbenches = False)
-    else:
-      itemGroups = deserialize(serializedItemGroups)
-
-  # Aggregate the tools (cached) and document objects (not cached), and assign an index to each
-  igs = itemGroups + gatherDocumentObjects()
-  globalGroups = []
-  def addId(group):
-    globalGroups.append(group)
-    group['id'] = len(globalGroups) - 1
-    for subitem in group['subitems']:
-      addId(subitem)
-  for ig in igs:
-    addId(ig)
-  
-  return igs
-
-def onResultSelected(index, nfo):
-  action = nfo['action']
-  actionHandlers[action['handler']](action)
-
-def addToolSearchBox():
-  global wax, sea
-  mw = FreeCADGui.getMainWindow()
-  mbr = mw.findChildren(QtGui.QToolBar, 'File')
-  if len(mbr) > 0:
-    # Get the first toolbar named 'File', and add 
-    mbr = mbr[0]
-    # Create search box widget
-    sea = SearchBox(getItemGroups)
-    sea.resultSelected.connect(onResultSelected)
-    wax = QtGui.QWidgetAction(None)
-    wax.setDefaultWidget(sea)
-    #mbr.addWidget(sea)
-    #print("addAction" + repr(mbr) + ' add(' + repr(wax))
-    mbr.addAction(wax)
-
-addToolSearchBox()
-FreeCADGui.getMainWindow().workbenchActivated.connect(addToolSearchBox)

Serialize.py

@@ -0,0 +1,87 @@
+from PySide import QtCore
+from PySide import QtGui
+import json
+
+def iconToBase64(icon, sz = QtCore.QSize(64,64), mode = QtGui.QIcon.Mode.Normal, state = QtGui.QIcon.State.On):
+  buf = QtCore.QBuffer()
+  buf.open(QtCore.QIODevice.WriteOnly)
+  icon.pixmap(sz, mode, state).save(buf, 'PNG')
+  return QtCore.QTextCodec.codecForName('UTF-8').toUnicode(buf.data().toBase64())
+
+def iconToHTML(icon, sz = 12, mode = QtGui.QIcon.Mode.Normal, state = QtGui.QIcon.State.On):
+  return '<img width="'+str(sz)+'" height="'+str(sz)+'" src="data:image/png;base64,' + iconToBase64(icon, QtCore.QSize(sz,sz), mode, state) + '" />'
+
+def serializeIcon(icon):
+  iconPixmaps = {}
+  for sz in icon.availableSizes():
+    strW = str(sz.width())
+    strH = str(sz.height())
+    iconPixmaps[strW] = {}
+    iconPixmaps[strW][strH] = {}
+    for strMode, mode in {'normal':QtGui.QIcon.Mode.Normal, 'disabled':QtGui.QIcon.Mode.Disabled, 'active':QtGui.QIcon.Mode.Active, 'selected':QtGui.QIcon.Mode.Selected}.items():
+      iconPixmaps[strW][strH][strMode] = {}
+      for strState, state in {'off':QtGui.QIcon.State.Off, 'on':QtGui.QIcon.State.On}.items():
+        iconPixmaps[strW][strH][strMode][strState] = iconToBase64(icon, sz, mode, state)
+  return iconPixmaps
+
+# workbenches is a list(str), toolbar is a str, text is a str, icon is a QtGui.QIcon
+def serializeTool(tool):
+  return {
+    'workbenches': tool['workbenches'],
+    'toolbar': tool['toolbar'],
+    'text': tool['text'],
+    'toolTip': tool['toolTip'],
+    'icon': serializeIcon(tool['icon']),
+  }
+
+def deserializeIcon(iconPixmaps):
+  ico = QtGui.QIcon()
+  for strW, wPixmaps in iconPixmaps.items():
+    for strH, hPixmaps in wPixmaps.items():
+      for strMode, modePixmaps in hPixmaps.items():
+        mode = {'normal':QtGui.QIcon.Mode.Normal, 'disabled':QtGui.QIcon.Mode.Disabled, 'active':QtGui.QIcon.Mode.Active, 'selected':QtGui.QIcon.Mode.Selected}[strMode]
+        for strState, statePixmap in modePixmaps.items():
+          state = {'off':QtGui.QIcon.State.Off, 'on':QtGui.QIcon.State.On}[strState]
+          pxm = QtGui.QPixmap()
+          pxm.loadFromData(QtCore.QByteArray.fromBase64(QtCore.QTextCodec.codecForName('UTF-8').fromUnicode(statePixmap)))
+          ico.addPixmap(pxm, mode, state)
+  return ico
+
+def deserializeTool(tool):
+  return {
+    'workbenches': tool['workbenches'],
+    'toolbar': tool['toolbar'],
+    'text': tool['text'],
+    'toolTip': tool['toolTip'],
+    'icon': deserializeIcon(tool['icon']),
+  }
+
+def serializeItemGroup(itemGroup):
+  return {
+    'icon': serializeIcon(itemGroup['icon']),
+    'text': itemGroup['text'],
+    'toolTip': itemGroup['toolTip'],
+    'action': itemGroup['action'],
+    'subitems': serializeItemGroups(itemGroup['subitems'])
+  }
+
+def serializeItemGroups(itemGroups):
+  return [serializeItemGroup(itemGroup) for itemGroup in itemGroups]
+
+def serialize(itemGroups):
+  return json.dumps(serializeItemGroups(itemGroups))
+
+def deserializeItemGroup(itemGroup):
+  return {
+    'icon': deserializeIcon(itemGroup['icon']),
+    'text': itemGroup['text'],
+    'toolTip': itemGroup['toolTip'],
+    'action': itemGroup['action'],
+    'subitems': deserializeItemGroups(itemGroup['subitems'])
+  }
+
+def deserializeItemGroups(serializedItemGroups):
+  return [deserializeItemGroup(itemGroup) for itemGroup in serializedItemGroups]
+
+def deserialize(serializedItemGroups):
+  return deserializeItemGroups(json.loads(serializedItemGroups))

TODO.py

@@ -0,0 +1,24 @@
+import os
+import FreeCAD as App
+from PySide import QtGui
+from PySide import QtCore
+
+from SafeViewer import SafeViewer
+
+"""
+TODO for this project:
+OK find a way to use the FreeCAD 3D viewer without segfaults or disappearing widgets
+OK fix sync problem when moving too fast
+OK split the list of tools vs. document objects
+OK save to disk the list of tools
+OK always display including when switching workbenches
+OK slightly larger popup widget to avoid scrollbar for the extra info for document objects
+OK turn this into a standalone mod
+OK Optimize so that it's not so slow
+OK speed up startup to show the box instantly and do the slow loading on first click.
+OK One small bug: when the 3D view is initialized, it causes a loss of focus on the drop-down. We restore it, but the currently-selected index is left unchanged, so the down or up arrow has to be pressed twice.
+* split into several files, try to keep the absolute minimum of code possible in the main file to speed up startup
+OK segfault when reloading
+* Disable the spacebar shortcut (can't type space in the search field…)
+* Possibly disable the home and end, and use ctrl+home and ctrl+end instead?
+"""