novelWriter 2.3rc1__py3-none-any.whl → 2.4b1__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -53,15 +53,17 @@ from PyQt5.QtWidgets import (
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
 from novelwriter.common import minmax, transferCase
-from novelwriter.constants import nwKeyWords, nwLabels, nwShortcode, nwUnicode, trConst
-from novelwriter.core.index import countWords
-from novelwriter.tools.lipsum import GuiLipsum
+from novelwriter.constants import nwConst, nwKeyWords, nwShortcode, nwUnicode
 from novelwriter.core.document import NWDocument
-from novelwriter.gui.dochighlight import GuiDocHighlighter
-from novelwriter.gui.editordocument import GuiTextDocument
+from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
 from novelwriter.extensions.eventfilters import WheelEventFilter
+from novelwriter.extensions.modified import NIconToolButton
+from novelwriter.gui.dochighlight import BLOCK_META, BLOCK_TITLE
+from novelwriter.gui.editordocument import GuiTextDocument
+from novelwriter.gui.theme import STYLES_MIN_TOOLBUTTON
+from novelwriter.text.counting import standardCounter
+from novelwriter.tools.lipsum import GuiLipsum
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -99,6 +101,7 @@ class GuiDocEditor(QPlainTextEdit):
     toggleFocusModeRequest = pyqtSignal()
     requestProjectItemSelected = pyqtSignal(str, bool)
     requestProjectItemRenamed = pyqtSignal(str, str)
+    requestNewNoteCreation = pyqtSignal(str, nwItemClass)
 
     def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
@@ -142,9 +145,10 @@ class GuiDocEditor(QPlainTextEdit):
         self._qDocument = GuiTextDocument(self)
         self.setDocument(self._qDocument)
 
-        # Connect Signals
+        # Connect Editor and Document Signals
         self._qDocument.contentsChange.connect(self._docChange)
         self.selectionChanged.connect(self._updateSelectedStatus)
+        self.cursorPositionChanged.connect(self._cursorMoved)
         self.spellCheckStateChanged.connect(self._qDocument.setSpellCheckState)
 
         # Document Title
@@ -153,7 +157,7 @@ class GuiDocEditor(QPlainTextEdit):
         self.docSearch = GuiDocEditSearch(self)
         self.docToolBar = GuiDocToolBar(self)
 
-        # Connect Signals
+        # Connect Widget Signals
         self.docHeader.closeDocumentRequest.connect(self._closeCurrentDocument)
         self.docHeader.toggleToolBarRequest.connect(self._toggleToolBarVisibility)
         self.docToolBar.requestDocAction.connect(self.docAction)
@@ -184,18 +188,18 @@ class GuiDocEditor(QPlainTextEdit):
         self.followTag2.activated.connect(self._processTag)
 
         # Set Up Document Word Counter
-        self.wcTimerDoc = QTimer()
-        self.wcTimerDoc.timeout.connect(self._runDocCounter)
-        self.wcTimerDoc.setInterval(5000)
+        self.timerDoc = QTimer(self)
+        self.timerDoc.timeout.connect(self._runDocumentTasks)
+        self.timerDoc.setInterval(5000)
 
         self.wCounterDoc = BackgroundWordCounter(self)
         self.wCounterDoc.setAutoDelete(False)
         self.wCounterDoc.signals.countsReady.connect(self._updateDocCounts)
 
         # Set Up Selection Word Counter
-        self.wcTimerSel = QTimer()
-        self.wcTimerSel.timeout.connect(self._runSelCounter)
-        self.wcTimerSel.setInterval(500)
+        self.timerSel = QTimer(self)
+        self.timerSel.timeout.connect(self._runSelCounter)
+        self.timerSel.setInterval(500)
 
         self.wCounterSel = BackgroundWordCounter(self, forSelection=True)
         self.wCounterSel.setAutoDelete(False)
@@ -248,8 +252,8 @@ class GuiDocEditor(QPlainTextEdit):
         self._nwDocument = None
         self.setReadOnly(True)
         self.clear()
-        self.wcTimerDoc.stop()
-        self.wcTimerSel.stop()
+        self.timerDoc.stop()
+        self.timerSel.stop()
 
         self._docHandle  = None
         self._lastEdit   = 0.0
@@ -258,7 +262,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._doReplace  = False
 
         self.setDocumentChanged(False)
-        self.docHeader.setTitleFromHandle(self._docHandle)
+        self.docHeader.clearHeader()
         self.docFooter.setHandle(self._docHandle)
         self.docToolBar.setVisible(False)
 
@@ -362,7 +366,7 @@ class GuiDocEditor(QPlainTextEdit):
         # which makes it read only.
         if self._docHandle:
             self._qDocument.syntaxHighlighter.rehighlight()
-            self.docHeader.setTitleFromHandle(self._docHandle)
+            self.docHeader.setHandle(self._docHandle)
         else:
             self.clearEditor()
 
@@ -396,12 +400,10 @@ class GuiDocEditor(QPlainTextEdit):
 
         self._lastEdit = time()
         self._lastActive = time()
-        self._runDocCounter()
-        self.wcTimerDoc.start()
+        self._runDocumentTasks()
+        self.timerDoc.start()
 
         self.setReadOnly(False)
-        self.docHeader.setTitleFromHandle(self._docHandle)
-        self.docFooter.setHandle(self._docHandle)
         self.updateDocMargins()
 
         if tLine is None and self._nwItem is not None:
@@ -409,7 +411,8 @@ class GuiDocEditor(QPlainTextEdit):
         elif isinstance(tLine, int):
             self.setCursorLine(tLine)
 
-        self.docFooter.updateLineCount()
+        self.docHeader.setHandle(tHandle)
+        self.docFooter.setHandle(tHandle)
 
         # This is a hack to fix invisible cursor on an empty document
         if self._qDocument.characterCount() <= 1:
@@ -432,7 +435,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def updateTagHighLighting(self) -> None:
         """Rerun the syntax highlighter on all meta data lines."""
-        self._qDocument.syntaxHighlighter.rehighlightByType(GuiDocHighlighter.BLOCK_META)
+        self._qDocument.syntaxHighlighter.rehighlightByType(BLOCK_META)
         return
 
     def replaceText(self, text: str) -> None:
@@ -462,7 +465,7 @@ class GuiDocEditor(QPlainTextEdit):
             return False
 
         docText = self.getText()
-        cC, wC, pC = countWords(docText)
+        cC, wC, pC = standardCounter(docText)
         self._updateDocCounts(cC, wC, pC)
 
         self.saveCursorPosition()
@@ -548,8 +551,8 @@ class GuiDocEditor(QPlainTextEdit):
         sH = hBar.height() if hBar.isVisible() else 0
 
         tM = self._vpMargin
-        if CONFIG.textWidth > 0 or self.mainGui.isFocusMode:
-            tW = CONFIG.getTextWidth(self.mainGui.isFocusMode)
+        if CONFIG.textWidth > 0 or SHARED.focusMode:
+            tW = CONFIG.getTextWidth(SHARED.focusMode)
             tM = max((wW - sW - tW)//2, self._vpMargin)
 
         tB = self.frameWidth()
@@ -600,13 +603,15 @@ class GuiDocEditor(QPlainTextEdit):
     #  Setters
     ##
 
-    def setDocumentChanged(self, state: bool) -> bool:
+    def setDocumentChanged(self, state: bool) -> None:
         """Keep track of the document changed variable, and emit the
         document change signal.
         """
-        self._docChanged = state
-        self.editedStatusChanged.emit(self._docChanged)
-        return self._docChanged
+        if self._docChanged != state:
+            logger.debug("Document changed status is '%s'", state)
+            self._docChanged = state
+            self.editedStatusChanged.emit(self._docChanged)
+        return
 
     def setCursorPosition(self, position: int) -> None:
         """Move the cursor to a given position in the document."""
@@ -616,7 +621,6 @@ class GuiDocEditor(QPlainTextEdit):
             cursor.setPosition(minmax(position, 0, nChars-1))
             self.setTextCursor(cursor)
             self.centerCursor()
-            self.docFooter.updateLineCount()
         return
 
     def saveCursorPosition(self) -> None:
@@ -635,6 +639,14 @@ class GuiDocEditor(QPlainTextEdit):
                 logger.debug("Cursor moved to line %d", line)
         return
 
+    def setCursorSelection(self, selStart: int, selLength: int) -> None:
+        """Make a text selection."""
+        cursor = self.textCursor()
+        cursor.setPosition(selStart, QTextCursor.MoveMode.MoveAnchor)
+        cursor.setPosition(selStart + selLength, QTextCursor.MoveMode.KeepAnchor)
+        self.setTextCursor(cursor)
+        return
+
     ##
     #  Spell Checking
     ##
@@ -745,6 +757,8 @@ class GuiDocEditor(QPlainTextEdit):
             self._formatBlock(nwDocAction.BLOCK_TTL)
         elif action == nwDocAction.BLOCK_UNN:
             self._formatBlock(nwDocAction.BLOCK_UNN)
+        elif action == nwDocAction.BLOCK_HSC:
+            self._formatBlock(nwDocAction.BLOCK_HSC)
         elif action == nwDocAction.REPL_SNG:
             self._replaceQuotes("'", self._typSQuoteO, self._typSQuoteC)
         elif action == nwDocAction.REPL_DBL:
@@ -769,6 +783,8 @@ class GuiDocEditor(QPlainTextEdit):
             self._wrapSelection(nwShortcode.STRIKE_O, nwShortcode.STRIKE_C)
         elif action == nwDocAction.SC_ULINE:
             self._wrapSelection(nwShortcode.ULINE_O, nwShortcode.ULINE_C)
+        elif action == nwDocAction.SC_MARK:
+            self._wrapSelection(nwShortcode.MARK_O, nwShortcode.MARK_C)
         elif action == nwDocAction.SC_SUP:
             self._wrapSelection(nwShortcode.SUP_O, nwShortcode.SUP_C)
         elif action == nwDocAction.SC_SUB:
@@ -785,11 +801,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def anyFocus(self) -> bool:
         """Check if any widget or child widget has focus."""
-        if self.hasFocus():
-            return True
-        if self.isAncestorOf(qApp.focusWidget()):
-            return True
-        return False
+        return self.hasFocus() or self.isAncestorOf(qApp.focusWidget())
 
     def revealLocation(self) -> None:
         """Tell the user where on the file system the file in the editor
@@ -947,8 +959,6 @@ class GuiDocEditor(QPlainTextEdit):
         else:
             super().keyPressEvent(event)
 
-        self.docFooter.updateLineCount()
-
         return
 
     def focusNextPrevChild(self, next: bool) -> bool:
@@ -971,7 +981,6 @@ class GuiDocEditor(QPlainTextEdit):
         if qApp.keyboardModifiers() == Qt.KeyboardModifier.ControlModifier:
             self._processTag(self.cursorForPosition(event.pos()))
         super().mouseReleaseEvent(event)
-        self.docFooter.updateLineCount()
         return
 
     def resizeEvent(self, event: QResizeEvent) -> None:
@@ -991,8 +1000,8 @@ class GuiDocEditor(QPlainTextEdit):
         """Called when an item label is changed to check if the document
         title bar needs updating,
         """
-        if tHandle == self._docHandle:
-            self.docHeader.setTitleFromHandle(self._docHandle)
+        if tHandle and tHandle == self._docHandle:
+            self.docHeader.setHandle(tHandle)
             self.docFooter.updateInfo()
             self.updateDocMargins()
         return
@@ -1033,32 +1042,35 @@ class GuiDocEditor(QPlainTextEdit):
         if not self._docChanged:
             self.setDocumentChanged(removed != 0 or added != 0)
 
-        if not self.wcTimerDoc.isActive():
-            self.wcTimerDoc.start()
-
-        block = self._qDocument.findBlock(pos)
-        if not block.isValid():
-            return
+        if not self.timerDoc.isActive():
+            self.timerDoc.start()
 
-        text = block.text()
-        if text.startswith("@") and added + removed == 1:
-            # Only run on single keypresses, otherwise it will trigger
-            # at unwanted times when other changes are made to the document
-            cursor = self.textCursor()
-            bPos = cursor.positionInBlock()
-            if bPos > 0:
-                show = self._completer.updateText(text, bPos)
-                point = self.cursorRect().bottomRight()
-                self._completer.move(self.viewport().mapToGlobal(point))
-                self._completer.setVisible(show)
-        else:
-            self._completer.setVisible(False)
+        if (block := self._qDocument.findBlock(pos)).isValid():
+            text = block.text()
+            if text.startswith("@") and added + removed == 1:
+                # Only run on single keypresses, otherwise it will trigger
+                # at unwanted times when other changes are made to the document
+                cursor = self.textCursor()
+                bPos = cursor.positionInBlock()
+                if bPos > 0:
+                    show = self._completer.updateText(text, bPos)
+                    point = self.cursorRect().bottomRight()
+                    self._completer.move(self.viewport().mapToGlobal(point))
+                    self._completer.setVisible(show)
+            else:
+                self._completer.setVisible(False)
 
         if self._doReplace and added == 1:
             self._docAutoReplace(text)
 
         return
 
+    @pyqtSlot()
+    def _cursorMoved(self):
+        """Triggered when the cursor moved in the editor."""
+        self.docFooter.updateLineCount(self.textCursor())
+        return
+
     @pyqtSlot(int, int, str)
     def _insertCompletion(self, pos: int, length: int, text: str) -> None:
         """Insert choice from the completer menu."""
@@ -1081,7 +1093,7 @@ class GuiDocEditor(QPlainTextEdit):
 
         ctxMenu = QMenu(self)
         ctxMenu.setObjectName("ContextMenu")
-        if pBlock.userState() == GuiDocHighlighter.BLOCK_TITLE:
+        if pBlock.userState() == BLOCK_TITLE:
             action = ctxMenu.addAction(self.tr("Set as Document Name"))
             action.triggered.connect(lambda: self._emitRenameItem(pBlock))
 
@@ -1176,10 +1188,8 @@ class GuiDocEditor(QPlainTextEdit):
         return
 
     @pyqtSlot()
-    def _runDocCounter(self) -> None:
-        """Decide whether to run the word counter, or not due to
-        inactivity.
-        """
+    def _runDocumentTasks(self) -> None:
+        """Run timer document tasks."""
         if self._docHandle is None:
             return
 
@@ -1190,25 +1200,23 @@ class GuiDocEditor(QPlainTextEdit):
         if time() - self._lastEdit < 25.0:
             logger.debug("Running word counter")
             SHARED.runInThreadPool(self.wCounterDoc)
+            self.docHeader.setOutline({
+                block.blockNumber(): block.text()
+                for block in self._qDocument.iterBlockByType(BLOCK_TITLE, maxCount=30)
+            })
 
         return
 
     @pyqtSlot(int, int, int)
     def _updateDocCounts(self, cCount: int, wCount: int, pCount: int) -> None:
         """Process the word counter's finished signal."""
-        if self._docHandle is None or self._nwItem is None:
-            return
-
-        logger.debug("Updating word count")
-
-        self._nwItem.setCharCount(cCount)
-        self._nwItem.setWordCount(wCount)
-        self._nwItem.setParaCount(pCount)
-
-        # Must not be emitted if docHandle is None!
-        self.docCountsChanged.emit(self._docHandle, cCount, wCount, pCount)
-        self.docFooter.updateCounts()
-
+        if self._docHandle and self._nwItem:
+            logger.debug("Updating word count")
+            self._nwItem.setCharCount(cCount)
+            self._nwItem.setWordCount(wCount)
+            self._nwItem.setParaCount(pCount)
+            self.docCountsChanged.emit(self._docHandle, cCount, wCount, pCount)
+            self.docFooter.updateWordCount(wCount, False)
         return
 
     @pyqtSlot()
@@ -1217,13 +1225,11 @@ class GuiDocEditor(QPlainTextEdit):
         information to the footer, and start the selection word counter.
         """
         if self.textCursor().hasSelection():
-            if not self.wcTimerSel.isActive():
-                self.wcTimerSel.start()
-            self.docFooter.setHasSelection(True)
+            if not self.timerSel.isActive():
+                self.timerSel.start()
         else:
-            self.wcTimerSel.stop()
-            self.docFooter.setHasSelection(False)
-            self.docFooter.updateCounts()
+            self.timerSel.stop()
+            self.docFooter.updateWordCount(0, False)
         return
 
     @pyqtSlot()
@@ -1243,13 +1249,10 @@ class GuiDocEditor(QPlainTextEdit):
     @pyqtSlot(int, int, int)
     def _updateSelCounts(self, cCount: int, wCount: int, pCount: int) -> None:
         """Update the counts on the counter's finished signal."""
-        if self._docHandle is None or self._nwItem is None:
-            return
-
-        logger.debug("User selected %d words", wCount)
-        self.docFooter.updateCounts(wCount=wCount, cCount=cCount)
-        self.wcTimerSel.stop()
-
+        if self._docHandle and self._nwItem:
+            logger.debug("User selected %d words", wCount)
+            self.docFooter.updateWordCount(wCount, True)
+            self.timerSel.stop()
         return
 
     @pyqtSlot()
@@ -1311,6 +1314,7 @@ class GuiDocEditor(QPlainTextEdit):
                     self._docHandle, wrapAround=self.docSearch.doLoop
                 )
                 self.beginSearch()
+                self.setFocus()
             return
 
         cursor = self.textCursor()
@@ -1331,6 +1335,7 @@ class GuiDocEditor(QPlainTextEdit):
                     self._docHandle, wrapAround=self.docSearch.doLoop
                 )
                 self.beginSearch()
+                self.setFocus()
                 return
             else:
                 resIdx = 0 if doLoop else maxIdx
@@ -1339,7 +1344,6 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.setPosition(resE[resIdx], QTextCursor.MoveMode.KeepAnchor)
         self.setTextCursor(cursor)
 
-        self.docFooter.updateLineCount()
         self.docSearch.setResultCount(resIdx + 1, len(resS))
         self._lastFind = (resS[resIdx], resE[resIdx])
 
@@ -1370,9 +1374,10 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.setPosition(0)
         self.setTextCursor(cursor)
 
-        # Search up to a maximum of 1000, and make sure certain special
-        # searches like a regex search for .* don't loop infinitely
-        while self.find(searchFor, findOpt) and len(resE) <= 1000:
+        # Search up to a maximum of MAX_SEARCH_RESULT, and make sure
+        # certain special searches like a regex search for .* don't loop
+        # infinitely
+        while self.find(searchFor, findOpt) and len(resE) <= nwConst.MAX_SEARCH_RESULT:
             cursor = self.textCursor()
             if cursor.hasSelection():
                 resS.append(cursor.selectionStart())
@@ -1436,13 +1441,7 @@ class GuiDocEditor(QPlainTextEdit):
 
         # Make sure the selected text was selected by an actual find
         # call, and not the user.
-        try:
-            isFind  = self._lastFind[0] == cursor.selectionStart()
-            isFind &= self._lastFind[1] == cursor.selectionEnd()
-        except Exception:
-            isFind = False
-
-        if isFind:
+        if self._lastFind == (cursor.selectionStart(), cursor.selectionEnd()):
             cursor.beginEditBlock()
             cursor.removeSelectedText()
             cursor.insertText(replWith)
@@ -1451,10 +1450,8 @@ class GuiDocEditor(QPlainTextEdit):
             self.setTextCursor(cursor)
             logger.debug(
                 "Replaced occurrence of '%s' with '%s' on line %d",
-                searchFor, replWith, cursor.blockNumber()
+                searchFor, replWith, cursor.blockNumber() + 1
             )
-        else:
-            logger.error("The selected text is not a search result, skipping replace")
 
         self.findNext()
 
@@ -1670,6 +1667,9 @@ class GuiDocEditor(QPlainTextEdit):
         elif text.startswith("##! "):
             temp = text[4:]
             offset = 4
+        elif text.startswith("###! "):
+            temp = text[5:]
+            offset = 5
         elif text.startswith(">> "):
             temp = text[3:]
             offset = 3
@@ -1721,6 +1721,9 @@ class GuiDocEditor(QPlainTextEdit):
         elif action == nwDocAction.BLOCK_UNN:
             text = f"##! {temp}"
             offset -= 4
+        elif action == nwDocAction.BLOCK_HSC:
+            text = f"###! {temp}"
+            offset -= 5
         elif action == nwDocAction.ALIGN_L:
             text = f"{temp} <<"
         elif action == nwDocAction.ALIGN_C:
@@ -1867,7 +1870,10 @@ class GuiDocEditor(QPlainTextEdit):
         if text.startswith("@") and self._docHandle:
 
             isGood, tBits, tPos = SHARED.project.index.scanThis(text)
-            if not isGood or not tBits or tBits[0] == nwKeyWords.TAG_KEY:
+            if (
+                not isGood or not tBits or tBits[0] == nwKeyWords.TAG_KEY
+                or tBits[0] not in nwKeyWords.VALID_KEYS
+            ):
                 return nwTrinary.NEUTRAL
 
             tag = ""
@@ -1895,13 +1901,9 @@ class GuiDocEditor(QPlainTextEdit):
                     "Do you want to create a new project note for the tag '{0}'?"
                 ).format(tag)):
                     itemClass = nwKeyWords.KEY_CLASS.get(tBits[0], nwItemClass.NO_CLASS)
-                    if SHARED.mainGui.projView.createNewNote(tag, itemClass):
-                        self._qDocument.syntaxHighlighter.rehighlightBlock(block)
-                    else:
-                        SHARED.error(self.tr(
-                            "Could not create note in a root folder for '{0}'. "
-                            "If one doesn't exist, you must create one first."
-                        ).format(trConst(nwLabels.CLASS_NAME[itemClass])))
+                    self.requestNewNoteCreation.emit(tag, itemClass)
+                    qApp.processEvents()
+                    self._qDocument.syntaxHighlighter.rehighlightBlock(block)
 
             return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
 
@@ -2224,7 +2226,7 @@ class BackgroundWordCounter(QRunnable):
         else:
             text = self._docEditor.getText()
 
-        cC, wC, pC = countWords(text)
+        cC, wC, pC = standardCounter(text)
         self.signals.countsReady.emit(cC, wC, pC)
         self._isRunning = False
 
@@ -2313,6 +2315,13 @@ class GuiDocToolBar(QWidget):
             lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
         )
 
+        self.tbMark = QToolButton(self)
+        self.tbMark.setIconSize(iconSize)
+        self.tbMark.setToolTip(self.tr("Shortcode Highlight"))
+        self.tbMark.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_MARK)
+        )
+
         self.tbSuperscript = QToolButton(self)
         self.tbSuperscript.setIconSize(iconSize)
         self.tbSuperscript.setToolTip(self.tr("Shortcode Superscript"))
@@ -2339,6 +2348,7 @@ class GuiDocToolBar(QWidget):
         self.outerBox.addWidget(self.tbItalic)
         self.outerBox.addWidget(self.tbStrike)
         self.outerBox.addWidget(self.tbUnderline)
+        self.outerBox.addWidget(self.tbMark)
         self.outerBox.addWidget(self.tbSuperscript)
         self.outerBox.addWidget(self.tbSubscript)
         self.outerBox.setContentsMargins(cM, cM, cM, cM)
@@ -2369,6 +2379,7 @@ class GuiDocToolBar(QWidget):
         self.tbItalic.setIcon(SHARED.theme.getIcon("fmt_italic"))
         self.tbStrike.setIcon(SHARED.theme.getIcon("fmt_strike"))
         self.tbUnderline.setIcon(SHARED.theme.getIcon("fmt_underline"))
+        self.tbMark.setIcon(SHARED.theme.getIcon("fmt_mark"))
         self.tbSuperscript.setIcon(SHARED.theme.getIcon("fmt_superscript"))
         self.tbSubscript.setIcon(SHARED.theme.getIcon("fmt_subscript"))
 
@@ -2605,8 +2616,10 @@ class GuiDocEditSearch(QFrame):
 
     def setResultCount(self, currRes: int | None, resCount: int | None) -> None:
         """Set the count values for the current search."""
+        lim = nwConst.MAX_SEARCH_RESULT
+        numCount = f"{lim:n}+" if (resCount or 0) > lim else f"{resCount:n}"
         sCurrRes = "?" if currRes is None else str(currRes)
-        sResCount = "?" if resCount is None else "1000+" if resCount > 1000 else str(resCount)
+        sResCount = "?" if resCount is None else numCount
         minWidth = SHARED.theme.getTextWidth(f"{sResCount}//{sResCount}", self.boxFont)
         self.resultLabel.setText(f"{sCurrRes}/{sResCount}")
         self.resultLabel.setMinimumWidth(minWidth)
@@ -2706,11 +2719,9 @@ class GuiDocEditSearch(QFrame):
     @pyqtSlot()
     def _doSearch(self) -> None:
         """Call the search action function for the document editor."""
-        modKey = qApp.keyboardModifiers()
-        if modKey == Qt.KeyboardModifier.ShiftModifier:
-            self.docEditor.findNext(goBack=True)
-        else:
-            self.docEditor.findNext()
+        self.docEditor.findNext(goBack=(
+            qApp.keyboardModifiers() == Qt.KeyboardModifier.ShiftModifier)
+        )
         return
 
     @pyqtSlot()
@@ -2801,84 +2812,81 @@ class GuiDocEditHeader(QWidget):
         logger.debug("Create: GuiDocEditHeader")
 
         self.docEditor = docEditor
-        self.mainGui   = docEditor.mainGui
 
         self._docHandle = None
+        self._docOutline: dict[int, str] = {}
 
-        fPx = int(0.9*SHARED.theme.fontPixelSize)
-        hSp = CONFIG.pxInt(6)
-        iconSize = QSize(fPx, fPx)
+        iPx = SHARED.theme.baseIconSize
+        mPx = CONFIG.pxInt(4)
 
         # Main Widget Settings
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.itemTitle = QLabel()
-        self.itemTitle.setText("")
+        self.itemTitle = QLabel("", self)
         self.itemTitle.setIndent(0)
         self.itemTitle.setMargin(0)
         self.itemTitle.setContentsMargins(0, 0, 0, 0)
         self.itemTitle.setAutoFillBackground(True)
         self.itemTitle.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
-        self.itemTitle.setFixedHeight(fPx)
+        self.itemTitle.setFixedHeight(iPx)
 
         lblFont = self.itemTitle.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
         self.itemTitle.setFont(lblFont)
 
+        # Other Widgets
+        self.outlineMenu = QMenu(self)
+
         # Buttons
-        self.tbButton = QToolButton(self)
-        self.tbButton.setContentsMargins(0, 0, 0, 0)
-        self.tbButton.setIconSize(iconSize)
-        self.tbButton.setFixedSize(fPx, fPx)
-        self.tbButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.tbButton = NIconToolButton(self, iPx)
         self.tbButton.setVisible(False)
         self.tbButton.setToolTip(self.tr("Toggle Tool Bar"))
         self.tbButton.clicked.connect(lambda: self.toggleToolBarRequest.emit())
 
-        self.searchButton = QToolButton(self)
-        self.searchButton.setContentsMargins(0, 0, 0, 0)
-        self.searchButton.setIconSize(iconSize)
-        self.searchButton.setFixedSize(fPx, fPx)
-        self.searchButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.outlineButton = NIconToolButton(self, iPx)
+        self.outlineButton.setVisible(False)
+        self.outlineButton.setToolTip(self.tr("Outline"))
+        self.outlineButton.setMenu(self.outlineMenu)
+
+        self.searchButton = NIconToolButton(self, iPx)
         self.searchButton.setVisible(False)
         self.searchButton.setToolTip(self.tr("Search"))
         self.searchButton.clicked.connect(self.docEditor.toggleSearch)
 
-        self.minmaxButton = QToolButton(self)
-        self.minmaxButton.setContentsMargins(0, 0, 0, 0)
-        self.minmaxButton.setIconSize(iconSize)
-        self.minmaxButton.setFixedSize(fPx, fPx)
-        self.minmaxButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.minmaxButton = NIconToolButton(self, iPx)
         self.minmaxButton.setVisible(False)
         self.minmaxButton.setToolTip(self.tr("Toggle Focus Mode"))
         self.minmaxButton.clicked.connect(lambda: self.docEditor.toggleFocusModeRequest.emit())
 
-        self.closeButton = QToolButton(self)
-        self.closeButton.setContentsMargins(0, 0, 0, 0)
-        self.closeButton.setIconSize(iconSize)
-        self.closeButton.setFixedSize(fPx, fPx)
-        self.closeButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.closeButton = NIconToolButton(self, iPx)
         self.closeButton.setVisible(False)
         self.closeButton.setToolTip(self.tr("Close"))
         self.closeButton.clicked.connect(self._closeDocument)
 
         # Assemble Layout
         self.outerBox = QHBoxLayout()
-        self.outerBox.setSpacing(hSp)
         self.outerBox.addWidget(self.tbButton, 0)
+        self.outerBox.addWidget(self.outlineButton, 0)
         self.outerBox.addWidget(self.searchButton, 0)
+        self.outerBox.addSpacing(mPx)
         self.outerBox.addWidget(self.itemTitle, 1)
+        self.outerBox.addSpacing(mPx)
+        self.outerBox.addSpacing(iPx)
         self.outerBox.addWidget(self.minmaxButton, 0)
         self.outerBox.addWidget(self.closeButton, 0)
+        self.outerBox.setContentsMargins(mPx, mPx, mPx, mPx)
+        self.outerBox.setSpacing(0)
+
         self.setLayout(self.outerBox)
 
+        # Other Signals
+        SHARED.focusModeChanged.connect(self._focusModeChanged)
+
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
-        cM = CONFIG.pxInt(8)
         self.setContentsMargins(0, 0, 0, 0)
-        self.outerBox.setContentsMargins(cM, cM, cM, cM)
-        self.setMinimumHeight(fPx + 2*cM)
+        self.setMinimumHeight(iPx + 2*mPx)
 
         self.updateTheme()
 
@@ -2890,20 +2898,45 @@ class GuiDocEditHeader(QWidget):
     #  Methods
     ##
 
+    def clearHeader(self) -> None:
+        """Clear the header."""
+        self._docHandle = None
+        self._docOutline = {}
+
+        self.itemTitle.setText("")
+        self.outlineMenu.clear()
+        self.tbButton.setVisible(False)
+        self.outlineButton.setVisible(False)
+        self.searchButton.setVisible(False)
+        self.closeButton.setVisible(False)
+        self.minmaxButton.setVisible(False)
+        return
+
+    def setOutline(self, data: dict[int, str]) -> None:
+        """Set the document outline dataset."""
+        if data != self._docOutline:
+            tStart = time()
+            self.outlineMenu.clear()
+            for number, text in data.items():
+                action = self.outlineMenu.addAction(text)
+                action.triggered.connect(
+                    lambda _, number=number: self._gotoBlock(number)
+                )
+            self._docOutline = data
+            logger.debug("Document outline updated in %.3f ms", 1000*(time() - tStart))
+        return
+
     def updateTheme(self) -> None:
         """Update theme elements."""
         self.tbButton.setIcon(SHARED.theme.getIcon("menu"))
+        self.outlineButton.setIcon(SHARED.theme.getIcon("list"))
         self.searchButton.setIcon(SHARED.theme.getIcon("search"))
         self.minmaxButton.setIcon(SHARED.theme.getIcon("maximise"))
         self.closeButton.setIcon(SHARED.theme.getIcon("close"))
 
-        colText = SHARED.theme.colText
-        buttonStyle = (
-            "QToolButton {{border: none; background: transparent;}} "
-            "QToolButton:hover {{border: none; background: rgba({0}, {1}, {2}, 0.2);}}"
-        ).format(colText.red(), colText.green(), colText.blue())
-
+        buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
         self.tbButton.setStyleSheet(buttonStyle)
+        self.outlineButton.setStyleSheet(buttonStyle)
         self.searchButton.setStyleSheet(buttonStyle)
         self.minmaxButton.setStyleSheet(buttonStyle)
         self.closeButton.setStyleSheet(buttonStyle)
@@ -2926,51 +2959,25 @@ class GuiDocEditHeader(QWidget):
 
         return
 
-    def setTitleFromHandle(self, tHandle: str | None) -> bool:
+    def setHandle(self, tHandle: str) -> None:
         """Set the document title from the handle, or alternatively, set
         the whole document path within the project.
         """
         self._docHandle = tHandle
-        if tHandle is None:
-            self.itemTitle.setText("")
-            self.tbButton.setVisible(False)
-            self.searchButton.setVisible(False)
-            self.closeButton.setVisible(False)
-            self.minmaxButton.setVisible(False)
-            return True
-
-        pTree = SHARED.project.tree
+
         if CONFIG.showFullPath:
-            tTitle = []
-            tTree = pTree.getItemPath(tHandle)
-            for aHandle in reversed(tTree):
-                nwItem = pTree[aHandle]
-                if nwItem is not None:
-                    tTitle.append(nwItem.itemName)
-            sSep = "  %s  " % nwUnicode.U_RSAQUO
-            self.itemTitle.setText(sSep.join(tTitle))
+            self.itemTitle.setText(f"  {nwUnicode.U_RSAQUO}  ".join(reversed(
+                [name for name in SHARED.project.tree.getItemPath(tHandle, asName=True)]
+            )))
         else:
-            nwItem = pTree[tHandle]
-            if nwItem is None:
-                return False
-            self.itemTitle.setText(nwItem.itemName)
+            self.itemTitle.setText(i.itemName if (i := SHARED.project.tree[tHandle]) else "")
 
         self.tbButton.setVisible(True)
         self.searchButton.setVisible(True)
+        self.outlineButton.setVisible(True)
         self.closeButton.setVisible(True)
         self.minmaxButton.setVisible(True)
 
-        return True
-
-    def updateFocusMode(self) -> None:
-        """Update the minimise/maximise icon of the Focus Mode button.
-        This function is called by the GuiMain class via the
-        toggleFocusMode function and should not be activated directly.
-        """
-        if self.mainGui.isFocusMode:
-            self.minmaxButton.setIcon(SHARED.theme.getIcon("minimise"))
-        else:
-            self.minmaxButton.setIcon(SHARED.theme.getIcon("maximise"))
         return
 
     ##
@@ -2980,11 +2987,20 @@ class GuiDocEditHeader(QWidget):
     @pyqtSlot()
     def _closeDocument(self) -> None:
         """Trigger the close editor on the main window."""
+        self.clearHeader()
         self.closeDocumentRequest.emit()
-        self.tbButton.setVisible(False)
-        self.searchButton.setVisible(False)
-        self.closeButton.setVisible(False)
-        self.minmaxButton.setVisible(False)
+        return
+
+    @pyqtSlot(int)
+    def _gotoBlock(self, blockNumber: int) -> None:
+        """Move cursor to a specific heading."""
+        self.docEditor.setCursorLine(blockNumber + 1)
+        return
+
+    @pyqtSlot(bool)
+    def _focusModeChanged(self, focusMode: bool) -> None:
+        """Update minimise/maximise icon of the Focus Mode button."""
+        self.minmaxButton.setIcon(SHARED.theme.getIcon("minimise" if focusMode else "maximise"))
         return
 
     ##
@@ -2996,7 +3012,7 @@ class GuiDocEditHeader(QWidget):
         selected in the project tree.
         """
         if event.button() == Qt.MouseButton.LeftButton:
-            self.docEditor.requestProjectItemSelected.emit(self._docHandle, True)
+            self.docEditor.requestProjectItemSelected.emit(self._docHandle or "", True)
         return
 
 # END Class GuiDocEditHeader
@@ -3009,26 +3025,28 @@ class GuiDocEditHeader(QWidget):
 
 class GuiDocEditFooter(QWidget):
 
-    def __init__(self, docEditor: GuiDocEditor) -> None:
-        super().__init__(parent=docEditor)
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
 
         logger.debug("Create: GuiDocEditFooter")
 
-        self.docEditor = docEditor
-
-        self._tItem     = None
+        self._tItem = None
         self._docHandle = None
 
-        self._docSelection = False
-
-        self.sPx = int(round(0.9*SHARED.theme.baseIconSize))
+        iPx = round(0.9*SHARED.theme.baseIconSize)
         fPx = int(0.9*SHARED.theme.fontPixelSize)
+        mPx = CONFIG.pxInt(8)
         bSp = CONFIG.pxInt(4)
         hSp = CONFIG.pxInt(6)
 
         lblFont = self.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
 
+        # Cached Translations
+        self._trLineCount = self.tr("Line: {0} ({1})")
+        self._trWordCount = self.tr("Words: {0} ({1})")
+        self._trSelectCount = self.tr("Words: {0} selected")
+
         # Main Widget Settings
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
@@ -3036,9 +3054,9 @@ class GuiDocEditFooter(QWidget):
         alLeftTop = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop
 
         # Status
-        self.statusIcon = QLabel("")
+        self.statusIcon = QLabel("", self)
         self.statusIcon.setContentsMargins(0, 0, 0, 0)
-        self.statusIcon.setFixedHeight(self.sPx)
+        self.statusIcon.setFixedHeight(iPx)
         self.statusIcon.setAlignment(alLeftTop)
 
         self.statusText = QLabel(self.tr("Status"))
@@ -3051,12 +3069,12 @@ class GuiDocEditFooter(QWidget):
         self.statusText.setFont(lblFont)
 
         # Lines
-        self.linesIcon = QLabel("")
+        self.linesIcon = QLabel("", self)
         self.linesIcon.setContentsMargins(0, 0, 0, 0)
-        self.linesIcon.setFixedHeight(self.sPx)
+        self.linesIcon.setFixedHeight(iPx)
         self.linesIcon.setAlignment(alLeftTop)
 
-        self.linesText = QLabel("")
+        self.linesText = QLabel("", self)
         self.linesText.setIndent(0)
         self.linesText.setMargin(0)
         self.linesText.setContentsMargins(0, 0, 0, 0)
@@ -3066,12 +3084,12 @@ class GuiDocEditFooter(QWidget):
         self.linesText.setFont(lblFont)
 
         # Words
-        self.wordsIcon = QLabel("")
+        self.wordsIcon = QLabel("", self)
         self.wordsIcon.setContentsMargins(0, 0, 0, 0)
-        self.wordsIcon.setFixedHeight(self.sPx)
+        self.wordsIcon.setFixedHeight(iPx)
         self.wordsIcon.setAlignment(alLeftTop)
 
-        self.wordsText = QLabel("")
+        self.wordsText = QLabel("", self)
         self.wordsText.setIndent(0)
         self.wordsText.setMargin(0)
         self.wordsText.setContentsMargins(0, 0, 0, 0)
@@ -3091,19 +3109,20 @@ class GuiDocEditFooter(QWidget):
         self.outerBox.addSpacing(hSp)
         self.outerBox.addWidget(self.wordsIcon)
         self.outerBox.addWidget(self.wordsText)
+        self.outerBox.setContentsMargins(mPx, mPx, mPx, mPx)
+
         self.setLayout(self.outerBox)
 
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
-        cM = CONFIG.pxInt(8)
         self.setContentsMargins(0, 0, 0, 0)
-        self.outerBox.setContentsMargins(cM, cM, cM, cM)
-        self.setMinimumHeight(fPx + 2*cM)
+        self.setMinimumHeight(fPx + 2*mPx)
 
         # Fix the Colours
         self.updateTheme()
-        self.updateLineCount()
-        self.updateCounts()
+
+        # Initialise Info
+        self.updateWordCount(0, False)
 
         logger.debug("Ready: GuiDocEditFooter")
 
@@ -3115,8 +3134,9 @@ class GuiDocEditFooter(QWidget):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        self.linesIcon.setPixmap(SHARED.theme.getPixmap("status_lines", (self.sPx, self.sPx)))
-        self.wordsIcon.setPixmap(SHARED.theme.getPixmap("status_stats", (self.sPx, self.sPx)))
+        iPx = round(0.9*SHARED.theme.baseIconSize)
+        self.linesIcon.setPixmap(SHARED.theme.getPixmap("status_lines", (iPx, iPx)))
+        self.wordsIcon.setPixmap(SHARED.theme.getPixmap("status_stats", (iPx, iPx)))
         self.matchColours()
         return
 
@@ -3145,27 +3165,20 @@ class GuiDocEditFooter(QWidget):
         else:
             self._tItem = SHARED.project.tree[self._docHandle]
 
-        self.setHasSelection(False)
         self.updateInfo()
-        self.updateCounts()
+        self.updateWordCount(0, False)
 
         return
 
-    def setHasSelection(self, hasSelection: bool) -> None:
-        """Toggle the word counter mode between full count and selection
-        count mode.
-        """
-        self._docSelection = hasSelection
-        return
-
     def updateInfo(self) -> None:
         """Update the content of text labels."""
         if self._tItem is None:
             sIcon = QPixmap()
             sText = ""
         else:
+            iPx = round(0.9*SHARED.theme.baseIconSize)
             status, icon = self._tItem.getImportStatus(incIcon=True)
-            sIcon = icon.pixmap(self.sPx, self.sPx)
+            sIcon = icon.pixmap(iPx, iPx)
             sText = f"{status} / {self._tItem.describeMe()}"
 
         self.statusIcon.setPixmap(sIcon)
@@ -3173,62 +3186,27 @@ class GuiDocEditFooter(QWidget):
 
         return
 
-    def updateLineCount(self) -> None:
-        """Update the line counter."""
-        if self._tItem is None:
-            iLine = 0
-            iDist = 0
-        else:
-            cursor = self.docEditor.textCursor()
-            iLine = cursor.blockNumber() + 1
-            iDist = 100*iLine/self.docEditor._qDocument.blockCount()
+    def updateLineCount(self, cursor: QTextCursor) -> None:
+        """Update the line and document position counter."""
+        cPos = cursor.position() + 1
+        cLine = cursor.blockNumber() + 1
+        cCount = max(cursor.document().characterCount(), 1)
         self.linesText.setText(
-            self.tr("Line: {0} ({1})").format(f"{iLine:n}", f"{iDist:.0f} %")
+            self._trLineCount.format(f"{cLine:n}", f"{100*cPos//cCount:d} %")
         )
         return
 
-    def updateCounts(self, wCount: int | None = None, cCount: int | None = None) -> None:
-        """Select which word count display mode to use."""
-        if self._docSelection:
-            self._updateSelectionWordCounts(wCount, cCount)
-        else:
-            self._updateWordCounts()
-        return
-
-    ##
-    #  Internal Functions
-    ##
-
-    def _updateWordCounts(self) -> None:
-        """Update the word count for the whole document."""
-        if self._tItem is None:
-            wCount = 0
-            wDiff = 0
-        else:
+    def updateWordCount(self, wCount: int, selection: bool) -> None:
+        """Update word counter information."""
+        if selection and wCount:
+            wText = self._trSelectCount.format(f"{wCount:n}")
+        elif self._tItem:
             wCount = self._tItem.wordCount
             wDiff = wCount - self._tItem.initCount
-
-        self.wordsText.setText(
-            self.tr("Words: {0} ({1})").format(f"{wCount:n}", f"{wDiff:+n}")
-        )
-
-        byteSize = self.docEditor._qDocument.characterCount()
-        self.wordsText.setToolTip(
-            self.tr("Document size is {0} bytes").format(f"{byteSize:n}")
-        )
-
-        return
-
-    def _updateSelectionWordCounts(self, wCount: int | None, cCount: int | None) -> None:
-        """Update the word count for a selection."""
-        if wCount is None or cCount is None:
-            return
-        self.wordsText.setText(
-            self.tr("Words: {0} selected").format(f"{wCount:n}")
-        )
-        self.wordsText.setToolTip(
-            self.tr("Character count: {0}").format(f"{cCount:n}")
-        )
+            wText = self._trWordCount.format(f"{wCount:n}", f"{wDiff:+n}")
+        else:
+            wText = self._trWordCount.format("0", "+0")
+        self.wordsText.setText(wText)
         return
 
 # END Class GuiDocEditFooter