novelWriter 2.3.1__py3-none-any.whl → 2.4rc1__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,7 +375,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()
 
@@ -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()
@@ -530,7 +542,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 +560,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 +602,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 +621,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 +639,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 +657,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 +705,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 +776,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 +802,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 +820,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 +929,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 +963,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 +973,6 @@ class GuiDocEditor(QPlainTextEdit):
         else:
             super().keyPressEvent(event)
 
-        self.docFooter.updateLineCount()
-
         return
 
     def focusNextPrevChild(self, next: bool) -> bool:
@@ -960,7 +984,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 +992,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 +1014,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 +1035,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 +1056,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."""
@@ -1066,8 +1092,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 +1107,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 +1153,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 +1170,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 +1200,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 +1238,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 +1262,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 +1289,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 +1318,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 +1339,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 +1374,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 +1396,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 +1445,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 +1459,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()
 
@@ -1494,8 +1500,8 @@ class GuiDocEditor(QPlainTextEdit):
         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
@@ -1572,8 +1578,8 @@ 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(posE + len(before), QtMoveAnchor)
+            cursor.setPosition(posS + len(before), QtKeepAnchor)
         elif select == _SelectAction.KEEP_POSITION:
             cursor.setPosition(posO + len(before))
 
@@ -1595,9 +1601,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,16 +1621,12 @@ 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()
 
@@ -1670,6 +1670,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 +1724,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 +1842,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 +1871,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 +1902,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 +2008,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 +2064,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 +2089,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)
 
@@ -2220,11 +2221,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 +2257,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 +2336,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 +2360,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 +2390,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)
 
@@ -2426,44 +2418,44 @@ class GuiDocEditSearch(QFrame):
 
         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 +2463,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 +2541,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 +2578,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 +2591,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 +2608,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 +2621,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 +2648,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 +2696,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 +2705,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 +2770,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 +2857,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 +2918,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 +2946,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.setThemeIcon("minimise" if focusMode else "maximise")
         return
 
     ##
@@ -2995,8 +2970,8 @@ class GuiDocEditHeader(QWidget):
         """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 +2984,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 +3066,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 +3091,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 +3122,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 +3143,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