novelWriter 2.3.1__py3-none-any.whl → 2.4__py3-none-any.whl

novelwriter/gui/projtree.py

@@ -32,26 +32,29 @@ from enum import Enum
 from time import time
 from typing import TYPE_CHECKING
 
+from PyQt5.QtCore import QPoint, QTimer, Qt, pyqtSignal, pyqtSlot
 from PyQt5.QtGui import (
     QDragEnterEvent, QDragMoveEvent, QDropEvent, QIcon, QMouseEvent, QPalette
 )
-from PyQt5.QtCore import QPoint, QTimer, Qt, QSize, pyqtSignal, pyqtSlot
 from PyQt5.QtWidgets import (
     QAbstractItemView, QAction, QDialog, QFrame, QHBoxLayout, QHeaderView,
-    QLabel, QMenu, QShortcut, QSizePolicy, QToolButton, QTreeWidget,
-    QTreeWidgetItem, QVBoxLayout, QWidget
+    QLabel, QMenu, QShortcut, QSizePolicy, QTreeWidget, QTreeWidgetItem,
+    QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.enum import nwDocMode, nwItemType, nwItemClass, nwItemLayout
 from novelwriter.common import minmax
 from novelwriter.constants import nwHeaders, nwUnicode, trConst, nwLabels
-from novelwriter.core.item import NWItem
 from novelwriter.core.coretools import DocDuplicator, DocMerger, DocSplitter
+from novelwriter.core.item import NWItem
 from novelwriter.dialogs.docmerge import GuiDocMerge
 from novelwriter.dialogs.docsplit import GuiDocSplit
 from novelwriter.dialogs.editlabel import GuiEditLabel
 from novelwriter.dialogs.projectsettings import GuiProjectSettings
+from novelwriter.enum import nwDocMode, nwItemType, nwItemClass, nwItemLayout
+from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
+from novelwriter.types import QtAlignLeft, QtAlignRight, QtMouseLeft, QtMouseMiddle, QtUserRole
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -142,7 +145,6 @@ class GuiProjectView(QWidget):
         self.requestDeleteItem = self.projTree.requestDeleteItem
         self.getSelectedHandle = self.projTree.getSelectedHandle
         self.changedSince = self.projTree.changedSince
-        self.createNewNote = self.projTree.createNewNote
 
         return
 
@@ -240,6 +242,12 @@ class GuiProjectView(QWidget):
         self.projBar.buildQuickLinksMenu()
         return
 
+    @pyqtSlot(str, nwItemClass)
+    def createNewNote(self, tag: str, itemClass: nwItemClass) -> None:
+        """Process new not request."""
+        self.projTree.createNewNote(tag, itemClass)
+        return
+
 # END Class GuiProjectView
 
 
@@ -256,36 +264,33 @@ class GuiProjectToolBar(QWidget):
         self.projTree = projView.projTree
         self.mainGui  = projView.mainGui
 
-        iPx = SHARED.theme.baseIconSize
+        iSz = SHARED.theme.baseIconSize
         mPx = CONFIG.pxInt(2)
 
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
 
         # Widget Label
-        self.viewLabel = QLabel("<b>%s</b>" % self.tr("Project Content"))
+        self.viewLabel = QLabel(self.tr("Project Content"), self)
+        self.viewLabel.setFont(SHARED.theme.guiFontB)
         self.viewLabel.setContentsMargins(0, 0, 0, 0)
         self.viewLabel.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
 
         # Quick Links
         self.mQuick = QMenu(self)
 
-        self.tbQuick = QToolButton(self)
+        self.tbQuick = NIconToolButton(self, iSz)
         self.tbQuick.setToolTip("%s [Ctrl+L]" % self.tr("Quick Links"))
         self.tbQuick.setShortcut("Ctrl+L")
-        self.tbQuick.setIconSize(QSize(iPx, iPx))
         self.tbQuick.setMenu(self.mQuick)
-        self.tbQuick.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
 
         # Move Buttons
-        self.tbMoveU = QToolButton(self)
+        self.tbMoveU = NIconToolButton(self, iSz)
         self.tbMoveU.setToolTip("%s [Ctrl+Up]" % self.tr("Move Up"))
-        self.tbMoveU.setIconSize(QSize(iPx, iPx))
         self.tbMoveU.clicked.connect(lambda: self.projTree.moveTreeItem(-1))
 
-        self.tbMoveD = QToolButton(self)
+        self.tbMoveD = NIconToolButton(self, iSz)
         self.tbMoveD.setToolTip("%s [Ctrl+Down]" % self.tr("Move Down"))
-        self.tbMoveD.setIconSize(QSize(iPx, iPx))
         self.tbMoveD.clicked.connect(lambda: self.projTree.moveTreeItem(1))
 
         # Add Item Menu
@@ -324,12 +329,10 @@ class GuiProjectToolBar(QWidget):
         self.mAddRoot = self.mAdd.addMenu(trConst(nwLabels.ITEM_DESCRIPTION["root"]))
         self._buildRootMenu()
 
-        self.tbAdd = QToolButton(self)
+        self.tbAdd = NIconToolButton(self, iSz)
         self.tbAdd.setToolTip("%s [Ctrl+N]" % self.tr("Add Item"))
         self.tbAdd.setShortcut("Ctrl+N")
-        self.tbAdd.setIconSize(QSize(iPx, iPx))
         self.tbAdd.setMenu(self.mAdd)
-        self.tbAdd.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
 
         # More Options Menu
         self.mMore = QMenu(self)
@@ -343,11 +346,9 @@ class GuiProjectToolBar(QWidget):
         self.aEmptyTrash = self.mMore.addAction(self.tr("Empty Trash"))
         self.aEmptyTrash.triggered.connect(lambda: self.projTree.emptyTrash())
 
-        self.tbMore = QToolButton(self)
+        self.tbMore = NIconToolButton(self, iSz)
         self.tbMore.setToolTip(self.tr("More Options"))
-        self.tbMore.setIconSize(QSize(iPx, iPx))
         self.tbMore.setMenu(self.mMore)
-        self.tbMore.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
 
         # Assemble
         self.outerBox = QHBoxLayout()
@@ -377,29 +378,24 @@ class GuiProjectToolBar(QWidget):
         qPalette.setBrush(QPalette.ColorRole.Window, qPalette.base())
         self.setPalette(qPalette)
 
-        fadeCol = qPalette.text().color()
-        buttonStyle = (
-            "QToolButton {{padding: {0}px; border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({1},{2},{3},0.2);}}"
-        ).format(CONFIG.pxInt(2), fadeCol.red(), fadeCol.green(), fadeCol.blue())
-        buttonStyleMenu = f"{buttonStyle} QToolButton::menu-indicator {{image: none;}}"
-
-        self.tbQuick.setStyleSheet(buttonStyleMenu)
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
+        self.tbQuick.setStyleSheet(buttonStyle)
         self.tbMoveU.setStyleSheet(buttonStyle)
         self.tbMoveD.setStyleSheet(buttonStyle)
-        self.tbAdd.setStyleSheet(buttonStyleMenu)
-        self.tbMore.setStyleSheet(buttonStyleMenu)
+        self.tbAdd.setStyleSheet(buttonStyle)
+        self.tbMore.setStyleSheet(buttonStyle)
+
+        self.tbQuick.setThemeIcon("bookmark")
+        self.tbMoveU.setThemeIcon("up")
+        self.tbMoveD.setThemeIcon("down")
+        self.tbAdd.setThemeIcon("add")
+        self.tbMore.setThemeIcon("menu")
 
-        self.tbQuick.setIcon(SHARED.theme.getIcon("bookmark"))
-        self.tbMoveU.setIcon(SHARED.theme.getIcon("up"))
-        self.tbMoveD.setIcon(SHARED.theme.getIcon("down"))
         self.aAddEmpty.setIcon(SHARED.theme.getIcon("proj_document"))
         self.aAddChap.setIcon(SHARED.theme.getIcon("proj_chapter"))
         self.aAddScene.setIcon(SHARED.theme.getIcon("proj_scene"))
         self.aAddNote.setIcon(SHARED.theme.getIcon("proj_note"))
         self.aAddFolder.setIcon(SHARED.theme.getIcon("proj_folder"))
-        self.tbAdd.setIcon(SHARED.theme.getIcon("add"))
-        self.tbMore.setIcon(SHARED.theme.getIcon("menu"))
 
         self.buildQuickLinksMenu()
         self._buildRootMenu()
@@ -457,7 +453,7 @@ class GuiProjectToolBar(QWidget):
 
     def _buildRootMenu(self) -> None:
         """Build the rood folder menu."""
-        def addClass(itemClass):
+        def addClass(itemClass: nwItemClass) -> None:
             aNew = self.mAddRoot.addAction(trConst(nwLabels.CLASS_NAME[itemClass]))
             aNew.setIcon(SHARED.theme.getIcon(nwLabels.CLASS_ICON[itemClass]))
             aNew.triggered.connect(lambda: self.projTree.newTreeItem(nwItemType.ROOT, itemClass))
@@ -491,8 +487,8 @@ class GuiProjectTree(QTreeWidget):
     C_ACTIVE = 2
     C_STATUS = 3
 
-    D_HANDLE = Qt.ItemDataRole.UserRole
-    D_WORDS  = Qt.ItemDataRole.UserRole + 1
+    D_HANDLE = QtUserRole
+    D_WORDS  = QtUserRole + 1
 
     itemRefreshed = pyqtSignal(str, NWItem, QIcon)
 
@@ -522,10 +518,10 @@ class GuiProjectTree(QTreeWidget):
         self.customContextMenuRequested.connect(self._openContextMenu)
 
         # Tree Settings
-        iPx = SHARED.theme.baseIconSize
+        iPx = SHARED.theme.baseIconHeight
         cMg = CONFIG.pxInt(6)
 
-        self.setIconSize(QSize(iPx, iPx))
+        self.setIconSize(SHARED.theme.baseIconSize)
         self.setFrameStyle(QFrame.Shape.NoFrame)
         self.setUniformRowHeights(True)
         self.setAllColumnsShowFocus(True)
@@ -569,9 +565,9 @@ class GuiProjectTree(QTreeWidget):
         self.itemSelectionChanged.connect(self._treeSelectionChange)
 
         # Auto Scroll
-        self._scrollMargin = SHARED.theme.baseIconSize
+        self._scrollMargin = SHARED.theme.baseIconHeight
         self._scrollDirection = 0
-        self._scrollTimer = QTimer()
+        self._scrollTimer = QTimer(self)
         self._scrollTimer.timeout.connect(self._doAutoScroll)
         self._scrollTimer.setInterval(250)
 
@@ -606,18 +602,18 @@ class GuiProjectTree(QTreeWidget):
         self._timeChanged = 0.0
         return
 
-    def createNewNote(self, tag: str, itemClass: nwItemClass | None) -> bool:
+    def createNewNote(self, tag: str, itemClass: nwItemClass) -> None:
         """Create a new note. This function is used by the document
         editor to create note files for unknown tags.
         """
-        rHandle = SHARED.project.tree.findRoot(itemClass)
-        if rHandle:
-            tHandle = SHARED.project.newFile(tag, rHandle)
-            if tHandle:
+        if itemClass != nwItemClass.NO_CLASS:
+            if not (rHandle := SHARED.project.tree.findRoot(itemClass)):
+                self.newTreeItem(nwItemType.ROOT, itemClass)
+                rHandle = SHARED.project.tree.findRoot(itemClass)
+            if rHandle and (tHandle := SHARED.project.newFile(tag, rHandle)):
                 SHARED.project.writeNewFile(tHandle, 1, False, f"@tag: {tag}\n\n")
                 self.revealNewTreeItem(tHandle, wordCount=True)
-                return True
-        return False
+        return
 
     def newTreeItem(self, itemType: nwItemType, itemClass: nwItemClass | None = None,
                     hLevel: int = 1, isNote: bool = False, copyDoc: str | None = None) -> bool:
@@ -1234,7 +1230,7 @@ class GuiProjectTree(QTreeWidget):
         else:
             ctxMenu.buildSingleSelectMenu(hasChild)
 
-        ctxMenu.exec_(self.viewport().mapToGlobal(clickPos))
+        ctxMenu.exec(self.viewport().mapToGlobal(clickPos))
         ctxMenu.deleteLater()
 
         return True
@@ -1260,11 +1256,11 @@ class GuiProjectTree(QTreeWidget):
         for viewing if the user middle-clicked.
         """
         super().mousePressEvent(event)
-        if event.button() == Qt.MouseButton.LeftButton:
+        if event.button() == QtMouseLeft:
             selItem = self.indexAt(event.pos())
             if not selItem.isValid():
                 self.clearSelection()
-        elif event.button() == Qt.MouseButton.MiddleButton:
+        elif event.button() == QtMouseMiddle:
             selItem = self.itemAt(event.pos())
             if selItem:
                 tHandle = selItem.data(self.C_DATA, self.D_HANDLE)
@@ -1272,7 +1268,7 @@ class GuiProjectTree(QTreeWidget):
                     self.projView.openDocumentRequest.emit(tHandle, nwDocMode.VIEW, "", False)
         return
 
-    def startDrag(self, dropAction: Qt.DropActions) -> None:
+    def startDrag(self, dropAction: Qt.DropAction) -> None:
         """Capture the drag and drop handling to pop alerts."""
         super().startDrag(dropAction)
         if self._popAlert:
@@ -1414,7 +1410,7 @@ class GuiProjectTree(QTreeWidget):
             itemList.remove(tHandle)
 
         dlgMerge = GuiDocMerge(self.mainGui, tHandle, itemList)
-        dlgMerge.exec_()
+        dlgMerge.exec()
 
         if dlgMerge.result() == QDialog.DialogCode.Accepted:
 
@@ -1484,7 +1480,7 @@ class GuiProjectTree(QTreeWidget):
             return False
 
         dlgSplit = GuiDocSplit(self.mainGui, tHandle)
-        dlgSplit.exec_()
+        dlgSplit.exec()
 
         if dlgSplit.result() == QDialog.DialogCode.Accepted:
 
@@ -1591,10 +1587,10 @@ class GuiProjectTree(QTreeWidget):
         newItem.setText(self.C_ACTIVE, "")
         newItem.setText(self.C_STATUS, "")
 
-        newItem.setTextAlignment(self.C_NAME, Qt.AlignmentFlag.AlignLeft)
-        newItem.setTextAlignment(self.C_COUNT, Qt.AlignmentFlag.AlignRight)
-        newItem.setTextAlignment(self.C_ACTIVE, Qt.AlignmentFlag.AlignLeft)
-        newItem.setTextAlignment(self.C_STATUS, Qt.AlignmentFlag.AlignLeft)
+        newItem.setTextAlignment(self.C_NAME, QtAlignLeft)
+        newItem.setTextAlignment(self.C_COUNT, QtAlignRight)
+        newItem.setTextAlignment(self.C_ACTIVE, QtAlignLeft)
+        newItem.setTextAlignment(self.C_STATUS, QtAlignLeft)
 
         newItem.setData(self.C_DATA, self.D_HANDLE, tHandle)
         newItem.setData(self.C_DATA, self.D_WORDS, 0)
@@ -1834,7 +1830,7 @@ class _TreeContextMenu(QMenu):
 
     def _itemHeader(self) -> None:
         """Check if there is a header that can be used for rename."""
-        if hItem := SHARED.project.index.getItemHeader(self._handle, "T0001"):
+        if hItem := SHARED.project.index.getItemHeading(self._handle, "T0001"):
             action = self.addAction(self.tr("Rename to Heading"))
             action.triggered.connect(
                 lambda: self.projTree.renameTreeItem(self._handle, hItem.title)
@@ -1933,7 +1929,7 @@ class _TreeContextMenu(QMenu):
             action.triggered.connect(lambda: tree._mergeDocuments(tHandle, True))
 
         if isFile:
-            action = menu.addAction(self.tr("Split Document by Headers"))
+            action = menu.addAction(self.tr("Split Document by Headings"))
             action.triggered.connect(lambda: tree._splitDocument(tHandle))
 
         return
@@ -1947,11 +1943,9 @@ class _TreeContextMenu(QMenu):
             action.triggered.connect(lambda: tree.setExpandedFromHandle(tHandle, True))
             action = self.addAction(self.tr("Collapse All"))
             action.triggered.connect(lambda: tree.setExpandedFromHandle(tHandle, False))
-            action = self.addAction(self.tr("Duplicate from Here"))
-            action.triggered.connect(lambda: tree._duplicateFromHandle(tHandle))
-        elif isFile:
-            action = self.addAction(self.tr("Duplicate Document"))
-            action.triggered.connect(lambda: tree._duplicateFromHandle(tHandle))
+
+        action = self.addAction(self.tr("Duplicate"))
+        action.triggered.connect(lambda: tree._duplicateFromHandle(tHandle))
 
         if self._item.itemClass == nwItemClass.TRASH or isRoot or (isFolder and not hasChild):
             action = self.addAction(self.tr("Delete Permanently"))

novelwriter/gui/search.py

@@ -0,0 +1,362 @@
+"""
+novelWriter – GUI Project Search
+================================
+
+File History:
+Created: 2024-03-21 [2.4b1]  GuiProjectSearch
+
+This file is a part of novelWriter
+Copyright 2018–2024, Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import logging
+
+from time import time
+
+from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot
+from PyQt5.QtGui import QCursor, QKeyEvent
+from PyQt5.QtWidgets import (
+    QApplication, QFrame, QHBoxLayout, QHeaderView, QLabel, QLineEdit,
+    QToolBar, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
+)
+
+from novelwriter import CONFIG, SHARED
+from novelwriter.common import checkInt, cssCol
+from novelwriter.core.coretools import DocSearch
+from novelwriter.core.item import NWItem
+from novelwriter.types import QtAlignMiddle, QtAlignRight, QtUserRole
+
+logger = logging.getLogger(__name__)
+
+
+class GuiProjectSearch(QWidget):
+
+    C_NAME   = 0
+    C_RESULT = 0
+    C_COUNT  = 1
+
+    D_HANDLE = QtUserRole
+    D_RESULT = QtUserRole + 1
+
+    selectedItemChanged = pyqtSignal(str)
+    openDocumentSelectRequest = pyqtSignal(str, int, int, bool)
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+
+        logger.debug("Create: GuiProjectSearch")
+
+        iPx = SHARED.theme.baseIconHeight
+        iSz = SHARED.theme.baseIconSize
+        mPx = CONFIG.pxInt(2)
+        tPx = CONFIG.pxInt(4)
+
+        self._time = time()
+        self._search = DocSearch()
+        self._blocked = False
+        self._map: dict[str, tuple[int, float]] = {}
+
+        # Header
+        self.viewLabel = QLabel(self.tr("Project Search"), self)
+        self.viewLabel.setFont(SHARED.theme.guiFontB)
+        self.viewLabel.setContentsMargins(mPx, tPx, 0, mPx)
+
+        # Options
+        self.searchOpt = QToolBar(self)
+        self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.searchOpt.setIconSize(iSz)
+        self.searchOpt.setContentsMargins(0, 0, 0, 0)
+
+        self.toggleCase = self.searchOpt.addAction(self.tr("Case Sensitive"))
+        self.toggleCase.setCheckable(True)
+        self.toggleCase.setChecked(CONFIG.searchProjCase)
+        self.toggleCase.toggled.connect(self._toggleCase)
+
+        self.toggleWord = self.searchOpt.addAction(self.tr("Whole Words Only"))
+        self.toggleWord.setCheckable(True)
+        self.toggleWord.setChecked(CONFIG.searchProjWord)
+        self.toggleWord.toggled.connect(self._toggleWord)
+
+        self.toggleRegEx = self.searchOpt.addAction(self.tr("RegEx Mode"))
+        self.toggleRegEx.setCheckable(True)
+        self.toggleRegEx.setChecked(CONFIG.searchProjRegEx)
+        self.toggleRegEx.toggled.connect(self._toggleRegEx)
+
+        # Search Box
+        self.searchText = QLineEdit(self)
+        self.searchText.setPlaceholderText(self.tr("Search for"))
+        self.searchText.setClearButtonEnabled(True)
+
+        self.searchAction = self.searchText.addAction(
+            SHARED.theme.getIcon("search"), QLineEdit.ActionPosition.TrailingPosition
+        )
+        self.searchAction.triggered.connect(self._processSearch)
+
+        # Search Result
+        self.searchResult = QTreeWidget(self)
+        self.searchResult.setHeaderHidden(True)
+        self.searchResult.setColumnCount(2)
+        self.searchResult.setIconSize(iSz)
+        self.searchResult.setIndentation(iPx)
+        self.searchResult.setFrameStyle(QFrame.Shape.NoFrame)
+        self.searchResult.setUniformRowHeights(True)
+        self.searchResult.setAllColumnsShowFocus(True)
+        self.searchResult.itemDoubleClicked.connect(self._searchResultDoubleClicked)
+        self.searchResult.itemSelectionChanged.connect(self._searchResultSelected)
+
+        treeHeader = self.searchResult.header()
+        treeHeader.setStretchLastSection(False)
+        treeHeader.setSectionResizeMode(self.C_NAME, QHeaderView.ResizeMode.Stretch)
+        treeHeader.setSectionResizeMode(self.C_COUNT, QHeaderView.ResizeMode.ResizeToContents)
+
+        # Assemble
+        self.headerBox = QHBoxLayout()
+        self.headerBox.addWidget(self.viewLabel, 1)
+        self.headerBox.addWidget(self.searchOpt, 0, QtAlignMiddle)
+        self.headerBox.setContentsMargins(0, 0, 0, 0)
+        self.headerBox.setSpacing(0)
+
+        self.headerWidget = QWidget(self)
+        self.headerWidget.setLayout(self.headerBox)
+        self.headerWidget.setContentsMargins(0, 0, 0, 0)
+
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addWidget(self.headerWidget, 0)
+        self.outerBox.addWidget(self.searchText, 0)
+        self.outerBox.addWidget(self.searchResult, 1)
+        self.outerBox.setContentsMargins(0, 0, 0, 0)
+        self.outerBox.setSpacing(mPx)
+
+        self.setLayout(self.outerBox)
+        self.updateTheme()
+
+        logger.debug("Ready: GuiProjectSearch")
+
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def updateTheme(self) -> None:
+        """Update theme elements."""
+        bPx = CONFIG.pxInt(1)
+        mPx = CONFIG.pxInt(2)
+
+        qPalette = self.palette()
+        colBase = cssCol(qPalette.base().color())
+        colFocus = cssCol(qPalette.highlight().color())
+
+        self.headerWidget.setStyleSheet(f"QWidget {{background: {colBase};}}")
+        self.headerWidget.setAutoFillBackground(True)
+
+        self.setStyleSheet(
+            "QToolBar {padding: 0; background: none;} "
+            f"QLineEdit {{border: {bPx}px solid {colBase}; padding: {mPx}px;}} "
+            f"QLineEdit:focus {{border: {bPx}px solid {colFocus};}} "
+        )
+
+        self.searchAction.setIcon(SHARED.theme.getIcon("search"))
+        self.toggleCase.setIcon(SHARED.theme.getIcon("search_case"))
+        self.toggleWord.setIcon(SHARED.theme.getIcon("search_word"))
+        self.toggleRegEx.setIcon(SHARED.theme.getIcon("search_regex"))
+
+        return
+
+    def processReturn(self) -> None:
+        """Process a return keypress forwarded from the main GUI."""
+        if self.searchText.hasFocus():
+            self._processSearch()
+        elif (
+            self.searchResult.hasFocus()
+            and (items := self.searchResult.selectedItems())
+            and (data := items[0].data(0, self.D_RESULT))
+            and len(data) == 3
+        ):
+            self.openDocumentSelectRequest.emit(
+                str(data[0]), checkInt(data[1], -1), checkInt(data[2], -1), False
+            )
+        return
+
+    def beginSearch(self, text: str = "") -> None:
+        """Focus the search box and select its text, if any."""
+        self.searchText.setFocus()
+        self.searchText.selectAll()
+        if text:
+            self.searchText.setText(text.partition("\n")[0])
+            self.searchText.selectAll()
+        return
+
+    def closeProjectTasks(self) -> None:
+        """Run close project tasks."""
+        self._map = {}
+        self.searchText.clear()
+        self.searchResult.clear()
+        return
+
+    ##
+    #  Events
+    ##
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Process key press events. This handles up and down arrow key
+        presses to jump between search text box and result tree.
+        """
+        if (
+            event.key() == Qt.Key.Key_Down
+            and self.searchText.hasFocus()
+            and (first := self.searchResult.topLevelItem(0))
+        ):
+            first.setSelected(True)
+            self.searchResult.setFocus()
+        elif (
+            event.key() == Qt.Key.Key_Up
+            and self.searchResult.hasFocus()
+            and (first := self.searchResult.topLevelItem(0))
+            and first.isSelected()
+        ):
+            first.setSelected(False)
+            self.searchText.setFocus()
+        else:
+            super().keyPressEvent(event)
+        return
+
+    ##
+    #  Public Slots
+    ##
+
+    @pyqtSlot(str, float)
+    def textChanged(self, tHandle: str, timeStamp: float) -> None:
+        """Update search result for a specific document."""
+        if (entry := self._map.get(tHandle)) and timeStamp > entry[1]:
+            start = time()
+            results, capped = self._search.searchText(SHARED.mainGui.docEditor.getText())
+            self._displayResultSet(SHARED.project.tree[tHandle], results, capped)
+            logger.debug("Updated search for '%s' in %.3f ms", tHandle, 1000*(time() - start))
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot()
+    def _processSearch(self) -> None:
+        """Perform a search."""
+        if not self._blocked:
+            QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+            start = time()
+            SHARED.mainGui.saveDocument()
+            self._blocked = True
+            self._map = {}
+            self.searchResult.clear()
+            if text := self.searchText.text():
+                self._search.setUserRegEx(self.toggleRegEx.isChecked())
+                self._search.setCaseSensitive(self.toggleCase.isChecked())
+                self._search.setWholeWords(self.toggleWord.isChecked())
+                for item, results, capped in self._search.iterSearch(SHARED.project, text):
+                    self._displayResultSet(item, results, capped)
+            logger.debug("Search took %.3f ms", 1000*(time() - start))
+            self._time = time()
+            QApplication.restoreOverrideCursor()
+        self._blocked = False
+        return
+
+    @pyqtSlot()
+    def _searchResultSelected(self) -> None:
+        """Process search result selection."""
+        if items := self.searchResult.selectedItems():
+            if (data := items[0].data(0, self.D_RESULT)) and len(data) == 3:
+                self.selectedItemChanged.emit(str(data[0]))
+            elif data := items[0].data(0, self.D_HANDLE):
+                self.selectedItemChanged.emit(str(data))
+        return
+
+    @pyqtSlot("QTreeWidgetItem*", int)
+    def _searchResultDoubleClicked(self, item: QTreeWidgetItem, column: int) -> None:
+        """Process search result double click."""
+        if (data := item.data(0, self.D_RESULT)) and len(data) == 3:
+            self.openDocumentSelectRequest.emit(
+                str(data[0]), checkInt(data[1], -1), checkInt(data[2], -1), True
+            )
+        return
+
+    @pyqtSlot(bool)
+    def _toggleCase(self, state: bool) -> None:
+        """Enable/disable case sensitive mode."""
+        CONFIG.searchProjCase = state
+        return
+
+    @pyqtSlot(bool)
+    def _toggleWord(self, state: bool) -> None:
+        """Enable/disable whole word search mode."""
+        CONFIG.searchProjWord = state
+        return
+
+    @pyqtSlot(bool)
+    def _toggleRegEx(self, state: bool) -> None:
+        """Enable/disable regular expression search mode."""
+        CONFIG.searchProjRegEx = state
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _displayResultSet(
+        self, nwItem: NWItem | None, results: list[tuple[int, int, str]], capped: bool
+    ) -> None:
+        """Populate the result tree."""
+        if results and nwItem:
+            tHandle = nwItem.itemHandle
+            docIcon = SHARED.theme.getItemIcon(
+                nwItem.itemType, nwItem.itemClass,
+                nwItem.itemLayout, nwItem.mainHeading
+            )
+            ext = "+" if capped else ""
+
+            tItem = QTreeWidgetItem()
+            tItem.setText(self.C_NAME, nwItem.itemName)
+            tItem.setIcon(self.C_NAME, docIcon)
+            tItem.setData(self.C_NAME, self.D_HANDLE, tHandle)
+            tItem.setText(self.C_COUNT, f"({len(results):n}{ext})")
+            tItem.setTextAlignment(self.C_COUNT, QtAlignRight)
+            tItem.setForeground(self.C_COUNT, self.palette().highlight())
+
+            index = self._map.get(tHandle, (self.searchResult.topLevelItemCount(), 0.0))[0]
+            self.searchResult.takeTopLevelItem(index)
+            self.searchResult.insertTopLevelItem(index, tItem)
+            self._map[tHandle] = (index, time())
+
+            rItems = []
+            for start, length, context in results:
+                rItem = QTreeWidgetItem()
+                rItem.setText(0, context)
+                rItem.setData(0, self.D_RESULT, (tHandle, start, length))
+                rItems.append(rItem)
+
+            tItem.addChildren(rItems)
+            tItem.setExpanded(True)
+
+            parent = self.searchResult.indexFromItem(tItem)
+            for i in range(tItem.childCount()):
+                self.searchResult.setFirstColumnSpanned(i, parent, True)
+
+            QApplication.processEvents()
+
+        return
+
+# END Class GuiProjectSearch