SearchBar/SearchBox.py

import FreeCAD as App
import FreeCADGui as Gui
import os

from PySide.QtCore import (
    Qt,
    SIGNAL,
    QSize,
    QIdentityProxyModel,
    QPoint,
)
from PySide.QtWidgets import (
    QTabWidget,
    QSlider,
    QSpinBox,
    QCheckBox,
    QComboBox,
    QLabel,
    QTabWidget,
    QSizePolicy,
    QPushButton,
    QLineEdit,
    QTextEdit,
    QListView,
    QAbstractItemView,
    QWidget,
    QVBoxLayout,
    QApplication,
    QListWidget,
    QWidgetAction,
)
from PySide.QtGui import (
    QIcon,
    QPixmap,
    QColor,
    QStandardItemModel,
    QShortcut,
    QKeySequence,
    QStandardItem,
)

from SearchBoxLight import SearchBoxLight
import Parameters_SearchBar as Parameters

genericToolIcon = QIcon(Parameters.genericToolIcon_Pixmap)

globalIgnoreFocusOut = False

# Define the translation
translate = App.Qt.translate

# Avoid garbage collection by storing the action in a global variable
wax = None
sea = None
tbr = None


def easyToolTipWidget(html):
    foo = QTextEdit()
    foo.setReadOnly(True)
    foo.setAlignment(Qt.AlignmentFlag.AlignTop)
    foo.setText(html)
    return foo


def SearchBoxFunction(mw):
    import SearchBoxLight

    global wax, sea, tbr

    if mw:
        if sea is None:
            sea = SearchBoxLight.SearchBoxLight(
                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)
            )

        if wax is None:
            wax = QWidgetAction(None)
            wax.setWhatsThis(
                translate(
                    "SearchBar",
                    "Use this search bar to find tools, document objects, preferences and more",
                )
            )

        sea.setWhatsThis(
            translate(
                "SearchBar",
                "Use this search bar to find tools, document objects, preferences and more",
            )
        )
        wax.setDefaultWidget(sea)
    return wax


class SearchBox(QLineEdit):
    # The following block of code is present in the lightweight proxy SearchBoxLight
    """
    resultSelected = QtCore.Signal(int, int)
    """

    @staticmethod
    def lazyInit(self):
        if self.isInitialized:
            return self
        getItemGroups = self.getItemGroups
        getToolTip = self.getToolTip
        getItemDelegate = self.getItemDelegate
        maxVisibleRows = self.maxVisibleRows
        # The following block of code is executed by the lightweight proxy SearchBoxLight
        """
    # Call parent constructor
    super(SearchBoxLight, self).__init__(parent)
    # Connect signals and slots
    self.textChanged.connect(self.filterModel)
    # Thanks to https://saurabhg.com/programming/search-box-using-qlineedit/ for indicating a few useful options
    ico = QIcon(':/icons/help-browser.svg')
    #ico = 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
    """

        # Save arguments
        # self.model = model
        self.getItemGroups = getItemGroups
        self.getToolTip = getToolTip
        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 = 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 = QStandardItemModel()
        # self.proxyModel.setModel(self.model)
        # Create list view
        self.listView = QListView(self)
        self.listView.setWindowFlags(Qt.WindowType.ToolTip)
        self.listView.setWindowFlag(Qt.WindowType.FramelessWindowHint)
        self.listView.setSelectionMode(self.listView.SelectionMode.SingleSelection)
        self.listView.setModel(self.proxyModel)
        self.listView.setItemDelegate(getItemDelegate())  # https://stackoverflow.com/a/65930408/324969
        self.listView.setMouseTracking(True)
        # make the QListView non-editable
        self.listView.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        # Create pane for showing extra info about the currently-selected tool
        # self.extraInfo = QtGui.QLabel()
        self.extraInfo = QWidget()
        self.extraInfo.setWindowFlags(Qt.WindowType.ToolTip)
        self.extraInfo.setWindowFlag(Qt.WindowType.FramelessWindowHint)
        self.extraInfo.setLayout(QVBoxLayout())
        self.extraInfo.layout().setContentsMargins(0, 0, 0, 0)
        self.setExtraInfoIsActive = False
        self.pendingExtraInfo = None
        self.currentExtraInfo = None
        # Connect signals and slots
        self.listView.clicked.connect(
            lambda x: self.selectResult("select", x)
        )  # This makes all workbenches appear. TODO: findout why, a click event seems not logic
        self.listView.selectionModel().selectionChanged.connect(
            self.onSelectionChanged
        )  # This updates the details when using the keyboard
        # Add custom mouse events. On windows the click events were not working for Searcbar versions 1.2.x and older.
        # These events and their proxies in the SearchBorLight fixes this
        self.listView.mousePressEvent = lambda event: self.proxyMousePressEvent(event)
        self.listView.mouseMoveEvent = lambda event: self.proxyMouseMoveEvent(event)
        self.extraInfo.leaveEvent = lambda event: self.proxyLeaveEvent(event)

        # Note: should probably use the eventFilter method instead...
        wdgctx = Qt.ShortcutContext.WidgetShortcut

        QShortcut(QKeySequence(Qt.Key.Key_Down), self, context=wdgctx).activated.connect(self.listDown)
        QShortcut(QKeySequence(Qt.Key.Key_Up), self, context=wdgctx).activated.connect(self.listUp)
        QShortcut(QKeySequence(Qt.Key.Key_PageDown), self, context=wdgctx).activated.connect(self.listPageDown)
        QShortcut(QKeySequence(Qt.Key.Key_PageUp), self, context=wdgctx).activated.connect(self.listPageUp)

        # Home and End do not work, for some reason.
        # QShortcut(QKeySequence.MoveToEndOfDocument, self, context = wdgctx).activated.connect(self.listEnd)
        # QShortcut(QKeySequence.MoveToStartOfDocument, self, context = wdgctx).activated.connect(self.listStart)
        # QShortcut(QKeySequence(Qt.Key.Key_End), self, context = wdgctx).activated.connect(self.listEnd)
        # QShortcut(QKeySequence('Home'), self, context = wdgctx).activated.connect(self.listStart)

        QShortcut(QKeySequence(Qt.Key.Key_Enter), self, context=wdgctx).activated.connect(self.listAccept)
        QShortcut(QKeySequence(Qt.Key.Key_Return), self, context=wdgctx).activated.connect(self.listAccept)
        QShortcut(QKeySequence("Ctrl+Return"), self, context=wdgctx).activated.connect(self.listAcceptToggle)
        QShortcut(QKeySequence("Ctrl+Enter"), self, context=wdgctx).activated.connect(self.listAcceptToggle)
        QShortcut(QKeySequence("Ctrl+Space"), self, context=wdgctx).activated.connect(self.listAcceptToggle)

        QShortcut(QKeySequence(Qt.Key.Key_Escape), self, context=wdgctx).activated.connect(self.listCancel)

        # Initialize the model with the full list (assuming the text() is empty)
        # self.proxyFilterModel(self.text()) # This is done by refreshItemGroups on focusInEvent, because the initial loading from cache can take time
        self.firstShowList = True
        self.isInitialized = True
        return self

    @staticmethod
    def proxyMousePressEvent(self, event):
        if self.listView.underMouse():
            self.selectResult(mode=None, index=self.listView.currentIndex())
        else:
            event.ignore()
        return

    @staticmethod
    def proxyMouseMoveEvent(self, arg__1):
        index = self.listView.indexAt(arg__1.pos())
        self.listView.setCurrentIndex(index)

        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()
        if self.listView.isHidden():
            self.hideExtraInfo()
        return

    @staticmethod
    def refreshItemGroups(self):
        self.itemGroups = self.getItemGroups()
        self.proxyFilterModel(self.text())

    @staticmethod
    def proxyFocusInEvent(self, qFocusEvent):
        # if the extrainfo is under the cursor, don't focus but only show the list
        if self.extraInfo.underMouse():
            self.showList()
            qFocusEvent.ignore()
            return
        if self.firstShowList:
            mdl = QStandardItemModel()
            mdl.appendRow(
                [
                    QStandardItem(
                        genericToolIcon,
                        translate("SearchBar", "Please wait, loading results from cache…"),
                    ),
                    QStandardItem("0"),
                    QStandardItem("-1"),
                ]
            )
            self.proxyModel.setSourceModel(mdl)
            self.showList()
            self.firstShowList = False
            Gui.updateGui()
        global globalIgnoreFocusOut
        if not globalIgnoreFocusOut:
            self.refreshItemGroups()
        self.showList()
        super(SearchBoxLight, self).focusInEvent(qFocusEvent)
        return

    @staticmethod
    def proxyFocusOutEvent(self, qFocusEvent):
        global globalIgnoreFocusOut
        if not globalIgnoreFocusOut:
            self.hideList()
            # super(SearchBoxLight, self).focusOutEvent(qFocusEvent)

    @staticmethod
    def proxyLeaveEvent(self, qFocusEvent):
        self.clearFocus()
        self.hideList()
        return

    @staticmethod
    def movementKey(self, rowUpdate):
        currentIndex = self.listView.currentIndex()
        self.showList()
        if self.listView.isEnabled():
            currentRow = currentIndex.row()
            nbRows = self.listView.model().rowCount()
            if nbRows > 0:
                newRow = rowUpdate(currentRow, nbRows)
                index = self.listView.model().index(newRow, 0)
                self.listView.setCurrentIndex(index)

    @staticmethod
    def proxyListDown(self):
        self.movementKey(lambda current, nbRows: (current + 1) % nbRows)

    @staticmethod
    def proxyListUp(self):
        self.movementKey(lambda current, nbRows: (current - 1) % nbRows)

    @staticmethod
    def proxyListPageDown(self):
        self.movementKey(lambda current, nbRows: min(current + max(1, self.maxVisibleRows / 2), nbRows - 1))

    @staticmethod
    def proxyListPageUp(self):
        self.movementKey(lambda current, nbRows: max(current - max(1, self.maxVisibleRows / 2), 0))

    @staticmethod
    def proxyListEnd(self):
        self.movementKey(lambda current, nbRows: nbRows - 1)

    @staticmethod
    def proxyListStart(self):
        self.movementKey(lambda current, nbRows: 0)

    @staticmethod
    def acceptKey(self, mode):
        currentIndex = self.listView.currentIndex()
        self.showList()
        if currentIndex.isValid():
            self.selectResult(mode, currentIndex)

    @staticmethod
    def proxyListAccept(self):
        self.acceptKey("select")

    @staticmethod
    def proxyListAcceptToggle(self):
        self.acceptKey("toggle")

    @staticmethod
    def cancelKey(self):
        self.hideList()
        self.clearFocus()

    # QKeySequence::Cancel
    @staticmethod
    def proxyListCancel(self):
        self.cancelKey()

    @staticmethod
    def proxyKeyPressEvent(self, qKeyEvent):
        key = qKeyEvent.key()
        modifiers = qKeyEvent.modifiers()
        self.showList()
        if key == Qt.Key.Key_Home and modifiers & Qt.Key.CTRL != 0:
            self.listStart()
        elif key == Qt.Key.Key_End and modifiers & Qt.Key.CTRL != 0:
            self.listEnd()
        else:
            super(SearchBoxLight, self).keyPressEvent(qKeyEvent)

    @staticmethod
    def showList(self):
        self.setFloatingWidgetsGeometry()
        if not self.listView.isVisible():
            self.listView.show()
        self.showExtraInfo()

    @staticmethod
    def hideList(self):
        self.listView.hide()
        self.hideExtraInfo()

    @staticmethod
    def hideExtraInfo(self):
        self.extraInfo.hide()

    @staticmethod
    def selectResult(self, mode: None, index):
        groupId = 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.proxyFilterModel(self.text())
        # TODO: emit index relative to the base model
        self.resultSelected.emit(index, groupId)

    @staticmethod
    def proxyFilterModel(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:
                #     self.index = 0
                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 = 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(
                    [
                        QStandardItem(group["icon"] or genericToolIcon, group["text"]),
                        QStandardItem(str(depth)),
                        QStandardItem(str(group["id"])),
                    ]
                )
                addGroups(group["subitems"], depth + 1)

        addGroups(filterGroups(self.itemGroups))
        self.proxyModel.setSourceModel(self.mdl)
        self.currentExtraInfo = None  # Unset this so that the ExtraInfo can be updated
        # TODO: try to find the already-highlighted item
        indexSelect = 1
        nbRows = self.listView.model().rowCount()
        if nbRows > 0:
            index = self.listView.model().index(indexSelect, 0)
            self.listView.setCurrentIndex(index)
            self.setExtraInfo(index)
        else:
            self.clearExtraInfo()
        # self.showList()

    @staticmethod
    def setFloatingWidgetsGeometry(self):
        def getScreenPosition(widget):
            geo = widget.geometry()
            parent = widget.parent()
            parentPos = getScreenPosition(parent) if parent is not None else QPoint(0, 0)
            return QPoint(geo.x() + parentPos.x(), geo.y() + parentPos.y())

        pos = getScreenPosition(self)
        siz = self.size()
        screen = QApplication.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)

    @staticmethod
    def proxyOnSelectionChanged(self, selected, deselected):
        # The list has .setSelectionMode(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()

    @staticmethod
    def setExtraInfo(self, index):
        if self.currentExtraInfo == (index.row(), index.column(), index.model()):
            # avoid useless updates of the extra info window; this also prevents segfaults when the widget
            # is replaced when selecting an option from the right-click context menu
            return
        self.currentExtraInfo = (index.row(), index.column(), index.model())
        # 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

    @staticmethod
    def clearExtraInfo(self):
        # TODO: just clear the contents but keep the widget visible.
        self.extraInfo.hide()

    @staticmethod
    def showExtraInfo(self):
        self.extraInfo.show()