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

novelwriter/gui/doceditor.py

@@ -40,28 +40,34 @@ from typing import TYPE_CHECKING
 
 from PyQt5.QtCore import (
     pyqtSignal, pyqtSlot, QObject, QPoint, QRegExp, QRegularExpression,
-    QRunnable, QSize, Qt, QTimer
+    QRunnable, Qt, QTimer
 )
 from PyQt5.QtGui import (
     QColor, QCursor, QFont, QKeyEvent, QKeySequence, QMouseEvent, QPalette,
     QPixmap, QResizeEvent, QTextBlock, QTextCursor, QTextDocument, QTextOption
 )
 from PyQt5.QtWidgets import (
-    QAction, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
-    QPlainTextEdit, QPushButton, QShortcut, QToolBar, QToolButton, QVBoxLayout,
-    QWidget, qApp
+    QAction, QApplication, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit,
+    QMenu, QPlainTextEdit, QShortcut, QToolBar, QVBoxLayout, QWidget
 )
 
 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 NIconToggleButton, 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
+from novelwriter.types import (
+    QtAlignCenterTop, QtAlignJustify, QtAlignLeft, QtAlignLeftTop,
+    QtAlignRight, QtKeepAnchor, QtModCtrl, QtMouseLeft, QtModeNone, QtModShift,
+    QtMoveAnchor, QtMoveLeft, QtMoveRight
+)
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.guimain import GuiMain
@@ -90,6 +96,7 @@ class GuiDocEditor(QPlainTextEdit):
     # Custom Signals
     statusMessage = pyqtSignal(str)
     docCountsChanged = pyqtSignal(str, int, int, int)
+    docTextChanged = pyqtSignal(str, float)
     editedStatusChanged = pyqtSignal(bool)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
     novelStructureChanged = pyqtSignal()
@@ -99,6 +106,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 +150,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 +162,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)
@@ -174,28 +183,28 @@ class GuiDocEditor(QPlainTextEdit):
         self.keyContext.activated.connect(self._openContextFromCursor)
 
         self.followTag1 = QShortcut(self)
-        self.followTag1.setKey(Qt.Key.Key_Return | Qt.KeyboardModifier.ControlModifier)
+        self.followTag1.setKey(Qt.Key.Key_Return | QtModCtrl)
         self.followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
         self.followTag1.activated.connect(self._processTag)
 
         self.followTag2 = QShortcut(self)
-        self.followTag2.setKey(Qt.Key.Key_Enter | Qt.KeyboardModifier.ControlModifier)
+        self.followTag2.setKey(Qt.Key.Key_Enter | QtModCtrl)
         self.followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
         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)
@@ -205,6 +214,10 @@ class GuiDocEditor(QPlainTextEdit):
         self.wheelEventFilter = WheelEventFilter(self)
         self.installEventFilter(self.wheelEventFilter)
 
+        # Function Mapping
+        self.closeSearch = self.docSearch.closeSearch
+        self.searchVisible = self.docSearch.isVisible
+
         # Finalise
         self.updateSyntaxColours()
         self.initEditor()
@@ -248,8 +261,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 +271,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)
 
@@ -334,7 +347,7 @@ class GuiDocEditor(QPlainTextEdit):
         options = QTextOption()
 
         if CONFIG.doJustify:
-            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
+            options.setAlignment(QtAlignJustify)
         if CONFIG.showTabsNSpaces:
             options.setFlags(options.flags() | QTextOption.Flag.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
@@ -362,13 +375,13 @@ 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()
 
         return
 
-    def loadText(self, tHandle: str, tLine=None) -> bool:
+    def loadText(self, tHandle: str, tLine: int | None = None) -> bool:
         """Load text from a document into the editor. If we have an I/O
         error, we must handle this and clear the editor so that we don't
         risk overwriting the file if it exists. This can for instance
@@ -386,22 +399,20 @@ class GuiDocEditor(QPlainTextEdit):
             self.clearEditor()
             return False
 
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._docHandle = tHandle
 
         self._allowAutoReplace(False)
         self._qDocument.setTextContent(docText, tHandle)
         self._allowAutoReplace(True)
-        qApp.processEvents()
+        QApplication.processEvents()
 
         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 +420,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:
@@ -417,12 +429,12 @@ class GuiDocEditor(QPlainTextEdit):
             self.setPlainText("")
             self.setCursorPosition(0)
 
-        qApp.processEvents()
+        QApplication.processEvents()
         self.setDocumentChanged(False)
         self._qDocument.clearUndoRedoStacks()
         self.docToolBar.setVisible(CONFIG.showEditToolBar)
 
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
 
         # Update the status bar
         if self._nwItem is not None:
@@ -432,18 +444,18 @@ 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:
         """Replace the text of the current document with the provided
         text. This also clears undo history.
         """
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self.setPlainText(text)
         self.updateDocMargins()
         self.setDocumentChanged(True)
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
         return
 
     def saveText(self) -> bool:
@@ -462,7 +474,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()
@@ -485,6 +497,7 @@ class GuiDocEditor(QPlainTextEdit):
             return False
 
         self.setDocumentChanged(False)
+        self.docTextChanged.emit(self._docHandle, self._lastEdit)
 
         oldHeader = self._nwItem.mainHeading
         oldCount = SHARED.project.index.getHandleHeaderCount(tHandle)
@@ -530,7 +543,7 @@ class GuiDocEditor(QPlainTextEdit):
             while self.cursorRect().bottom() > vH and count < 100000:
                 vBar.setValue(vBar.value() + 1)
                 count += 1
-        qApp.processEvents()
+        QApplication.processEvents()
         return
 
     def updateDocMargins(self) -> None:
@@ -548,8 +561,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()
@@ -590,6 +603,15 @@ class GuiDocEditor(QPlainTextEdit):
         text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
         return text
 
+    def getSelectedText(self) -> str:
+        """Get currently selected text."""
+        if (cursor := self.textCursor()).hasSelection():
+            text = cursor.selectedText()
+            text = text.replace(nwUnicode.U_LSEP, "\n")  # Line separators
+            text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
+            return text
+        return ""
+
     def getCursorPosition(self) -> int:
         """Find the cursor position in the document. If the editor has a
         selection, return the position of the end of the selection.
@@ -600,13 +622,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 +640,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 +658,15 @@ class GuiDocEditor(QPlainTextEdit):
                 logger.debug("Cursor moved to line %d", line)
         return
 
+    def setCursorSelection(self, start: int, length: int) -> None:
+        """Make a text selection."""
+        if start >= 0 and length > 0:
+            cursor = self.textCursor()
+            cursor.setPosition(start, QtMoveAnchor)
+            cursor.setPosition(start + length, QtKeepAnchor)
+            self.setTextCursor(cursor)
+        return
+
     ##
     #  Spell Checking
     ##
@@ -674,9 +706,9 @@ class GuiDocEditor(QPlainTextEdit):
         """
         logger.debug("Running spell checker")
         start = time()
-        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._qDocument.syntaxHighlighter.rehighlight()
-        qApp.restoreOverrideCursor()
+        QApplication.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
         self.statusMessage.emit(self.tr("Spell check complete"))
         return
@@ -745,6 +777,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 +803,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 +821,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(QApplication.focusWidget())
 
     def revealLocation(self) -> None:
         """Tell the user where on the file system the file in the editor
@@ -898,11 +930,6 @@ class GuiDocEditor(QPlainTextEdit):
 
         return True
 
-    def closeSearch(self) -> bool:
-        """Close the search box."""
-        self.docSearch.closeSearch()
-        return self.docSearch.isVisible()
-
     ##
     #  Document Events and Maintenance
     ##
@@ -937,7 +964,7 @@ class GuiDocEditor(QPlainTextEdit):
             super().keyPressEvent(event)
             nPos = self.cursorRect().topLeft().y()
             kMod = event.modifiers()
-            okMod = kMod in (Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.ShiftModifier)
+            okMod = kMod in (QtModeNone, QtModShift)
             okKey = event.key() not in self.MOVE_KEYS
             if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
@@ -947,8 +974,6 @@ class GuiDocEditor(QPlainTextEdit):
         else:
             super().keyPressEvent(event)
 
-        self.docFooter.updateLineCount()
-
         return
 
     def focusNextPrevChild(self, next: bool) -> bool:
@@ -960,7 +985,7 @@ class GuiDocEditor(QPlainTextEdit):
         if self.hasFocus():
             return False
         elif self.docSearch.isVisible():
-            return self.docSearch.cycleFocus(next)
+            return self.docSearch.cycleFocus()
         return True
 
     def mouseReleaseEvent(self, event: QMouseEvent) -> None:
@@ -968,10 +993,9 @@ class GuiDocEditor(QPlainTextEdit):
         pressed, check if we're clicking on a tag, and trigger the
         follow tag function.
         """
-        if qApp.keyboardModifiers() == Qt.KeyboardModifier.ControlModifier:
+        if QApplication.keyboardModifiers() == QtModCtrl:
             self._processTag(self.cursorForPosition(event.pos()))
         super().mouseReleaseEvent(event)
-        self.docFooter.updateLineCount()
         return
 
     def resizeEvent(self, event: QResizeEvent) -> None:
@@ -991,8 +1015,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
@@ -1012,8 +1036,8 @@ class GuiDocEditor(QPlainTextEdit):
     @pyqtSlot()
     def toggleSearch(self) -> None:
         """Toggle the visibility of the search box."""
-        if self.docSearch.isVisible():
-            self.docSearch.closeSearch()
+        if self.searchVisible():
+            self.closeSearch()
         else:
             self.beginSearch()
         return
@@ -1033,32 +1057,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) -> None:
+        """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."""
@@ -1066,8 +1093,8 @@ class GuiDocEditor(QPlainTextEdit):
         block = cursor.block()
         if block.isValid():
             pos += block.position()
-            cursor.setPosition(pos, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(pos + length, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(pos, QtMoveAnchor)
+            cursor.setPosition(pos + length, QtKeepAnchor)
             cursor.insertText(text)
             self._completer.hide()
         return
@@ -1081,7 +1108,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))
 
@@ -1127,9 +1154,7 @@ class GuiDocEditor(QPlainTextEdit):
                 block = pCursor.block()
                 sCursor = self.textCursor()
                 sCursor.setPosition(block.position() + cPos)
-                sCursor.movePosition(
-                    QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, cLen
-                )
+                sCursor.movePosition(QtMoveRight, QtKeepAnchor, cLen)
                 if suggest:
                     ctxMenu.addSeparator()
                     ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
@@ -1146,7 +1171,7 @@ class GuiDocEditor(QPlainTextEdit):
                 action.triggered.connect(lambda: self._addWord(word, block))
 
         # Execute the context menu
-        ctxMenu.exec_(self.viewport().mapToGlobal(pos))
+        ctxMenu.exec(self.viewport().mapToGlobal(pos))
         ctxMenu.deleteLater()
 
         return
@@ -1176,39 +1201,36 @@ 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
 
-        if self.wCounterDoc.isRunning():
-            logger.debug("Word counter is busy")
-            return
-
         if time() - self._lastEdit < 25.0:
-            logger.debug("Running word counter")
-            SHARED.runInThreadPool(self.wCounterDoc)
+            logger.debug("Running document tasks")
+            if not self.wCounterDoc.isRunning():
+                SHARED.runInThreadPool(self.wCounterDoc)
+
+            self.docHeader.setOutline({
+                block.blockNumber(): block.text()
+                for block in self._qDocument.iterBlockByType(BLOCK_TITLE, maxCount=30)
+            })
+
+            if self._docChanged:
+                self.docTextChanged.emit(self._docHandle, self._lastEdit)
 
         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 +1239,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 +1263,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()
@@ -1273,11 +1290,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def beginSearch(self) -> None:
         """Set the selected text as the search text."""
-        cursor = self.textCursor()
-        if cursor.hasSelection():
-            self.docSearch.setSearchText(cursor.selectedText())
-        else:
-            self.docSearch.setSearchText(None)
+        self.docSearch.setSearchText(self.getSelectedText() or None)
         resS, _ = self.findAllOccurences()
         self.docSearch.setResultCount(None, len(resS))
         return
@@ -1306,17 +1319,18 @@ class GuiDocEditor(QPlainTextEdit):
         if len(resS) == 0 and self._docHandle:
             self.docSearch.setResultCount(0, 0)
             self._lastFind = None
-            if self.docSearch.doNextFile and not goBack:
+            if CONFIG.searchNextFile and not goBack:
                 self.mainGui.openNextDocument(
-                    self._docHandle, wrapAround=self.docSearch.doLoop
+                    self._docHandle, wrapAround=CONFIG.searchLoop
                 )
                 self.beginSearch()
+                self.setFocus()
             return
 
         cursor = self.textCursor()
         resIdx = bisect.bisect_left(resS, cursor.position())
 
-        doLoop = self.docSearch.doLoop
+        doLoop = CONFIG.searchLoop
         maxIdx = len(resS) - 1
 
         if goBack:
@@ -1326,20 +1340,20 @@ class GuiDocEditor(QPlainTextEdit):
             resIdx = maxIdx if doLoop else 0
 
         if resIdx > maxIdx and self._docHandle:
-            if self.docSearch.doNextFile and not goBack:
+            if CONFIG.searchNextFile and not goBack:
                 self.mainGui.openNextDocument(
-                    self._docHandle, wrapAround=self.docSearch.doLoop
+                    self._docHandle, wrapAround=CONFIG.searchLoop
                 )
                 self.beginSearch()
+                self.setFocus()
                 return
             else:
                 resIdx = 0 if doLoop else maxIdx
 
-        cursor.setPosition(resS[resIdx], QTextCursor.MoveMode.MoveAnchor)
-        cursor.setPosition(resE[resIdx], QTextCursor.MoveMode.KeepAnchor)
+        cursor.setPosition(resS[resIdx], QtMoveAnchor)
+        cursor.setPosition(resE[resIdx], QtKeepAnchor)
         self.setTextCursor(cursor)
 
-        self.docFooter.updateLineCount()
         self.docSearch.setResultCount(resIdx + 1, len(resS))
         self._lastFind = (resS[resIdx], resE[resIdx])
 
@@ -1361,18 +1375,19 @@ class GuiDocEditor(QPlainTextEdit):
             origB = cursor.position()
 
         findOpt = QTextDocument.FindFlag(0)
-        if self.docSearch.isCaseSense:
+        if CONFIG.searchCase:
             findOpt |= QTextDocument.FindFlag.FindCaseSensitively
-        if self.docSearch.isWholeWord:
+        if CONFIG.searchWord:
             findOpt |= QTextDocument.FindFlag.FindWholeWords
 
         searchFor = self.docSearch.getSearchObject()
         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())
@@ -1382,8 +1397,8 @@ class GuiDocEditor(QPlainTextEdit):
                 break
 
         if hasSelection:
-            cursor.setPosition(origA, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(origB, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(origA, QtMoveAnchor)
+            cursor.setPosition(origB, QtKeepAnchor)
         else:
             cursor.setPosition(origA)
 
@@ -1431,18 +1446,12 @@ class GuiDocEditor(QPlainTextEdit):
         searchFor = self.docSearch.searchText
         replWith = self.docSearch.replaceText
 
-        if self.docSearch.doMatchCap:
+        if CONFIG.searchMatchCap:
             replWith = transferCase(cursor.selectedText(), replWith)
 
         # 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 +1460,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()
 
@@ -1464,7 +1471,7 @@ class GuiDocEditor(QPlainTextEdit):
     #  Internal Functions : Text Manipulation
     ##
 
-    def _toggleFormat(self, fLen: int, fChar: str) -> bool:
+    def _toggleFormat(self, fLen: int, fChar: str) -> None:
         """Toggle the formatting of a specific type for a piece of text.
         If more than one block is selected, the formatting is applied to
         the first block.
@@ -1482,20 +1489,20 @@ class GuiDocEditor(QPlainTextEdit):
 
         posS = cursor.selectionStart()
         posE = cursor.selectionEnd()
-        if self._qDocument.characterAt(posO - 1) == fChar:
+        if posS == posE and self._qDocument.characterAt(posO - 1) == fChar:
             logger.warning("Format repetition, cancelling action")
             cursor.clearSelection()
             cursor.setPosition(posO)
             self.setTextCursor(cursor)
-            return False
+            return
 
         blockS = self._qDocument.findBlock(posS)
         blockE = self._qDocument.findBlock(posE)
         if blockS != blockE:
             posE = blockS.position() + blockS.length() - 1
             cursor.clearSelection()
-            cursor.setPosition(posS, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(posS, QtMoveAnchor)
+            cursor.setPosition(posE, QtKeepAnchor)
             self.setTextCursor(cursor)
 
         numB = 0
@@ -1513,7 +1520,6 @@ class GuiDocEditor(QPlainTextEdit):
                 break
 
         if fLen == min(numA, numB):
-            cursor.clearSelection()
             cursor.beginEditBlock()
             cursor.setPosition(posS)
             for i in range(fLen):
@@ -1522,17 +1528,19 @@ class GuiDocEditor(QPlainTextEdit):
             for i in range(fLen):
                 cursor.deletePreviousChar()
             cursor.endEditBlock()
-            cursor.clearSelection()
-            cursor.setPosition(posO - fLen)
-            self.setTextCursor(cursor)
+
+            if select != _SelectAction.KEEP_SELECTION:
+                cursor.clearSelection()
+                cursor.setPosition(posO - fLen)
+                self.setTextCursor(cursor)
 
         else:
             self._wrapSelection(fChar*fLen, pos=posO, select=select)
 
-        return True
+        return
 
     def _wrapSelection(self, before: str, after: str | None = None, pos: int | None = None,
-                       select: _SelectAction = _SelectAction.NO_DECISION) -> bool:
+                       select: _SelectAction = _SelectAction.NO_DECISION) -> None:
         """Wrap the selected text in whatever is in tBefore and tAfter.
         If there is no selection, the autoSelect setting decides the
         action. AutoSelect will select the word under the cursor before
@@ -1572,21 +1580,21 @@ class GuiDocEditor(QPlainTextEdit):
         if select == _SelectAction.MOVE_AFTER:
             cursor.setPosition(posE + len(before + after))
         elif select == _SelectAction.KEEP_SELECTION:
-            cursor.setPosition(posE + len(before), QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(posS + len(before), QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(posS + len(before), QtMoveAnchor)
+            cursor.setPosition(posE + len(before), QtKeepAnchor)
         elif select == _SelectAction.KEEP_POSITION:
             cursor.setPosition(posO + len(before))
 
         self.setTextCursor(cursor)
 
-        return True
+        return
 
-    def _replaceQuotes(self, sQuote: str, oQuote: str, cQuote: str) -> bool:
+    def _replaceQuotes(self, sQuote: str, oQuote: str, cQuote: str) -> None:
         """Replace all straight quotes in the selected text."""
         cursor = self.textCursor()
         if not cursor.hasSelection():
             SHARED.error(self.tr("Please select some text before calling replace quotes."))
-            return False
+            return
 
         posS = cursor.selectionStart()
         posE = cursor.selectionEnd()
@@ -1595,9 +1603,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._allowAutoReplace(False)
         for posC in range(posS, posE+1):
             cursor.setPosition(posC)
-            cursor.movePosition(
-                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 2
-            )
+            cursor.movePosition(QtMoveLeft, QtKeepAnchor, 2)
             selText = cursor.selectedText()
 
             nS = len(selText)
@@ -1617,22 +1623,18 @@ class GuiDocEditor(QPlainTextEdit):
             cursor.setPosition(posC)
             if pC in closeCheck:
                 cursor.beginEditBlock()
-                cursor.movePosition(
-                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
-                )
+                cursor.movePosition(QtMoveLeft, QtKeepAnchor, 1)
                 cursor.insertText(oQuote)
                 cursor.endEditBlock()
             else:
                 cursor.beginEditBlock()
-                cursor.movePosition(
-                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
-                )
+                cursor.movePosition(QtMoveLeft, QtKeepAnchor, 1)
                 cursor.insertText(cQuote)
                 cursor.endEditBlock()
 
         self._allowAutoReplace(True)
 
-        return True
+        return
 
     def _processBlockFormat(
         self, action: nwDocAction, text: str, toggle: bool = True
@@ -1670,6 +1672,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 +1726,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:
@@ -1836,9 +1844,7 @@ class GuiDocEditor(QPlainTextEdit):
         cursor.beginEditBlock()
         cursor.clearSelection()
         cursor.setPosition(rS)
-        cursor.movePosition(
-            QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, rE-rS
-        )
+        cursor.movePosition(QtMoveRight, QtKeepAnchor, rE-rS)
         cursor.insertText(cleanText.rstrip() + "\n")
         cursor.endEditBlock()
 
@@ -1867,7 +1873,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 +1904,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)
+                    QApplication.processEvents()
+                    self._qDocument.syntaxHighlighter.rehighlightBlock(block)
 
             return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
 
@@ -2005,9 +2010,7 @@ class GuiDocEditor(QPlainTextEdit):
                 tInsert = tInsert + self._typPadChar
 
         if nDelete > 0:
-            cursor.movePosition(
-                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, nDelete
-            )
+            cursor.movePosition(QtMoveLeft, QtKeepAnchor, nDelete)
             cursor.insertText(tInsert)
 
         return
@@ -2063,8 +2066,8 @@ class GuiDocEditor(QPlainTextEdit):
                 return cursor
 
             cursor.clearSelection()
-            cursor.setPosition(sPos, QTextCursor.MoveMode.MoveAnchor)
-            cursor.setPosition(ePos, QTextCursor.MoveMode.KeepAnchor)
+            cursor.setPosition(sPos, QtMoveAnchor)
+            cursor.setPosition(ePos, QtKeepAnchor)
 
             self.setTextCursor(cursor)
 
@@ -2088,8 +2091,8 @@ class GuiDocEditor(QPlainTextEdit):
             posE = cursor.selectionEnd()
             selTxt = cursor.selectedText()
             if selTxt.startswith(nwUnicode.U_PSEP):
-                cursor.setPosition(posS+1, QTextCursor.MoveMode.MoveAnchor)
-                cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+                cursor.setPosition(posS+1, QtMoveAnchor)
+                cursor.setPosition(posE, QtKeepAnchor)
 
         self.setTextCursor(cursor)
 
@@ -2184,7 +2187,7 @@ class MetaCompleter(QMenu):
     #  Internal Functions
     ##
 
-    def _emitComplete(self, pos: int, length: int, value: str):
+    def _emitComplete(self, pos: int, length: int, value: str) -> None:
         """Emit the signal to indicate a selection has been made."""
         self.complete.emit(pos, length, value)
         return
@@ -2220,11 +2223,11 @@ class BackgroundWordCounter(QRunnable):
         """
         self._isRunning = True
         if self._forSelection:
-            text = self._docEditor.textCursor().selectedText()
+            text = self._docEditor.getSelectedText()
         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
 
@@ -2256,72 +2259,68 @@ class GuiDocToolBar(QWidget):
 
         logger.debug("Create: GuiDocToolBar")
 
+        iSz = SHARED.theme.baseIconSize
         cM = CONFIG.pxInt(4)
-        tPx = int(0.8*SHARED.theme.fontPixelSize)
-        iconSize = QSize(tPx, tPx)
         self.setContentsMargins(0, 0, 0, 0)
 
         # General Buttons
         # ===============
 
-        self.tbBoldMD = QToolButton(self)
-        self.tbBoldMD.setIconSize(iconSize)
+        self.tbBoldMD = NIconToolButton(self, iSz)
         self.tbBoldMD.setToolTip(self.tr("Markdown Bold"))
         self.tbBoldMD.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.MD_BOLD)
         )
 
-        self.tbItalicMD = QToolButton(self)
-        self.tbItalicMD.setIconSize(iconSize)
+        self.tbItalicMD = NIconToolButton(self, iSz)
         self.tbItalicMD.setToolTip(self.tr("Markdown Italic"))
         self.tbItalicMD.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.MD_ITALIC)
         )
 
-        self.tbStrikeMD = QToolButton(self)
-        self.tbStrikeMD.setIconSize(iconSize)
+        self.tbStrikeMD = NIconToolButton(self, iSz)
         self.tbStrikeMD.setToolTip(self.tr("Markdown Strikethrough"))
         self.tbStrikeMD.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.MD_STRIKE)
         )
 
-        self.tbBold = QToolButton(self)
-        self.tbBold.setIconSize(iconSize)
+        self.tbBold = NIconToolButton(self, iSz)
         self.tbBold.setToolTip(self.tr("Shortcode Bold"))
         self.tbBold.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_BOLD)
         )
 
-        self.tbItalic = QToolButton(self)
-        self.tbItalic.setIconSize(iconSize)
+        self.tbItalic = NIconToolButton(self, iSz)
         self.tbItalic.setToolTip(self.tr("Shortcode Italic"))
         self.tbItalic.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_ITALIC)
         )
 
-        self.tbStrike = QToolButton(self)
-        self.tbStrike.setIconSize(iconSize)
+        self.tbStrike = NIconToolButton(self, iSz)
         self.tbStrike.setToolTip(self.tr("Shortcode Strikethrough"))
         self.tbStrike.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_STRIKE)
         )
 
-        self.tbUnderline = QToolButton(self)
-        self.tbUnderline.setIconSize(iconSize)
+        self.tbUnderline = NIconToolButton(self, iSz)
         self.tbUnderline.setToolTip(self.tr("Shortcode Underline"))
         self.tbUnderline.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
         )
 
-        self.tbSuperscript = QToolButton(self)
-        self.tbSuperscript.setIconSize(iconSize)
+        self.tbMark = NIconToolButton(self, iSz)
+        self.tbMark.setToolTip(self.tr("Shortcode Highlight"))
+        self.tbMark.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_MARK)
+        )
+
+        self.tbSuperscript = NIconToolButton(self, iSz)
         self.tbSuperscript.setToolTip(self.tr("Shortcode Superscript"))
         self.tbSuperscript.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_SUP)
         )
 
-        self.tbSubscript = QToolButton(self)
-        self.tbSubscript.setIconSize(iconSize)
+        self.tbSubscript = NIconToolButton(self, iSz)
         self.tbSubscript.setToolTip(self.tr("Shortcode Subscript"))
         self.tbSubscript.clicked.connect(
             lambda: self.requestDocAction.emit(nwDocAction.SC_SUB)
@@ -2339,6 +2338,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)
@@ -2362,15 +2362,16 @@ class GuiDocToolBar(QWidget):
         palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
         self.setPalette(palette)
 
-        self.tbBoldMD.setIcon(SHARED.theme.getIcon("fmt_bold-md"))
-        self.tbItalicMD.setIcon(SHARED.theme.getIcon("fmt_italic-md"))
-        self.tbStrikeMD.setIcon(SHARED.theme.getIcon("fmt_strike-md"))
-        self.tbBold.setIcon(SHARED.theme.getIcon("fmt_bold"))
-        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.tbSuperscript.setIcon(SHARED.theme.getIcon("fmt_superscript"))
-        self.tbSubscript.setIcon(SHARED.theme.getIcon("fmt_subscript"))
+        self.tbBoldMD.setThemeIcon("fmt_bold-md")
+        self.tbItalicMD.setThemeIcon("fmt_italic-md")
+        self.tbStrikeMD.setThemeIcon("fmt_strike-md")
+        self.tbBold.setThemeIcon("fmt_bold")
+        self.tbItalic.setThemeIcon("fmt_italic")
+        self.tbStrike.setThemeIcon("fmt_strike")
+        self.tbUnderline.setThemeIcon("fmt_underline")
+        self.tbMark.setThemeIcon("fmt_mark")
+        self.tbSuperscript.setThemeIcon("fmt_superscript")
+        self.tbSubscript.setThemeIcon("fmt_subscript")
 
         return
 
@@ -2391,16 +2392,9 @@ class GuiDocEditSearch(QFrame):
 
         self.docEditor = docEditor
 
-        self.repVisible  = False
-        self.isCaseSense = CONFIG.searchCase
-        self.isWholeWord = CONFIG.searchWord
-        self.isRegEx     = CONFIG.searchRegEx
-        self.doLoop      = CONFIG.searchLoop
-        self.doNextFile  = CONFIG.searchNextFile
-        self.doMatchCap  = CONFIG.searchMatchCap
-
+        iSz = SHARED.theme.baseIconSize
         mPx = CONFIG.pxInt(6)
-        tPx = int(0.8*SHARED.theme.fontPixelSize)
+
         self.boxFont = SHARED.theme.guiFont
         self.boxFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
 
@@ -2416,54 +2410,54 @@ class GuiDocEditSearch(QFrame):
 
         self.searchBox = QLineEdit(self)
         self.searchBox.setFont(self.boxFont)
-        self.searchBox.setPlaceholderText(self.tr("Search"))
+        self.searchBox.setPlaceholderText(self.tr("Search for"))
         self.searchBox.returnPressed.connect(self._doSearch)
 
         self.replaceBox = QLineEdit(self)
         self.replaceBox.setFont(self.boxFont)
-        self.replaceBox.setPlaceholderText(self.tr("Replace"))
+        self.replaceBox.setPlaceholderText(self.tr("Replace with"))
         self.replaceBox.returnPressed.connect(self._doReplace)
 
         self.searchOpt = QToolBar(self)
         self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
-        self.searchOpt.setIconSize(QSize(tPx, tPx))
+        self.searchOpt.setIconSize(iSz)
         self.searchOpt.setContentsMargins(0, 0, 0, 0)
 
-        self.searchLabel = QLabel(self.tr("Search"))
+        self.searchLabel = QLabel(self.tr("Search"), self)
         self.searchLabel.setFont(self.boxFont)
         self.searchLabel.setIndent(CONFIG.pxInt(6))
 
-        self.resultLabel = QLabel("?/?")
+        self.resultLabel = QLabel("?/?", self)
         self.resultLabel.setFont(self.boxFont)
         self.resultLabel.setMinimumWidth(SHARED.theme.getTextWidth("?/?", self.boxFont))
 
         self.toggleCase = QAction(self.tr("Case Sensitive"), self)
         self.toggleCase.setCheckable(True)
-        self.toggleCase.setChecked(self.isCaseSense)
+        self.toggleCase.setChecked(CONFIG.searchCase)
         self.toggleCase.toggled.connect(self._doToggleCase)
         self.searchOpt.addAction(self.toggleCase)
 
         self.toggleWord = QAction(self.tr("Whole Words Only"), self)
         self.toggleWord.setCheckable(True)
-        self.toggleWord.setChecked(self.isWholeWord)
+        self.toggleWord.setChecked(CONFIG.searchWord)
         self.toggleWord.toggled.connect(self._doToggleWord)
         self.searchOpt.addAction(self.toggleWord)
 
         self.toggleRegEx = QAction(self.tr("RegEx Mode"), self)
         self.toggleRegEx.setCheckable(True)
-        self.toggleRegEx.setChecked(self.isRegEx)
+        self.toggleRegEx.setChecked(CONFIG.searchRegEx)
         self.toggleRegEx.toggled.connect(self._doToggleRegEx)
         self.searchOpt.addAction(self.toggleRegEx)
 
         self.toggleLoop = QAction(self.tr("Loop Search"), self)
         self.toggleLoop.setCheckable(True)
-        self.toggleLoop.setChecked(self.doLoop)
+        self.toggleLoop.setChecked(CONFIG.searchLoop)
         self.toggleLoop.toggled.connect(self._doToggleLoop)
         self.searchOpt.addAction(self.toggleLoop)
 
         self.toggleProject = QAction(self.tr("Search Next File"), self)
         self.toggleProject.setCheckable(True)
-        self.toggleProject.setChecked(self.doNextFile)
+        self.toggleProject.setChecked(CONFIG.searchNextFile)
         self.toggleProject.toggled.connect(self._doToggleProject)
         self.searchOpt.addAction(self.toggleProject)
 
@@ -2471,38 +2465,32 @@ class GuiDocEditSearch(QFrame):
 
         self.toggleMatchCap = QAction(self.tr("Preserve Case"), self)
         self.toggleMatchCap.setCheckable(True)
-        self.toggleMatchCap.setChecked(self.doMatchCap)
+        self.toggleMatchCap.setChecked(CONFIG.searchMatchCap)
         self.toggleMatchCap.toggled.connect(self._doToggleMatchCap)
         self.searchOpt.addAction(self.toggleMatchCap)
 
         self.searchOpt.addSeparator()
 
         self.cancelSearch = QAction(self.tr("Close Search"), self)
-        self.cancelSearch.triggered.connect(self._doClose)
+        self.cancelSearch.triggered.connect(self.closeSearch)
         self.searchOpt.addAction(self.cancelSearch)
 
         # Buttons
         # =======
 
-        bPx = self.searchBox.sizeHint().height()
-
-        self.showReplace = QToolButton(self)
-        self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
-        self.showReplace.setCheckable(True)
+        self.showReplace = NIconToggleButton(self, iSz, "unfold")
         self.showReplace.toggled.connect(self._doToggleReplace)
 
-        self.searchButton = QPushButton("")
-        self.searchButton.setFixedSize(QSize(bPx, bPx))
+        self.searchButton = NIconToolButton(self, iSz)
         self.searchButton.setToolTip(self.tr("Find in current document"))
         self.searchButton.clicked.connect(self._doSearch)
 
-        self.replaceButton = QPushButton("")
-        self.replaceButton.setFixedSize(QSize(bPx, bPx))
+        self.replaceButton = NIconToolButton(self, iSz)
         self.replaceButton.setToolTip(self.tr("Find and replace in current document"))
         self.replaceButton.clicked.connect(self._doReplace)
 
-        self.mainBox.addWidget(self.searchLabel,   0, 0, 1, 2, Qt.AlignmentFlag.AlignLeft)
-        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, Qt.AlignmentFlag.AlignRight)
+        self.mainBox.addWidget(self.searchLabel,   0, 0, 1, 2, QtAlignLeft)
+        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, QtAlignRight)
         self.mainBox.addWidget(self.showReplace,   1, 0, 1, 1)
         self.mainBox.addWidget(self.searchBox,     1, 1, 1, 2)
         self.mainBox.addWidget(self.searchButton,  1, 3, 1, 1)
@@ -2555,20 +2543,20 @@ class GuiDocEditSearch(QFrame):
         expression object.
         """
         text = self.searchBox.text()
-        if self.isRegEx:
+        if CONFIG.searchRegEx:
             # Using the Unicode-capable QRegularExpression class was
             # only added in Qt 5.13. Otherwise, 5.3 and up supports
             # only the QRegExp class.
             if CONFIG.verQtValue >= 0x050d00:
                 rxOpt = QRegularExpression.PatternOption.UseUnicodePropertiesOption
-                if not self.isCaseSense:
+                if not CONFIG.searchCase:
                     rxOpt |= QRegularExpression.PatternOption.CaseInsensitiveOption
                 regEx = QRegularExpression(text, rxOpt)
                 self._alertSearchValid(regEx.isValid())
                 return regEx
             else:  # pragma: no cover
                 # >= 50300 to < 51300
-                if self.isCaseSense:
+                if CONFIG.searchCase:
                     rxOpt = Qt.CaseSensitivity.CaseSensitive
                 else:
                     rxOpt = Qt.CaseSensitivity.CaseInsensitive
@@ -2592,7 +2580,7 @@ class GuiDocEditSearch(QFrame):
             self.searchBox.setText(text)
         self.searchBox.setFocus()
         self.searchBox.selectAll()
-        if self.isRegEx:
+        if CONFIG.searchRegEx:
             self._alertSearchValid(True)
         return
 
@@ -2605,8 +2593,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)
@@ -2620,7 +2610,7 @@ class GuiDocEditSearch(QFrame):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        qPalette = qApp.palette()
+        qPalette = QApplication.palette()
         self.setPalette(qPalette)
         self.searchBox.setPalette(qPalette)
         self.replaceBox.setPalette(qPalette)
@@ -2633,8 +2623,8 @@ class GuiDocEditSearch(QFrame):
         self.toggleProject.setIcon(SHARED.theme.getIcon("search_project"))
         self.toggleMatchCap.setIcon(SHARED.theme.getIcon("search_preserve"))
         self.cancelSearch.setIcon(SHARED.theme.getIcon("search_cancel"))
-        self.searchButton.setIcon(SHARED.theme.getIcon("search"))
-        self.replaceButton.setIcon(SHARED.theme.getIcon("search_replace"))
+        self.searchButton.setThemeIcon("search")
+        self.replaceButton.setThemeIcon("search_replace")
 
         # Set stylesheets
         self.searchOpt.setStyleSheet("QToolBar {padding: 0;}")
@@ -2660,57 +2650,43 @@ class GuiDocEditSearch(QFrame):
 
         return
 
-    def closeSearch(self) -> None:
-        """Close the search box."""
-        CONFIG.searchCase = self.isCaseSense
-        CONFIG.searchWord = self.isWholeWord
-        CONFIG.searchRegEx = self.isRegEx
-        CONFIG.searchLoop = self.doLoop
-        CONFIG.searchNextFile = self.doNextFile
-        CONFIG.searchMatchCap = self.doMatchCap
-
-        self.showReplace.setChecked(False)
-        self.setVisible(False)
-        self.docEditor.updateDocMargins()
-        self.docEditor.setFocus()
-
-        return
-
-    def cycleFocus(self, next: bool) -> bool:
+    def cycleFocus(self) -> bool:
         """The tab key just alternates focus between the two input
         boxes, if the replace box is visible.
         """
-        if self.replaceBox.isVisible():
-            if self.searchBox.hasFocus():
-                self.replaceBox.setFocus()
-                return True
-            elif self.replaceBox.hasFocus():
-                self.searchBox.setFocus()
-                return True
+        if self.searchBox.hasFocus():
+            self.replaceBox.setFocus()
+            return True
+        elif self.replaceBox.hasFocus():
+            self.searchBox.setFocus()
+            return True
         return False
 
     def anyFocus(self) -> bool:
         """Return True if any of the input boxes have focus."""
-        return self.searchBox.hasFocus() | self.replaceBox.hasFocus()
+        return self.searchBox.hasFocus() or self.replaceBox.hasFocus()
 
     ##
-    #  Private Slots
+    #  Public Slots
     ##
 
     @pyqtSlot()
-    def _doClose(self) -> None:
-        """Hide the search/replace bar."""
-        self.closeSearch()
+    def closeSearch(self) -> None:
+        """Close the search box."""
+        self.showReplace.setChecked(False)
+        self.setVisible(False)
+        self.docEditor.updateDocMargins()
+        self.docEditor.setFocus()
         return
 
+    ##
+    #  Private Slots
+    ##
+
     @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=(QApplication.keyboardModifiers() == QtModShift))
         return
 
     @pyqtSlot()
@@ -2722,13 +2698,8 @@ class GuiDocEditSearch(QFrame):
     @pyqtSlot(bool)
     def _doToggleReplace(self, state: bool) -> None:
         """Toggle the show/hide of the replace box."""
-        if state:
-            self.showReplace.setArrowType(Qt.ArrowType.DownArrow)
-        else:
-            self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
         self.replaceBox.setVisible(state)
         self.replaceButton.setVisible(state)
-        self.repVisible = state
         self.adjustSize()
         self.docEditor.updateDocMargins()
         return
@@ -2736,37 +2707,37 @@ class GuiDocEditSearch(QFrame):
     @pyqtSlot(bool)
     def _doToggleCase(self, state: bool) -> None:
         """Enable/disable case sensitive mode."""
-        self.isCaseSense = state
+        CONFIG.searchCase = state
         return
 
     @pyqtSlot(bool)
     def _doToggleWord(self, state: bool) -> None:
         """Enable/disable whole word search mode."""
-        self.isWholeWord = state
+        CONFIG.searchWord = state
         return
 
     @pyqtSlot(bool)
     def _doToggleRegEx(self, state: bool) -> None:
         """Enable/disable regular expression search mode."""
-        self.isRegEx = state
+        CONFIG.searchRegEx = state
         return
 
     @pyqtSlot(bool)
     def _doToggleLoop(self, state: bool) -> None:
         """Enable/disable looping the search."""
-        self.doLoop = state
+        CONFIG.searchLoop = state
         return
 
     @pyqtSlot(bool)
     def _doToggleProject(self, state: bool) -> None:
         """Enable/disable continuing search in next project file."""
-        self.doNextFile = state
+        CONFIG.searchNextFile = state
         return
 
     @pyqtSlot(bool)
     def _doToggleMatchCap(self, state: bool) -> None:
         """Enable/disable preserving capitalisation when replacing."""
-        self.doMatchCap = state
+        CONFIG.searchMatchCap = state
         return
 
     ##
@@ -2801,84 +2772,82 @@ 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.baseIconHeight
+        iSz = 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.setAlignment(QtAlignCenterTop)
+        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, iSz)
         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, iSz)
+        self.outlineButton.setVisible(False)
+        self.outlineButton.setToolTip(self.tr("Outline"))
+        self.outlineButton.setMenu(self.outlineMenu)
+
+        self.searchButton = NIconToolButton(self, iSz)
         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, iSz)
         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, iSz)
         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 +2859,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.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())
+        self.tbButton.setThemeIcon("menu")
+        self.outlineButton.setThemeIcon("list")
+        self.searchButton.setThemeIcon("search")
+        self.minmaxButton.setThemeIcon("maximise")
+        self.closeButton.setThemeIcon("close")
 
+        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 +2920,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,23 +2948,32 @@ 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.setThemeIcon("minimise" if focusMode else "maximise")
         return
 
     ##
     #  Events
     ##
 
-    def mousePressEvent(self, event: QMouseEvent):
+    def mousePressEvent(self, event: QMouseEvent) -> None:
         """Capture a click on the title and ensure that the item is
         selected in the project tree.
         """
-        if event.button() == Qt.MouseButton.LeftButton:
-            self.docEditor.requestProjectItemSelected.emit(self._docHandle, True)
+        if event.button() == QtMouseLeft:
+            self.docEditor.requestProjectItemSelected.emit(self._docHandle or "", True)
         return
 
 # END Class GuiDocEditHeader
@@ -3009,75 +2986,75 @@ 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.baseIconHeight)
         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)
 
-        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.setAlignment(alLeftTop)
+        self.statusIcon.setFixedHeight(iPx)
+        self.statusIcon.setAlignment(QtAlignLeftTop)
 
-        self.statusText = QLabel(self.tr("Status"))
+        self.statusText = QLabel(self.tr("Status"), self)
         self.statusText.setIndent(0)
         self.statusText.setMargin(0)
         self.statusText.setContentsMargins(0, 0, 0, 0)
         self.statusText.setAutoFillBackground(True)
         self.statusText.setFixedHeight(fPx)
-        self.statusText.setAlignment(alLeftTop)
+        self.statusText.setAlignment(QtAlignLeftTop)
         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.setAlignment(alLeftTop)
+        self.linesIcon.setFixedHeight(iPx)
+        self.linesIcon.setAlignment(QtAlignLeftTop)
 
-        self.linesText = QLabel("")
+        self.linesText = QLabel("", self)
         self.linesText.setIndent(0)
         self.linesText.setMargin(0)
         self.linesText.setContentsMargins(0, 0, 0, 0)
         self.linesText.setAutoFillBackground(True)
         self.linesText.setFixedHeight(fPx)
-        self.linesText.setAlignment(alLeftTop)
+        self.linesText.setAlignment(QtAlignLeftTop)
         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.setAlignment(alLeftTop)
+        self.wordsIcon.setFixedHeight(iPx)
+        self.wordsIcon.setAlignment(QtAlignLeftTop)
 
-        self.wordsText = QLabel("")
+        self.wordsText = QLabel("", self)
         self.wordsText.setIndent(0)
         self.wordsText.setMargin(0)
         self.wordsText.setContentsMargins(0, 0, 0, 0)
         self.wordsText.setAutoFillBackground(True)
         self.wordsText.setFixedHeight(fPx)
-        self.wordsText.setAlignment(alLeftTop)
+        self.wordsText.setAlignment(QtAlignLeftTop)
         self.wordsText.setFont(lblFont)
 
         # Assemble Layout
@@ -3091,19 +3068,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 +3093,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.baseIconHeight)
+        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 +3124,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.baseIconHeight)
             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 +3145,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