novelWriter 2.6.3__py3-none-any.whl → 2.7rc1__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -3,15 +3,16 @@ novelWriter – GUI Document Editor
 =================================
 
 File History:
-Created:   2018-09-29 [0.0.1] GuiDocEditor
-Created:   2019-04-22 [0.0.1] BackgroundWordCounter
-Created:   2019-09-29 [0.2.1] GuiDocEditSearch
-Created:   2020-04-25 [0.4.5] GuiDocEditHeader
-Rewritten: 2020-06-15 [0.9]   GuiDocEditSearch
-Created:   2020-06-27 [0.10]  GuiDocEditFooter
-Rewritten: 2020-10-07 [1.0b3] BackgroundWordCounter
-Created:   2023-11-06 [2.2b1] MetaCompleter
-Created:   2023-11-07 [2.2b1] GuiDocToolBar
+Created:   2018-09-29 [0.0.1]  GuiDocEditor
+Created:   2019-04-22 [0.0.1]  BackgroundWordCounter
+Created:   2019-09-29 [0.2.1]  GuiDocEditSearch
+Created:   2020-04-25 [0.4.5]  GuiDocEditHeader
+Rewritten: 2020-06-15 [0.9]    GuiDocEditSearch
+Created:   2020-06-27 [0.10]   GuiDocEditFooter
+Rewritten: 2020-10-07 [1.0b3]  BackgroundWordCounter
+Created:   2023-11-06 [2.2b1]  MetaCompleter
+Created:   2023-11-07 [2.2b1]  GuiDocToolBar
+Extended:  2025-05-18 [2.7rc1] CommandCompleter
 
 This file is a part of novelWriter
 Copyright (C) 2018 Veronica Berglyd Olsen and novelWriter contributors
@@ -37,29 +38,33 @@ import logging
 from enum import Enum, IntFlag
 from time import time
 
-from PyQt5.QtCore import (
+from PyQt6.QtCore import (
     QObject, QPoint, QRegularExpression, QRunnable, Qt, QTimer, pyqtSignal,
     pyqtSlot
 )
-from PyQt5.QtGui import (
-    QColor, QCursor, QDragEnterEvent, QDragMoveEvent, QDropEvent, QKeyEvent,
-    QKeySequence, QMouseEvent, QPalette, QPixmap, QResizeEvent, QTextBlock,
-    QTextCursor, QTextDocument, QTextOption
+from PyQt6.QtGui import (
+    QAction, QCursor, QDragEnterEvent, QDragMoveEvent, QDropEvent, QKeyEvent,
+    QKeySequence, QMouseEvent, QPalette, QPixmap, QResizeEvent, QShortcut,
+    QTextBlock, QTextCursor, QTextDocument, QTextOption
 )
-from PyQt5.QtWidgets import (
-    QAction, QApplication, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit,
-    QMenu, QPlainTextEdit, QShortcut, QToolBar, QVBoxLayout, QWidget
+from PyQt6.QtWidgets import (
+    QApplication, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
+    QPlainTextEdit, QToolBar, QVBoxLayout, QWidget
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.common import decodeMimeHandles, fontMatcher, minmax, qtLambda, transferCase
-from novelwriter.constants import nwConst, nwKeyWords, nwShortcode, nwUnicode
+from novelwriter.common import (
+    decodeMimeHandles, fontMatcher, minmax, qtAddAction, qtLambda, transferCase
+)
+from novelwriter.constants import (
+    nwConst, nwKeyWords, nwLabels, nwShortcode, nwStats, nwUnicode, trStats
+)
 from novelwriter.core.document import NWDocument
 from novelwriter.enum import (
     nwChange, nwComment, nwDocAction, nwDocInsert, nwDocMode, nwItemClass,
     nwItemType
 )
-from novelwriter.extensions.configlayout import NColourLabel
+from novelwriter.extensions.configlayout import NColorLabel
 from novelwriter.extensions.eventfilters import WheelEventFilter
 from novelwriter.extensions.modified import NIconToggleButton, NIconToolButton
 from novelwriter.gui.dochighlight import BLOCK_META, BLOCK_TITLE
@@ -95,16 +100,17 @@ class GuiDocEditor(QPlainTextEdit):
     """Gui Widget: Main Document Editor"""
 
     __slots__ = (
-        "_nwDocument", "_nwItem", "_docChanged", "_docHandle", "_vpMargin",
-        "_lastEdit", "_lastActive", "_lastFind", "_doReplace", "_autoReplace",
-        "_completer", "_qDocument", "_keyContext", "_followTag1", "_followTag2",
-        "_timerDoc", "_wCounterDoc", "_timerSel", "_wCounterSel",
+        "_autoReplace", "_completer", "_doReplace", "_docChanged", "_docHandle", "_followTag1",
+        "_followTag2", "_keyContext", "_lastActive", "_lastEdit", "_lastFind", "_nwDocument",
+        "_nwItem", "_qDocument", "_timerDoc", "_timerSel", "_vpMargin", "_wCounterDoc",
+        "_wCounterSel",
     )
 
     MOVE_KEYS = (
         Qt.Key.Key_Left, Qt.Key.Key_Right, Qt.Key.Key_Up, Qt.Key.Key_Down,
         Qt.Key.Key_PageUp, Qt.Key.Key_PageDown
     )
+    ENTER_KEYS = (Qt.Key.Key_Return, Qt.Key.Key_Enter)
 
     # Custom Signals
     closeEditorRequest = pyqtSignal()
@@ -112,8 +118,6 @@ class GuiDocEditor(QPlainTextEdit):
     editedStatusChanged = pyqtSignal(bool)
     itemHandleChanged = pyqtSignal(str)
     loadDocumentTagRequest = pyqtSignal(str, Enum)
-    novelItemMetaChanged = pyqtSignal(str)
-    novelStructureChanged = pyqtSignal()
     openDocumentRequest = pyqtSignal(str, Enum, str, bool)
     requestNewNoteCreation = pyqtSignal(str, nwItemClass)
     requestNextDocument = pyqtSignal(str, bool)
@@ -146,7 +150,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._autoReplace = TextAutoReplace()
 
         # Completer
-        self._completer = MetaCompleter(self)
+        self._completer = CommandCompleter(self)
         self._completer.complete.connect(self._insertCompletion)
 
         # Create Custom Document
@@ -175,7 +179,7 @@ class GuiDocEditor(QPlainTextEdit):
         self.customContextMenuRequested.connect(self._openContextMenu)
 
         # Editor Settings
-        self.setMinimumWidth(CONFIG.pxInt(300))
+        self.setMinimumWidth(300)
         self.setAutoFillBackground(True)
         self.setFrameStyle(QFrame.Shape.NoFrame)
         self.setAcceptDrops(True)
@@ -224,7 +228,7 @@ class GuiDocEditor(QPlainTextEdit):
         self.changeFocusState = self.docHeader.changeFocusState
 
         # Finalise
-        self.updateSyntaxColours()
+        self.updateSyntaxColors()
         self.initEditor()
 
         logger.debug("Ready: GuiDocEditor")
@@ -292,21 +296,24 @@ class GuiDocEditor(QPlainTextEdit):
         self.docToolBar.updateTheme()
         return
 
-    def updateSyntaxColours(self) -> None:
+    def updateSyntaxColors(self) -> None:
         """Update the syntax highlighting theme."""
-        mainPalette = self.palette()
-        mainPalette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
-        mainPalette.setColor(QPalette.ColorRole.Base, SHARED.theme.colBack)
-        mainPalette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
-        self.setPalette(mainPalette)
+        syntax = SHARED.theme.syntaxTheme
+
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, syntax.back)
+        palette.setColor(QPalette.ColorRole.Base, syntax.back)
+        palette.setColor(QPalette.ColorRole.Text, syntax.text)
+        self.setPalette(palette)
 
-        docPalette = self.viewport().palette()
-        docPalette.setColor(QPalette.ColorRole.Base, SHARED.theme.colBack)
-        docPalette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
-        self.viewport().setPalette(docPalette)
+        if viewport := self.viewport():
+            palette = viewport.palette()
+            palette.setColor(QPalette.ColorRole.Base, syntax.back)
+            palette.setColor(QPalette.ColorRole.Text, syntax.text)
+            viewport.setPalette(palette)
 
-        self.docHeader.matchColours()
-        self.docFooter.matchColours()
+        self.docHeader.matchColors()
+        self.docFooter.matchColors()
 
         return
 
@@ -317,6 +324,7 @@ class GuiDocEditor(QPlainTextEdit):
         """
         # Auto-Replace
         self._autoReplace.initSettings()
+        self.docFooter.initSettings()
 
         # Reload spell check and dictionaries
         SHARED.updateSpellCheckLanguage()
@@ -336,19 +344,17 @@ class GuiDocEditor(QPlainTextEdit):
         # Due to cursor visibility, a part of the margin must be
         # allocated to the document itself. See issue #1112.
         self._qDocument.setDocumentMargin(4)
-        self._vpMargin = max(CONFIG.getTextMargin() - 4, 0)
+        self._vpMargin = max(CONFIG.textMargin - 4, 0)
         self.setViewportMargins(self._vpMargin, self._vpMargin, self._vpMargin, self._vpMargin)
 
         # Also set the document text options for the document text flow
         options = QTextOption()
-
         if CONFIG.doJustify:
             options.setAlignment(QtAlignJustify)
         if CONFIG.showTabsNSpaces:
             options.setFlags(options.flags() | QTextOption.Flag.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
             options.setFlags(options.flags() | QTextOption.Flag.ShowLineAndParagraphSeparators)
-
         self._qDocument.setDefaultTextOption(options)
 
         # Scrolling
@@ -363,8 +369,9 @@ class GuiDocEditor(QPlainTextEdit):
         else:
             self.setHorizontalScrollBarPolicy(QtScrollAsNeeded)
 
-        # Refresh the tab stops
-        self.setTabStopDistance(CONFIG.getTabWidth())
+        # Refresh sizes
+        self.setTabStopDistance(CONFIG.tabWidth)
+        self.setCursorWidth(CONFIG.cursorWidth)
 
         # If we have a document open, we should refresh it in case the
         # font changed, otherwise we just clear the editor entirely,
@@ -381,19 +388,19 @@ class GuiDocEditor(QPlainTextEdit):
         """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
-        happen of the file contains binary elements or an encoding that
+        happen if the file contains binary elements or an encoding that
         novelWriter does not support. If loading is successful, or the
         document is new (empty string), we set up the editor for editing
         the file.
         """
         self._nwDocument = SHARED.project.storage.getDocument(tHandle)
         self._nwItem = self._nwDocument.nwItem
-        if not ((nwItem := self._nwItem) and nwItem.itemType == nwItemType.FILE):
+        if not (self._nwItem and self._nwItem.itemType == nwItemType.FILE):
             logger.debug("Requested item '%s' is not a document", tHandle)
             self.clearEditor()
             return False
 
-        if (docText := self._nwDocument.readDocument()) is None:
+        if (text := self._nwDocument.readDocument()) is None:
             # There was an I/O error
             self.clearEditor()
             return False
@@ -402,7 +409,7 @@ class GuiDocEditor(QPlainTextEdit):
         self._docHandle = tHandle
 
         self._allowAutoReplace(False)
-        self._qDocument.setTextContent(docText, tHandle)
+        self._qDocument.setTextContent(text, tHandle)
         self._allowAutoReplace(True)
         QApplication.processEvents()
 
@@ -417,7 +424,7 @@ class GuiDocEditor(QPlainTextEdit):
         if isinstance(tLine, int):
             self.setCursorLine(tLine)
         else:
-            self.setCursorPosition(nwItem.cursorPos)
+            self.setCursorPosition(self._nwItem.cursorPos)
 
         self.docHeader.setHandle(tHandle)
         self.docFooter.setHandle(tHandle)
@@ -440,7 +447,7 @@ class GuiDocEditor(QPlainTextEdit):
         # Finalise
         QApplication.restoreOverrideCursor()
         self.updateStatusMessage.emit(
-            self.tr("Opened Document: {0}").format(nwItem.itemName)
+            self.tr("Opened Document: {0}").format(self._nwItem.itemName)
         )
 
         return True
@@ -471,19 +478,17 @@ class GuiDocEditor(QPlainTextEdit):
             )
             return False
 
-        docText = self.getText()
-        cC, wC, pC = standardCounter(docText)
+        text = self.getText()
+        cC, wC, pC = standardCounter(text)
         self._updateDocCounts(cC, wC, pC)
 
-        if not self._nwDocument.writeDocument(docText):
+        if not self._nwDocument.writeDocument(text):
             saveOk = False
-            if self._nwDocument.hashError:
-                msgYes = SHARED.question(self.tr(
-                    "This document has been changed outside of novelWriter "
-                    "while it was open. Overwrite the file on disk?"
-                ))
-                if msgYes:
-                    saveOk = self._nwDocument.writeDocument(docText, forceWrite=True)
+            if self._nwDocument.hashError and SHARED.question(self.tr(
+                "This document has been changed outside of novelWriter "
+                "while it was open. Overwrite the file on disk?"
+            )):
+                saveOk = self._nwDocument.writeDocument(text, forceWrite=True)
 
             if not saveOk:
                 SHARED.error(
@@ -495,52 +500,35 @@ class GuiDocEditor(QPlainTextEdit):
 
         self.setDocumentChanged(False)
         self.docTextChanged.emit(self._docHandle, self._lastEdit)
+        SHARED.project.index.scanText(tHandle, text)
 
-        oldHeader = self._nwItem.mainHeading
-        oldCount = SHARED.project.index.getHandleHeaderCount(tHandle)
-        SHARED.project.index.scanText(tHandle, docText)
-        newHeader = self._nwItem.mainHeading
-        newCount = SHARED.project.index.getHandleHeaderCount(tHandle)
-
-        if self._nwItem.itemClass == nwItemClass.NOVEL:
-            if oldCount == newCount:
-                self.novelItemMetaChanged.emit(tHandle)
-            else:
-                self.novelStructureChanged.emit()
-
-        if oldHeader != newHeader:
-            self.docFooter.updateInfo()
-
-        # Update the status bar
         self.updateStatusMessage.emit(self.tr("Saved Document: {0}").format(self._nwItem.itemName))
 
         return True
 
     def cursorIsVisible(self) -> bool:
         """Check if the cursor is visible in the editor."""
-        return (
-            0 < self.cursorRect().top()
-            and self.cursorRect().bottom() < self.viewport().height()
-        )
+        viewport = self.viewport()
+        height = viewport.height() if viewport else 0
+        return 0 < self.cursorRect().top() and self.cursorRect().bottom() < height
 
     def ensureCursorVisibleNoCentre(self) -> None:
         """Ensure cursor is visible, but don't force it to centre."""
-        cT = self.cursorRect().top()
-        cB = self.cursorRect().bottom()
-        vH = self.viewport().height()
-        if cT < 0:
-            count = 0
-            vBar = self.verticalScrollBar()
-            while self.cursorRect().top() < 0 and count < 100000:
-                vBar.setValue(vBar.value() - 1)
-                count += 1
-        elif cB > vH:
-            count = 0
-            vBar = self.verticalScrollBar()
-            while self.cursorRect().bottom() > vH and count < 100000:
-                vBar.setValue(vBar.value() + 1)
-                count += 1
-        QApplication.processEvents()
+        if (viewport := self.viewport()) and (vBar := self.verticalScrollBar()):
+            cT = self.cursorRect().top()
+            cB = self.cursorRect().bottom()
+            vH = viewport.height()
+            if cT < 0:
+                count = 0
+                while self.cursorRect().top() < 0 and count < 100000:
+                    vBar.setValue(vBar.value() - 1)
+                    count += 1
+            elif cB > vH:
+                count = 0
+                while self.cursorRect().bottom() > vH and count < 100000:
+                    vBar.setValue(vBar.value() + 1)
+                    count += 1
+            QApplication.processEvents()
         return
 
     def updateDocMargins(self) -> None:
@@ -552,10 +540,10 @@ class GuiDocEditor(QPlainTextEdit):
         wH = self.height()
 
         vBar = self.verticalScrollBar()
-        sW = vBar.width() if vBar.isVisible() else 0
+        sW = vBar.width() if vBar and vBar.isVisible() else 0
 
         hBar = self.horizontalScrollBar()
-        sH = hBar.height() if hBar.isVisible() else 0
+        sH = hBar.height() if hBar and hBar.isVisible() else 0
 
         tM = self._vpMargin
         if CONFIG.textWidth > 0 or SHARED.focusMode:
@@ -593,7 +581,7 @@ class GuiDocEditor(QPlainTextEdit):
         QTextDocument->toRawText instead of toPlainText. The former preserves
         non-breaking spaces, the latter does not. We still want to get rid of
         paragraph and line separators though.
-        See: https://doc.qt.io/qt-5/qtextdocument.html#toPlainText
+        See: https://doc.qt.io/qt-6/qtextdocument.html#toPlainText
         """
         text = self._qDocument.toRawText()
         text = text.replace(nwUnicode.U_LSEP, "\n")  # Line separators
@@ -631,10 +619,9 @@ class GuiDocEditor(QPlainTextEdit):
 
     def setCursorPosition(self, position: int) -> None:
         """Move the cursor to a given position in the document."""
-        nChars = self._qDocument.characterCount()
-        if nChars > 1 and isinstance(position, int):
+        if (chars := self._qDocument.characterCount()) > 1 and isinstance(position, int):
             cursor = self.textCursor()
-            cursor.setPosition(minmax(position, 0, nChars-1))
+            cursor.setPosition(minmax(position, 0, chars-1))
             self.setTextCursor(cursor)
             self.centerCursor()
         return
@@ -697,12 +684,10 @@ class GuiDocEditor(QPlainTextEdit):
 
     def spellCheckDocument(self) -> None:
         """Rerun the highlighter to update spell checking status of the
-        currently loaded text. The fastest way to do this, at least as
-        of Qt 5.13, is to clear the text and put it back. This clears
-        the undo stack, so we only do it for big documents.
+        currently loaded text.
         """
-        logger.debug("Running spell checker")
         start = time()
+        logger.debug("Running spell checker")
         QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
         self._qDocument.syntaxHighlighter.rehighlight()
         QApplication.restoreOverrideCursor()
@@ -779,7 +764,7 @@ class GuiDocEditor(QPlainTextEdit):
         elif action == nwDocAction.REPL_SNG:
             self._replaceQuotes("'", CONFIG.fmtSQuoteOpen, CONFIG.fmtSQuoteClose)
         elif action == nwDocAction.REPL_DBL:
-            self._replaceQuotes("\"", CONFIG.fmtDQuoteOpen, CONFIG.fmtDQuoteClose)
+            self._replaceQuotes('"', CONFIG.fmtDQuoteOpen, CONFIG.fmtDQuoteClose)
         elif action == nwDocAction.RM_BREAKS:
             self._removeInParLineBreaks()
         elif action == nwDocAction.ALIGN_L:
@@ -943,9 +928,7 @@ class GuiDocEditor(QPlainTextEdit):
           * We also handle automatic scrolling here.
         """
         self._lastActive = time()
-        isReturn  = event.key() == Qt.Key.Key_Return
-        isReturn |= event.key() == Qt.Key.Key_Enter
-        if isReturn and self.docSearch.anyFocus():
+        if self.docSearch.anyFocus() and event.key() in self.ENTER_KEYS:
             return
         elif event == QKeySequence.StandardKey.Redo:
             self.docAction(nwDocAction.REDO)
@@ -964,10 +947,9 @@ class GuiDocEditor(QPlainTextEdit):
             kMod = event.modifiers()
             okMod = kMod in (QtModNone, QtModShift)
             okKey = event.key() not in self.MOVE_KEYS
-            if nPos != cPos and okMod and okKey:
-                mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
-                if cPos > mPos:
-                    vBar = self.verticalScrollBar()
+            if nPos != cPos and okMod and okKey and (viewport := self.viewport()):
+                mPos = CONFIG.autoScrollPos*0.01 * viewport.height()
+                if cPos > mPos and (vBar := self.verticalScrollBar()):
                     vBar.setValue(vBar.value() + (1 if nPos > cPos else -1))
         else:
             super().keyPressEvent(event)
@@ -976,7 +958,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def dragEnterEvent(self, event: QDragEnterEvent) -> None:
         """Overload drag enter event to handle dragged items."""
-        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+        if (data := event.mimeData()) and data.hasFormat(nwConst.MIME_HANDLE):
             event.acceptProposedAction()
         else:
             super().dragEnterEvent(event)
@@ -984,7 +966,7 @@ class GuiDocEditor(QPlainTextEdit):
 
     def dragMoveEvent(self, event: QDragMoveEvent) -> None:
         """Overload drag move event to handle dragged items."""
-        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
+        if (data := event.mimeData()) and data.hasFormat(nwConst.MIME_HANDLE):
             event.acceptProposedAction()
         else:
             super().dragMoveEvent(event)
@@ -992,15 +974,15 @@ class GuiDocEditor(QPlainTextEdit):
 
     def dropEvent(self, event: QDropEvent) -> None:
         """Overload drop event to handle dragged items."""
-        if event.mimeData().hasFormat(nwConst.MIME_HANDLE):
-            if handles := decodeMimeHandles(event.mimeData()):
+        if (data := event.mimeData()) and data.hasFormat(nwConst.MIME_HANDLE):
+            if handles := decodeMimeHandles(data):
                 if SHARED.project.tree.checkType(handles[0], nwItemType.FILE):
                     self.openDocumentRequest.emit(handles[0], nwDocMode.EDIT, "", True)
         else:
             super().dropEvent(event)
         return
 
-    def focusNextPrevChild(self, next: bool) -> bool:
+    def focusNextPrevChild(self, _next: bool) -> bool:
         """Capture the focus request from the tab key on the text
         editor. If the editor has focus, we do not change focus and
         allow the editor to insert a tab. If the search bar has focus,
@@ -1059,7 +1041,7 @@ class GuiDocEditor(QPlainTextEdit):
             logger.error("Invalid keyword '%s'", keyword)
             return False
         logger.debug("Inserting keyword '%s'", keyword)
-        state = self.insertNewBlock("%s: " % keyword)
+        state = self.insertNewBlock(f"{keyword}: ")
         return state
 
     @pyqtSlot()
@@ -1098,15 +1080,18 @@ class GuiDocEditor(QPlainTextEdit):
 
         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
+            if text and text[0] in "@%" and added + removed == 1:
+                # Only run on single character changes, or 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)
+                if bPos > 0 and (viewport := self.viewport()):
+                    if text[0] == "@":
+                        show = self._completer.updateMetaText(text, bPos)
+                    else:
+                        show = self._completer.updateCommentText(text, bPos)
                     point = self.cursorRect().bottomRight()
-                    self._completer.move(self.viewport().mapToGlobal(point))
+                    self._completer.move(viewport.mapToGlobal(point))
                     self._completer.setVisible(show)
             else:
                 self._completer.setVisible(False)
@@ -1128,11 +1113,10 @@ class GuiDocEditor(QPlainTextEdit):
     def _insertCompletion(self, pos: int, length: int, text: str) -> None:
         """Insert choice from the completer menu."""
         cursor = self.textCursor()
-        block = cursor.block()
-        if block.isValid():
-            pos += block.position()
-            cursor.setPosition(pos, QtMoveAnchor)
-            cursor.setPosition(pos + length, QtKeepAnchor)
+        if (block := cursor.block()).isValid():
+            check = pos + block.position()
+            cursor.setPosition(check, QtMoveAnchor)
+            cursor.setPosition(check + length, QtKeepAnchor)
             cursor.insertText(text)
             self._completer.hide()
         return
@@ -1153,46 +1137,46 @@ class GuiDocEditor(QPlainTextEdit):
         ctxMenu = QMenu(self)
         ctxMenu.setObjectName("ContextMenu")
         if pBlock.userState() == BLOCK_TITLE:
-            action = ctxMenu.addAction(self.tr("Set as Document Name"))
+            action = qtAddAction(ctxMenu, self.tr("Set as Document Name"))
             action.triggered.connect(qtLambda(self._emitRenameItem, pBlock))
 
         # URL
         (mData, mType) = self._qDocument.metaDataAtPos(pCursor.position())
         if mData and mType == "url":
-            action = ctxMenu.addAction(self.tr("Open URL"))
+            action = qtAddAction(ctxMenu, self.tr("Open URL"))
             action.triggered.connect(qtLambda(SHARED.openWebsite, mData))
             ctxMenu.addSeparator()
 
         # Follow
         status = self._processTag(cursor=pCursor, follow=False)
         if status & _TagAction.FOLLOW:
-            action = ctxMenu.addAction(self.tr("Follow Tag"))
+            action = qtAddAction(ctxMenu, self.tr("Follow Tag"))
             action.triggered.connect(qtLambda(self._processTag, cursor=pCursor, follow=True))
             ctxMenu.addSeparator()
         elif status & _TagAction.CREATE:
-            action = ctxMenu.addAction(self.tr("Create Note for Tag"))
+            action = qtAddAction(ctxMenu, self.tr("Create Note for Tag"))
             action.triggered.connect(qtLambda(self._processTag, cursor=pCursor, create=True))
             ctxMenu.addSeparator()
 
         # Cut, Copy and Paste
         if uCursor.hasSelection():
-            action = ctxMenu.addAction(self.tr("Cut"))
+            action = qtAddAction(ctxMenu, self.tr("Cut"))
             action.triggered.connect(qtLambda(self.docAction, nwDocAction.CUT))
-            action = ctxMenu.addAction(self.tr("Copy"))
+            action = qtAddAction(ctxMenu, self.tr("Copy"))
             action.triggered.connect(qtLambda(self.docAction, nwDocAction.COPY))
 
-        action = ctxMenu.addAction(self.tr("Paste"))
+        action = qtAddAction(ctxMenu, self.tr("Paste"))
         action.triggered.connect(qtLambda(self.docAction, nwDocAction.PASTE))
         ctxMenu.addSeparator()
 
         # Selections
-        action = ctxMenu.addAction(self.tr("Select All"))
+        action = qtAddAction(ctxMenu, self.tr("Select All"))
         action.triggered.connect(qtLambda(self.docAction, nwDocAction.SEL_ALL))
-        action = ctxMenu.addAction(self.tr("Select Word"))
+        action = qtAddAction(ctxMenu, self.tr("Select Word"))
         action.triggered.connect(qtLambda(
             self._makePosSelection, QTextCursor.SelectionType.WordUnderCursor, pos,
         ))
-        action = ctxMenu.addAction(self.tr("Select Paragraph"))
+        action = qtAddAction(ctxMenu, self.tr("Select Paragraph"))
         action.triggered.connect(qtLambda(
             self._makePosSelection, QTextCursor.SelectionType.BlockUnderCursor, pos
         ))
@@ -1208,22 +1192,24 @@ class GuiDocEditor(QPlainTextEdit):
                 sCursor.movePosition(QtMoveRight, QtKeepAnchor, cLen)
                 if suggest:
                     ctxMenu.addSeparator()
-                    ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
+                    qtAddAction(ctxMenu, self.tr("Spelling Suggestion(s)"))
                     for option in suggest[:15]:
-                        action = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
+                        action = qtAddAction(ctxMenu, f"{nwUnicode.U_ENDASH} {option}")
                         action.triggered.connect(qtLambda(self._correctWord, sCursor, option))
                 else:
                     trNone = self.tr("No Suggestions")
-                    ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {trNone}")
+                    qtAddAction(ctxMenu, f"{nwUnicode.U_ENDASH} {trNone}")
 
                 ctxMenu.addSeparator()
-                action = ctxMenu.addAction(self.tr("Ignore Word"))
+                action = qtAddAction(ctxMenu, self.tr("Ignore Word"))
                 action.triggered.connect(qtLambda(self._addWord, word, block, False))
-                action = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
+                action = qtAddAction(ctxMenu, self.tr("Add Word to Dictionary"))
                 action.triggered.connect(qtLambda(self._addWord, word, block, True))
 
         # Execute the context menu
-        ctxMenu.exec(self.viewport().mapToGlobal(pos))
+        if viewport := self.viewport():
+            ctxMenu.exec(viewport.mapToGlobal(pos))
+
         ctxMenu.setParent(None)
 
         return
@@ -1254,7 +1240,8 @@ class GuiDocEditor(QPlainTextEdit):
         """Process the word counter's finished signal."""
         if self._docHandle and self._nwItem:
             logger.debug("Updating word count")
-            needsRefresh = wCount != self._nwItem.wordCount
+            mCount = cCount if CONFIG.useCharCount else wCount
+            needsRefresh = mCount != self._nwItem.mainCount
             self._nwItem.setCharCount(cCount)
             self._nwItem.setWordCount(wCount)
             self._nwItem.setParaCount(pCount)
@@ -1262,7 +1249,7 @@ class GuiDocEditor(QPlainTextEdit):
                 self._nwItem.notifyToRefresh()
                 if not self.textCursor().hasSelection():
                     # Selection counter should take precedence (#2155)
-                    self.docFooter.updateWordCount(wCount, False)
+                    self.docFooter.updateMainCount(mCount, False)
         return
 
     @pyqtSlot()
@@ -1275,29 +1262,24 @@ class GuiDocEditor(QPlainTextEdit):
                 self._timerSel.start()
         else:
             self._timerSel.stop()
-            self.docFooter.updateWordCount(0, False)
+            self.docFooter.updateMainCount(0, False)
         return
 
     @pyqtSlot()
     def _runSelCounter(self) -> None:
         """Update the selection word count."""
-        if self._docHandle is None:
-            return
-
-        if self._wCounterSel.isRunning():
-            logger.debug("Selection word counter is busy")
-            return
-
-        SHARED.runInThreadPool(self._wCounterSel)
-
+        if self._docHandle:
+            if self._wCounterSel.isRunning():
+                logger.debug("Selection word counter is busy")
+                return
+            SHARED.runInThreadPool(self._wCounterSel)
         return
 
     @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 and self._nwItem:
-            logger.debug("User selected %d words", wCount)
-            self.docFooter.updateWordCount(wCount, True)
+            self.docFooter.updateMainCount(cCount if CONFIG.useCharCount else wCount, True)
             self._timerSel.stop()
         return
 
@@ -1347,6 +1329,7 @@ class GuiDocEditor(QPlainTextEdit):
             self.beginSearch()
             return
 
+        prevFocus = QApplication.focusWidget() or self
         resS, resE = self.findAllOccurences()
         if len(resS) == 0 and self._docHandle:
             self.docSearch.setResultCount(0, 0)
@@ -1355,7 +1338,7 @@ class GuiDocEditor(QPlainTextEdit):
                 self.requestNextDocument.emit(self._docHandle, CONFIG.searchLoop)
                 QApplication.processEvents()
                 self.beginSearch()
-                self.setFocus()
+                prevFocus.setFocus()
             return
 
         cursor = self.textCursor()
@@ -1375,7 +1358,7 @@ class GuiDocEditor(QPlainTextEdit):
                 self.requestNextDocument.emit(self._docHandle, CONFIG.searchLoop)
                 QApplication.processEvents()
                 self.beginSearch()
-                self.setFocus()
+                prevFocus.setFocus()
                 return
             else:
                 resIdx = 0 if doLoop else maxIdx
@@ -1552,10 +1535,10 @@ class GuiDocEditor(QPlainTextEdit):
         if fLen == min(numA, numB):
             cursor.beginEditBlock()
             cursor.setPosition(posS)
-            for i in range(fLen):
+            for _ in range(fLen):
                 cursor.deletePreviousChar()
             cursor.setPosition(posE)
-            for i in range(fLen):
+            for _ in range(fLen):
                 cursor.deletePreviousChar()
             cursor.endEditBlock()
 
@@ -1569,8 +1552,10 @@ class GuiDocEditor(QPlainTextEdit):
 
         return
 
-    def _wrapSelection(self, before: str, after: str | None = None, pos: int | None = None,
-                       select: _SelectAction = _SelectAction.NO_DECISION) -> None:
+    def _wrapSelection(
+        self, before: str, after: str | None = None, pos: int | None = None,
+        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
@@ -1965,7 +1950,9 @@ class GuiDocEditor(QPlainTextEdit):
             exist = False
             cPos = cursor.selectionStart() - block.position()
             tExist = SHARED.project.index.checkThese(tBits, self._docHandle)
-            for sTag, sPos, sExist in zip(reversed(tBits), reversed(tPos), reversed(tExist)):
+            for sTag, sPos, sExist in zip(
+                reversed(tBits), reversed(tPos), reversed(tExist), strict=False
+            ):
                 if cPos >= sPos:
                     # The cursor is between the start of two tags
                     if cPos <= sPos + len(sTag):
@@ -2021,9 +2008,9 @@ class GuiDocEditor(QPlainTextEdit):
             sPos = cPos
             for i in range(cPos - bPos):
                 sPos = cPos - i - 1
-                cOne = self._qDocument.characterAt(sPos)
-                cTwo = self._qDocument.characterAt(sPos - 1)
-                if not (cOne.isalnum() or cOne in apos and cTwo.isalnum()):
+                cOne = str(self._qDocument.characterAt(sPos))
+                cTwo = str(self._qDocument.characterAt(sPos - 1))
+                if not (cOne.isalnum() or (cOne in apos and cTwo.isalnum())):
                     sPos += 1
                     break
 
@@ -2031,9 +2018,9 @@ class GuiDocEditor(QPlainTextEdit):
             ePos = cPos
             for i in range(bPos + bLen - cPos):
                 ePos = cPos + i
-                cOne = self._qDocument.characterAt(ePos)
-                cTwo = self._qDocument.characterAt(ePos + 1)
-                if not (cOne.isalnum() or cOne in apos and cTwo.isalnum()):
+                cOne = str(self._qDocument.characterAt(ePos))
+                cTwo = str(self._qDocument.characterAt(ePos + 1))
+                if not (cOne.isalnum() or (cOne in apos and cTwo.isalnum())):
                     break
 
             if ePos - sPos <= 0:
@@ -2048,8 +2035,9 @@ class GuiDocEditor(QPlainTextEdit):
 
         return cursor
 
-    def _makeSelection(self, mode: QTextCursor.SelectionType,
-                       cursor: QTextCursor | None = None) -> None:
+    def _makeSelection(
+        self, mode: QTextCursor.SelectionType, cursor: QTextCursor | None = None
+    ) -> None:
         """Select text based on selection mode."""
         if cursor is None:
             cursor = self.textCursor()
@@ -2089,13 +2077,13 @@ class GuiDocEditor(QPlainTextEdit):
         return
 
 
-class MetaCompleter(QMenu):
-    """GuiWidget: Meta Completer Menu
+class CommandCompleter(QMenu):
+    """GuiWidget: Command Completer Menu
 
     This is a context menu with options populated from the user's
-    defined tags. It also helps to type the meta data keyword on a new
-    line starting with an @. The updateText function should be called on
-    every keystroke on a line starting with @.
+    defined tags and keys. It also helps to type the meta data keyword
+    on a new line starting with @ or %. The update functions should be
+    called on every keystroke on a line starting with @ or %.
     """
 
     complete = pyqtSignal(int, int, str)
@@ -2104,7 +2092,7 @@ class MetaCompleter(QMenu):
         super().__init__(parent=parent)
         return
 
-    def updateText(self, text: str, pos: int) -> bool:
+    def updateMetaText(self, text: str, pos: int) -> bool:
         """Update the menu options based on the line of text."""
         self.clear()
         kw, sep, _ = text.partition(":")
@@ -2112,7 +2100,7 @@ class MetaCompleter(QMenu):
             offset = 0
             length = len(kw.rstrip())
             suffix = "" if sep else ":"
-            options = list(filter(
+            options = sorted(filter(
                 lambda x: x.startswith(kw.rstrip()), nwKeyWords.VALID_KEYS
             ))
         else:
@@ -2124,7 +2112,7 @@ class MetaCompleter(QMenu):
             offset = tPos[index] if lookup else pos
             length = len(lookup)
             suffix = ""
-            options = list(filter(
+            options = sorted(filter(
                 lambda x: lookup in x.lower(), SHARED.project.index.getClassTags(
                     nwKeyWords.KEY_CLASS.get(kw.strip())
                 )
@@ -2133,13 +2121,57 @@ class MetaCompleter(QMenu):
         if not options:
             return False
 
-        for value in sorted(options):
+        for value in options:
             rep = value + suffix
-            action = self.addAction(value)
+            action = qtAddAction(self, value)
             action.triggered.connect(qtLambda(self._emitComplete, offset, length, rep))
 
         return True
 
+    def updateCommentText(self, text: str, pos: int) -> bool:
+        """Update the menu options based on the line of text."""
+        self.clear()
+        cmd, sep, _ = text.partition(":")
+        if pos <= len(cmd):
+            clean = text[1:].lstrip()[:6].lower()
+            if clean[:6] == "story.":
+                pre, _, key = cmd.partition(".")
+                offset = len(pre) + 1
+                length = len(key)
+                suffix = "" if sep else ": "
+                options = sorted(filter(
+                    lambda x: x.startswith(key.rstrip()),
+                    SHARED.project.index.getStoryKeys(),
+                ))
+            elif clean[:5] == "note.":
+                pre, _, key = cmd.partition(".")
+                offset = len(pre) + 1
+                length = len(key)
+                suffix = "" if sep else ": "
+                options = sorted(filter(
+                    lambda x: x.startswith(key.rstrip()),
+                    SHARED.project.index.getNoteKeys(),
+                ))
+            elif pos < 12:
+                offset = 0
+                length = len(cmd.rstrip())
+                suffix = ""
+                options = list(filter(
+                    lambda x: x.startswith(cmd.rstrip()),
+                    ["%Synopsis: ", "%Short: ", "%Story", "%Note"],
+                ))
+            else:
+                return False
+
+            if options:
+                for value in options:
+                    rep = value + suffix
+                    action = qtAddAction(self, rep.rstrip(":. "))
+                    action.triggered.connect(qtLambda(self._emitComplete, offset, length, rep))
+                return True
+
+        return False
+
     ##
     #  Events
     ##
@@ -2175,13 +2207,10 @@ class BackgroundWordCounter(QRunnable):
 
     def __init__(self, docEditor: GuiDocEditor, forSelection: bool = False) -> None:
         super().__init__()
-
         self._docEditor = docEditor
         self._forSelection = forSelection
         self._isRunning = False
-
         self.signals = BackgroundWordCounterSignals()
-
         return
 
     def isRunning(self) -> bool:
@@ -2215,9 +2244,9 @@ class BackgroundWordCounterSignals(QObject):
 class TextAutoReplace:
 
     __slots__ = (
-        "_quoteSO", "_quoteSC", "_quoteDO", "_quoteDC",
-        "_replaceSQuote", "_replaceDQuote", "_replaceDash", "_replaceDots",
-        "_padChar", "_padBefore", "_padAfter", "_doPadBefore", "_doPadAfter",
+        "_doPadAfter", "_doPadBefore", "_padAfter", "_padBefore", "_padChar",
+        "_quoteDC", "_quoteDO", "_quoteSC", "_quoteSO", "_replaceDQuote",
+        "_replaceDash", "_replaceDots", "_replaceSQuote",
     )
 
     def __init__(self) -> None:
@@ -2352,7 +2381,6 @@ class GuiDocToolBar(QWidget):
         logger.debug("Create: GuiDocToolBar")
 
         iSz = SHARED.theme.baseIconSize
-        cM = CONFIG.pxInt(4)
         self.setContentsMargins(0, 0, 0, 0)
 
         # General Buttons
@@ -2425,7 +2453,7 @@ class GuiDocToolBar(QWidget):
         self.outerBox.addWidget(self.tbBoldMD)
         self.outerBox.addWidget(self.tbItalicMD)
         self.outerBox.addWidget(self.tbStrikeMD)
-        self.outerBox.addSpacing(cM)
+        self.outerBox.addSpacing(4)
         self.outerBox.addWidget(self.tbBold)
         self.outerBox.addWidget(self.tbItalic)
         self.outerBox.addWidget(self.tbStrike)
@@ -2433,8 +2461,8 @@ class GuiDocToolBar(QWidget):
         self.outerBox.addWidget(self.tbMark)
         self.outerBox.addWidget(self.tbSuperscript)
         self.outerBox.addWidget(self.tbSubscript)
-        self.outerBox.setContentsMargins(cM, cM, cM, cM)
-        self.outerBox.setSpacing(cM)
+        self.outerBox.setContentsMargins(4, 4, 4, 4)
+        self.outerBox.setSpacing(4)
 
         self.setLayout(self.outerBox)
         self.updateTheme()
@@ -2448,15 +2476,17 @@ class GuiDocToolBar(QWidget):
 
     def updateTheme(self) -> None:
         """Initialise GUI elements that depend on specific settings."""
-        palette = QPalette()
-        palette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
-        palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
-        palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
+        syntax = SHARED.theme.syntaxTheme
+
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, syntax.back)
+        palette.setColor(QPalette.ColorRole.WindowText, syntax.text)
+        palette.setColor(QPalette.ColorRole.Text, syntax.text)
         self.setPalette(palette)
 
-        self.tbBoldMD.setThemeIcon("fmt_bold-md")
-        self.tbItalicMD.setThemeIcon("fmt_italic-md")
-        self.tbStrikeMD.setThemeIcon("fmt_strike-md")
+        self.tbBoldMD.setThemeIcon("fmt_bold", "orange")
+        self.tbItalicMD.setThemeIcon("fmt_italic", "orange")
+        self.tbStrikeMD.setThemeIcon("fmt_strike", "orange")
         self.tbBold.setThemeIcon("fmt_bold")
         self.tbItalic.setThemeIcon("fmt_italic")
         self.tbStrike.setThemeIcon("fmt_strike")
@@ -2483,7 +2513,6 @@ class GuiDocEditSearch(QFrame):
         self.docEditor = docEditor
 
         iSz = SHARED.theme.baseIconSize
-        mPx = CONFIG.pxInt(6)
 
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
@@ -2509,7 +2538,7 @@ class GuiDocEditSearch(QFrame):
         self.searchOpt.setContentsMargins(0, 0, 0, 0)
 
         self.searchLabel = QLabel(self.tr("Search"), self)
-        self.searchLabel.setIndent(CONFIG.pxInt(6))
+        self.searchLabel.setIndent(6)
 
         self.resultLabel = QLabel("?/?", self)
 
@@ -2586,12 +2615,11 @@ class GuiDocEditSearch(QFrame):
         self.mainBox.setColumnStretch(3, 0)
         self.mainBox.setColumnStretch(4, 0)
         self.mainBox.setColumnStretch(5, 0)
-        self.mainBox.setSpacing(CONFIG.pxInt(2))
-        self.mainBox.setContentsMargins(mPx, mPx, mPx, mPx)
+        self.mainBox.setSpacing(2)
+        self.mainBox.setContentsMargins(6, 6, 6, 6)
 
-        boxWidth = CONFIG.pxInt(200)
-        self.searchBox.setFixedWidth(boxWidth)
-        self.replaceBox.setFixedWidth(boxWidth)
+        self.searchBox.setFixedWidth(200)
+        self.replaceBox.setFixedWidth(200)
         self.replaceBox.setVisible(False)
         self.replaceButton.setVisible(False)
         self.adjustSize()
@@ -2693,10 +2721,11 @@ class GuiDocEditSearch(QFrame):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        qPalette = QApplication.palette()
-        self.setPalette(qPalette)
-        self.searchBox.setPalette(qPalette)
-        self.replaceBox.setPalette(qPalette)
+        palette = QApplication.palette()
+
+        self.setPalette(palette)
+        self.searchBox.setPalette(palette)
+        self.replaceBox.setPalette(palette)
 
         # Set icons
         self.toggleCase.setIcon(SHARED.theme.getIcon("search_case"))
@@ -2706,31 +2735,13 @@ 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.setThemeIcon("search")
-        self.replaceButton.setThemeIcon("search_replace")
+        self.searchButton.setThemeIcon("search", "green")
+        self.replaceButton.setThemeIcon("search_replace", "green")
 
         # Set stylesheets
         self.searchOpt.setStyleSheet("QToolBar {padding: 0;}")
         self.showReplace.setStyleSheet("QToolButton {border: none; background: transparent;}")
 
-        # Construct Box Colours
-        qPalette = self.searchBox.palette()
-        baseCol = qPalette.base().color()
-        rCol = baseCol.redF() + 0.1
-        gCol = baseCol.greenF() - 0.1
-        bCol = baseCol.blueF() - 0.1
-
-        mCol = max(rCol, gCol, bCol, 1.0)
-        errCol = QColor()
-        errCol.setRedF(rCol/mCol)
-        errCol.setGreenF(gCol/mCol)
-        errCol.setBlueF(bCol/mCol)
-
-        self.rxCol = {
-            True: baseCol,
-            False: errCol
-        }
-
         return
 
     def cycleFocus(self) -> bool:
@@ -2747,7 +2758,7 @@ class GuiDocEditSearch(QFrame):
 
     def anyFocus(self) -> bool:
         """Return True if any of the input boxes have focus."""
-        return self.searchBox.hasFocus() or self.replaceBox.hasFocus()
+        return self.hasFocus() or self.isAncestorOf(QApplication.focusWidget())
 
     ##
     #  Public Slots
@@ -2831,9 +2842,12 @@ class GuiDocEditSearch(QFrame):
         """Highlight the search box to indicate the search string is or
         isn't valid. Take the colour from the replace box.
         """
-        qPalette = self.replaceBox.palette()
-        qPalette.setColor(QPalette.ColorRole.Base, self.rxCol[isValid])
-        self.searchBox.setPalette(qPalette)
+        palette = self.replaceBox.palette()
+        palette.setColor(
+            QPalette.ColorRole.Text,
+            palette.text().color() if isValid else SHARED.theme.errorText
+        )
+        self.searchBox.setPalette(palette)
         return
 
 
@@ -2859,13 +2873,12 @@ class GuiDocEditHeader(QWidget):
 
         iPx = SHARED.theme.baseIconHeight
         iSz = SHARED.theme.baseIconSize
-        mPx = CONFIG.pxInt(4)
 
         # Main Widget Settings
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.itemTitle = NColourLabel("", self, faded=SHARED.theme.fadedText)
+        self.itemTitle = NColorLabel("", self, faded=SHARED.theme.fadedText)
         self.itemTitle.setMargin(0)
         self.itemTitle.setContentsMargins(0, 0, 0, 0)
         self.itemTitle.setAutoFillBackground(True)
@@ -2906,13 +2919,13 @@ class GuiDocEditHeader(QWidget):
         self.outerBox.addWidget(self.tbButton, 0)
         self.outerBox.addWidget(self.outlineButton, 0)
         self.outerBox.addWidget(self.searchButton, 0)
-        self.outerBox.addSpacing(mPx)
+        self.outerBox.addSpacing(4)
         self.outerBox.addWidget(self.itemTitle, 1)
-        self.outerBox.addSpacing(mPx)
+        self.outerBox.addSpacing(4)
         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.setContentsMargins(4, 4, 4, 4)
         self.outerBox.setSpacing(0)
 
         self.setLayout(self.outerBox)
@@ -2923,7 +2936,7 @@ class GuiDocEditHeader(QWidget):
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
         self.setContentsMargins(0, 0, 0, 0)
-        self.setMinimumHeight(iPx + 2*mPx)
+        self.setMinimumHeight(iPx + 8)
 
         self.updateFont()
         self.updateTheme()
@@ -2956,7 +2969,7 @@ class GuiDocEditHeader(QWidget):
             tStart = time()
             self.outlineMenu.clear()
             for number, text in data.items():
-                action = self.outlineMenu.addAction(text)
+                action = qtAddAction(self.outlineMenu, text)
                 action.triggered.connect(qtLambda(self._gotoBlock, number))
             self._docOutline = data
             logger.debug("Document outline updated in %.3f ms", 1000*(time() - tStart))
@@ -2970,11 +2983,11 @@ class GuiDocEditHeader(QWidget):
 
     def updateTheme(self) -> None:
         """Update theme elements."""
-        self.tbButton.setThemeIcon("toolbar")
-        self.outlineButton.setThemeIcon("list")
-        self.searchButton.setThemeIcon("search")
-        self.minmaxButton.setThemeIcon("maximise")
-        self.closeButton.setThemeIcon("close")
+        self.tbButton.setThemeIcon("fmt_toolbar", "blue")
+        self.outlineButton.setThemeIcon("list", "blue")
+        self.searchButton.setThemeIcon("search", "blue")
+        self.minmaxButton.setThemeIcon("maximise", "blue")
+        self.closeButton.setThemeIcon("close", "red")
 
         buttonStyle = SHARED.theme.getStyleSheet(STYLES_MIN_TOOLBUTTON)
         self.tbButton.setStyleSheet(buttonStyle)
@@ -2983,18 +2996,19 @@ class GuiDocEditHeader(QWidget):
         self.minmaxButton.setStyleSheet(buttonStyle)
         self.closeButton.setStyleSheet(buttonStyle)
 
-        self.matchColours()
+        self.matchColors()
 
         return
 
-    def matchColours(self) -> None:
+    def matchColors(self) -> None:
         """Update the colours of the widget to match those of the syntax
         theme rather than the main GUI.
         """
-        palette = QPalette()
-        palette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
-        palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
-        palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
+        syntax = SHARED.theme.syntaxTheme
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, syntax.back)
+        palette.setColor(QPalette.ColorRole.WindowText, syntax.text)
+        palette.setColor(QPalette.ColorRole.Text, syntax.text)
         self.setPalette(palette)
         self.itemTitle.setTextColors(
             color=palette.windowText().color(), faded=SHARED.theme.fadedText
@@ -3047,7 +3061,7 @@ class GuiDocEditHeader(QWidget):
     @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")
+        self.minmaxButton.setThemeIcon("minimise" if focusMode else "maximise", "blue")
         return
 
     ##
@@ -3080,14 +3094,11 @@ class GuiDocEditFooter(QWidget):
 
         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)
 
         # Cached Translations
+        self.initSettings()
         self._trLineCount = self.tr("Line: {0} ({1})")
-        self._trWordCount = self.tr("Words: {0} ({1})")
-        self._trSelectCount = self.tr("Words: {0} selected")
+        self._trSelectCount = self.tr("Selected: {0}")
 
         # Main Widget Settings
         self.setContentsMargins(0, 0, 0, 0)
@@ -3095,72 +3106,60 @@ class GuiDocEditFooter(QWidget):
 
         # Status
         self.statusIcon = QLabel("", self)
-        self.statusIcon.setContentsMargins(0, 0, 0, 0)
         self.statusIcon.setFixedHeight(iPx)
         self.statusIcon.setAlignment(QtAlignLeftTop)
 
-        self.statusText = QLabel(self.tr("Status"), self)
-        self.statusText.setIndent(0)
-        self.statusText.setMargin(0)
-        self.statusText.setContentsMargins(0, 0, 0, 0)
+        self.statusText = QLabel("", self)
         self.statusText.setAutoFillBackground(True)
         self.statusText.setFixedHeight(fPx)
         self.statusText.setAlignment(QtAlignLeftTop)
 
         # Lines
         self.linesIcon = QLabel("", self)
-        self.linesIcon.setContentsMargins(0, 0, 0, 0)
         self.linesIcon.setFixedHeight(iPx)
         self.linesIcon.setAlignment(QtAlignLeftTop)
 
         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(QtAlignLeftTop)
 
         # Words
         self.wordsIcon = QLabel("", self)
-        self.wordsIcon.setContentsMargins(0, 0, 0, 0)
         self.wordsIcon.setFixedHeight(iPx)
         self.wordsIcon.setAlignment(QtAlignLeftTop)
 
         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(QtAlignLeftTop)
 
         # Assemble Layout
         self.outerBox = QHBoxLayout()
-        self.outerBox.setSpacing(bSp)
+        self.outerBox.setSpacing(4)
         self.outerBox.addWidget(self.statusIcon)
         self.outerBox.addWidget(self.statusText)
         self.outerBox.addStretch(1)
         self.outerBox.addWidget(self.linesIcon)
         self.outerBox.addWidget(self.linesText)
-        self.outerBox.addSpacing(hSp)
+        self.outerBox.addSpacing(6)
         self.outerBox.addWidget(self.wordsIcon)
         self.outerBox.addWidget(self.wordsText)
-        self.outerBox.setContentsMargins(mPx, mPx, mPx, mPx)
+        self.outerBox.setContentsMargins(8, 8, 8, 8)
 
         self.setLayout(self.outerBox)
 
         # Fix Margins and Size
         # This is needed for high DPI systems. See issue #499.
         self.setContentsMargins(0, 0, 0, 0)
-        self.setMinimumHeight(fPx + 2*mPx)
+        self.setMinimumHeight(fPx + 16)
 
         # Fix the Colours
         self.updateFont()
         self.updateTheme()
 
         # Initialise Info
-        self.updateWordCount(0, False)
+        self.updateMainCount(0, False)
 
         logger.debug("Ready: GuiDocEditFooter")
 
@@ -3170,6 +3169,13 @@ class GuiDocEditFooter(QWidget):
     #  Methods
     ##
 
+    def initSettings(self) -> None:
+        """Apply user settings."""
+        self._trMainCount = trStats(nwLabels.STATS_DISPLAY[
+            nwStats.CHARS if CONFIG.useCharCount else nwStats.WORDS
+        ])
+        return
+
     def updateFont(self) -> None:
         """Update the font settings."""
         self.setFont(SHARED.theme.guiFont)
@@ -3181,19 +3187,21 @@ class GuiDocEditFooter(QWidget):
     def updateTheme(self) -> None:
         """Update theme elements."""
         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()
+        self.linesIcon.setPixmap(SHARED.theme.getPixmap("lines", (iPx, iPx)))
+        self.wordsIcon.setPixmap(SHARED.theme.getPixmap("stats", (iPx, iPx)))
+        self.matchColors()
         return
 
-    def matchColours(self) -> None:
+    def matchColors(self) -> None:
         """Update the colours of the widget to match those of the syntax
         theme rather than the main GUI.
         """
-        palette = QPalette()
-        palette.setColor(QPalette.ColorRole.Window, SHARED.theme.colBack)
-        palette.setColor(QPalette.ColorRole.WindowText, SHARED.theme.colText)
-        palette.setColor(QPalette.ColorRole.Text, SHARED.theme.colText)
+        syntax = SHARED.theme.syntaxTheme
+
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, syntax.back)
+        palette.setColor(QPalette.ColorRole.WindowText, syntax.text)
+        palette.setColor(QPalette.ColorRole.Text, syntax.text)
 
         self.setPalette(palette)
         self.statusText.setPalette(palette)
@@ -3212,7 +3220,7 @@ class GuiDocEditFooter(QWidget):
             self._tItem = SHARED.project.tree[self._docHandle]
 
         self.updateInfo()
-        self.updateWordCount(0, False)
+        self.updateMainCount(0, False)
 
         return
 
@@ -3234,23 +3242,24 @@ class GuiDocEditFooter(QWidget):
 
     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._trLineCount.format(f"{cLine:n}", f"{100*cPos//cCount:d} %")
-        )
+        if document := cursor.document():
+            cPos = cursor.position() + 1
+            cLine = cursor.blockNumber() + 1
+            cCount = max(document.characterCount(), 1)
+            self.linesText.setText(
+                self._trLineCount.format(f"{cLine:n}", f"{100*cPos//cCount:d} %")
+            )
         return
 
-    def updateWordCount(self, wCount: int, selection: bool) -> None:
-        """Update word counter information."""
-        if selection and wCount:
-            wText = self._trSelectCount.format(f"{wCount:n}")
+    def updateMainCount(self, count: int, selection: bool) -> None:
+        """Update main counter information."""
+        if selection and count:
+            text = self._trSelectCount.format(f"{count:n}")
         elif self._tItem:
-            wCount = self._tItem.wordCount
-            wDiff = wCount - self._tItem.initCount
-            wText = self._trWordCount.format(f"{wCount:n}", f"{wDiff:+n}")
+            count = self._tItem.mainCount
+            diff = count - self._tItem.initCount
+            text = self._trMainCount.format(f"{count:n}", f"{diff:+n}")
         else:
-            wText = self._trWordCount.format("0", "+0")
-        self.wordsText.setText(wText)
+            text = self._trMainCount.format("0", "+0")
+        self.wordsText.setText(text)
         return