novelWriter 2.1.1__py3-none-any.whl → 2.2rc1__py3-none-any.whl

novelwriter/gui/doceditor.py

@@ -10,6 +10,8 @@ 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
 
 This file is a part of novelWriter
 Copyright 2018–2023, Veronica Berglyd Olsen
@@ -37,24 +39,28 @@ from time import time
 from typing import TYPE_CHECKING
 
 from PyQt5.QtCore import (
-    Qt, QSize, QTimer, pyqtSlot, pyqtSignal, QRegExp, QRegularExpression,
-    QPointF, QObject, QRunnable, QPropertyAnimation
+    pyqtSignal, pyqtSlot, QObject, QPoint, QRegExp, QRegularExpression,
+    QRunnable, QSize, Qt, QTimer
 )
 from PyQt5.QtGui import (
-    QFontMetrics, QTextCursor, QTextOption, QKeySequence, QFont, QColor,
-    QPalette, QTextDocument, QCursor, QPixmap
+    QColor, QCursor, QFont, QKeyEvent, QKeySequence, QMouseEvent, QPalette,
+    QPixmap, QResizeEvent, QTextBlock, QTextCursor, QTextDocument, QTextOption
 )
 from PyQt5.QtWidgets import (
-    QAction, qApp, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
-    QPushButton, QShortcut, QTextEdit, QToolBar, QToolButton, QWidget
+    QAction, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QMenu,
+    QPlainTextEdit, QPushButton, QShortcut, QToolBar, QToolButton, QVBoxLayout,
+    QWidget, qApp
 )
 
 from novelwriter import CONFIG, SHARED
-from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwItemClass
+from novelwriter.enum import nwDocAction, nwDocInsert, nwDocMode, nwItemClass, nwTrinary
 from novelwriter.common import minmax, transferCase
-from novelwriter.constants import nwConst, nwKeyWords, nwUnicode
+from novelwriter.constants import nwKeyWords, nwLabels, nwShortcode, nwUnicode, trConst
+from novelwriter.core.item import NWItem
 from novelwriter.core.index import countWords
+from novelwriter.core.document import NWDocument
 from novelwriter.gui.dochighlight import GuiDocHighlighter
+from novelwriter.gui.editordocument import GuiTextDocument
 from novelwriter.extensions.wheeleventfilter import WheelEventFilter
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -63,11 +69,22 @@ if TYPE_CHECKING:  # pragma: no cover
 logger = logging.getLogger(__name__)
 
 
-class GuiDocEditor(QTextEdit):
+class _SelectAction(Enum):
+
+    NO_DECISION    = 0
+    KEEP_SELECTION = 1
+    KEEP_POSITION  = 2
+    MOVE_AFTER     = 3
+
+# END Class _SelectAction
+
+
+class GuiDocEditor(QPlainTextEdit):
+    """Gui Widget: Main Document Editor"""
 
     MOVE_KEYS = (
-        Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down,
-        Qt.Key_PageUp, Qt.Key_PageDown
+        Qt.Key.Key_Left, Qt.Key.Key_Right, Qt.Key.Key_Up, Qt.Key.Key_Down,
+        Qt.Key.Key_PageUp, Qt.Key.Key_PageDown
     )
 
     # Custom Signals
@@ -77,8 +94,13 @@ class GuiDocEditor(QTextEdit):
     loadDocumentTagRequest = pyqtSignal(str, Enum)
     novelStructureChanged = pyqtSignal()
     novelItemMetaChanged = pyqtSignal(str)
+    spellCheckStateChanged = pyqtSignal(bool)
+    closeDocumentRequest = pyqtSignal()
+    toggleFocusModeRequest = pyqtSignal()
+    requestProjectItemSelected = pyqtSignal(str, bool)
+    requestProjectItemRenamed = pyqtSignal(str, str)
 
-    def __init__(self, mainGui: GuiMain):
+    def __init__(self, mainGui: GuiMain) -> None:
         super().__init__(parent=mainGui)
 
         logger.debug("Create: GuiDocEditor")
@@ -90,22 +112,14 @@ class GuiDocEditor(QTextEdit):
         self._nwItem     = None
 
         self._docChanged = False  # Flag for changed status of document
-        self._docHandle  = None   # The handle of the open file
-
-        self._spellCheck = False  # Flag for spell checking enabled
-        self._nonWord    = "\"'"  # Characters to not include in spell checking
+        self._docHandle  = None   # The handle of the open document
         self._vpMargin   = 0      # The editor viewport margin, set during init
 
         # Document Variables
-        self._charCount  = 0      # Character count
-        self._wordCount  = 0      # Word count
-        self._paraCount  = 0      # Paragraph count
-        self._lastEdit   = 0      # Time stamp of last edit
-        self._lastActive = 0.0    # Time stamp of last activity
+        self._lastEdit   = 0.0    # Timestamp of last edit
+        self._lastActive = 0.0    # Timestamp of last activity
         self._lastFind   = None   # Position of the last found search word
-        self._bigDoc     = False  # Flag for very large document size
         self._doReplace  = False  # Switch to temporarily disable auto-replace
-        self._queuePos   = None   # Used for delayed change of cursor position
 
         # Typography Cache
         self._typPadChar = " "
@@ -120,45 +134,54 @@ class GuiDocEditor(QTextEdit):
         self._typPadBefore = ""
         self._typPadAfter = ""
 
-        # Core Elements and Signals
-        qDoc = self.document()
-        qDoc.contentsChange.connect(self._docChange)
-        qDoc.documentLayout().documentSizeChanged.connect(self._docSizeChanged)
+        # Completer
+        self._completer = MetaCompleter(self)
+        self._completer.complete.connect(self._insertCompletion)
+
+        # Create Custom Document
+        self._qDocument = GuiTextDocument(self)
+        self.setDocument(self._qDocument)
+
+        # Connect Signals
+        self._qDocument.contentsChange.connect(self._docChange)
         self.selectionChanged.connect(self._updateSelectedStatus)
+        self.spellCheckStateChanged.connect(self._qDocument.setSpellCheckState)
 
         # Document Title
         self.docHeader = GuiDocEditHeader(self)
         self.docFooter = GuiDocEditFooter(self)
         self.docSearch = GuiDocEditSearch(self)
+        self.docToolBar = GuiDocToolBar(self)
 
-        # Syntax
-        self.highLight = GuiDocHighlighter(qDoc)
+        # Connect Signals
+        self.docHeader.closeDocumentRequest.connect(self._closeCurrentDocument)
+        self.docHeader.toggleToolBarRequest.connect(self._toggleToolBarVisibility)
+        self.docToolBar.requestDocAction.connect(self.docAction)
 
         # Context Menu
-        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.customContextMenuRequested.connect(self._openContextMenu)
 
         # Editor Settings
         self.setMinimumWidth(CONFIG.pxInt(300))
-        self.setAcceptRichText(False)
         self.setAutoFillBackground(True)
-        self.setFrameStyle(QFrame.NoFrame)
+        self.setFrameStyle(QFrame.Shape.NoFrame)
 
         # Custom Shortcuts
         self.keyContext = QShortcut(self)
         self.keyContext.setKey("Ctrl+.")
-        self.keyContext.setContext(Qt.WidgetShortcut)
-        self.keyContext.activated.connect(self._openSpellContext)
+        self.keyContext.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self.keyContext.activated.connect(self._openContextFromCursor)
 
         self.followTag1 = QShortcut(self)
-        self.followTag1.setKey(Qt.Key_Return | Qt.ControlModifier)
-        self.followTag1.setContext(Qt.WidgetShortcut)
-        self.followTag1.activated.connect(self._followTag)
+        self.followTag1.setKey(Qt.Key.Key_Return | Qt.KeyboardModifier.ControlModifier)
+        self.followTag1.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self.followTag1.activated.connect(self._processTag)
 
         self.followTag2 = QShortcut(self)
-        self.followTag2.setKey(Qt.Key_Enter | Qt.ControlModifier)
-        self.followTag2.setContext(Qt.WidgetShortcut)
-        self.followTag2.activated.connect(self._followTag)
+        self.followTag2.setKey(Qt.Key.Key_Enter | Qt.KeyboardModifier.ControlModifier)
+        self.followTag2.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self.followTag2.activated.connect(self._processTag)
 
         # Set Up Document Word Counter
         self.wcTimerDoc = QTimer()
@@ -213,13 +236,13 @@ class GuiDocEditor(QTextEdit):
     @property
     def isEmpty(self) -> bool:
         """Check if the current document is empty."""
-        return self.document().isEmpty()
+        return self._qDocument.isEmpty()
 
     ##
     #  Methods
     ##
 
-    def clearEditor(self):
+    def clearEditor(self) -> None:
         """Clear the current document and reset all document-related
         flags and counters.
         """
@@ -230,63 +253,51 @@ class GuiDocEditor(QTextEdit):
         self.wcTimerSel.stop()
 
         self._docHandle  = None
-        self._charCount  = 0
-        self._wordCount  = 0
-        self._paraCount  = 0
-        self._lastEdit   = 0
+        self._lastEdit   = 0.0
         self._lastActive = 0.0
         self._lastFind   = None
-        self._bigDoc     = False
         self._doReplace  = False
-        self._queuePos   = None
 
         self.setDocumentChanged(False)
         self.docHeader.setTitleFromHandle(self._docHandle)
         self.docFooter.setHandle(self._docHandle)
+        self.docToolBar.setVisible(False)
 
-        return True
+        return
 
-    def updateTheme(self):
-        """Update theme elements
-        """
+    def updateTheme(self) -> None:
+        """Update theme elements."""
         self.docSearch.updateTheme()
         self.docHeader.updateTheme()
         self.docFooter.updateTheme()
+        self.docToolBar.updateTheme()
         return
 
-    def updateSyntaxColours(self):
-        """Update the syntax highlighting theme.
-        """
+    def updateSyntaxColours(self) -> None:
+        """Update the syntax highlighting theme."""
         mainPalette = self.palette()
-        mainPalette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.Base, QColor(*SHARED.theme.colBack))
-        mainPalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        mainPalette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        mainPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
+        mainPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
         self.setPalette(mainPalette)
 
         docPalette = self.viewport().palette()
-        docPalette.setColor(QPalette.Base, QColor(*SHARED.theme.colBack))
-        docPalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        docPalette.setColor(QPalette.ColorRole.Base, QColor(*SHARED.theme.colBack))
+        docPalette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
         self.viewport().setPalette(docPalette)
 
         self.docHeader.matchColours()
         self.docFooter.matchColours()
 
-        self.highLight.initHighlighter()
+        self._qDocument.syntaxHighlighter.initHighlighter()
 
         return
 
-    def initEditor(self):
+    def initEditor(self) -> None:
         """Initialise or re-initialise the editor with the user's
         settings. This function is both called when the editor is
         created, and when the user changes the main editor preferences.
         """
-        # Some Constants
-        self._nonWord = (
-            "\"'"
-            f"{CONFIG.fmtSQuoteOpen}{CONFIG.fmtSQuoteClose}"
-            f"{CONFIG.fmtDQuoteOpen}{CONFIG.fmtDQuoteClose}"
-        )
-
         # Typography
         if CONFIG.fmtPadThin:
             self._typPadChar = nwUnicode.U_THNBSP
@@ -316,34 +327,33 @@ class GuiDocEditor(QTextEdit):
         # Set default text margins
         # Due to cursor visibility, a part of the margin must be
         # allocated to the document itself. See issue #1112.
-        cW = self.cursorWidth()
-        qDoc = self.document()
-        qDoc.setDocumentMargin(cW)
-        self._vpMargin = max(CONFIG.getTextMargin() - cW, 0)
+        self._qDocument.setDocumentMargin(4)
+        self._vpMargin = max(CONFIG.getTextMargin() - 4, 0)
         self.setViewportMargins(self._vpMargin, self._vpMargin, self._vpMargin, self._vpMargin)
 
         # Also set the document text options for the document text flow
-        theOpt = QTextOption()
+        options = QTextOption()
 
         if CONFIG.doJustify:
-            theOpt.setAlignment(Qt.AlignJustify)
+            options.setAlignment(Qt.AlignmentFlag.AlignJustify)
         if CONFIG.showTabsNSpaces:
-            theOpt.setFlags(theOpt.flags() | QTextOption.ShowTabsAndSpaces)
+            options.setFlags(options.flags() | QTextOption.Flag.ShowTabsAndSpaces)
         if CONFIG.showLineEndings:
-            theOpt.setFlags(theOpt.flags() | QTextOption.ShowLineAndParagraphSeparators)
+            options.setFlags(options.flags() | QTextOption.Flag.ShowLineAndParagraphSeparators)
 
-        qDoc.setDefaultTextOption(theOpt)
+        self._qDocument.setDefaultTextOption(options)
 
-        # Scroll bars
+        # Scrolling
+        self.setCenterOnScroll(CONFIG.scrollPastEnd)
         if CONFIG.hideVScroll:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         if CONFIG.hideHScroll:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         else:
-            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 
         # Refresh the tab stops
         self.setTabStopDistance(CONFIG.getTabWidth())
@@ -358,14 +368,12 @@ class GuiDocEditor(QTextEdit):
         if self._docHandle is None:
             self.clearEditor()
         else:
-            self.redrawText()
-            if not self._bigDoc:
-                self.highLight.rehighlight()
+            self._qDocument.syntaxHighlighter.rehighlight()
 
-        return True
+        return
 
-    def loadText(self, tHandle, tLine=None):
-        """Load text from a document into the editor. If we have an io
+    def loadText(self, tHandle: str, tLine=None) -> bool:
+        """Load text from a document into the editor. If we have an I/O
         error, we must handle this and clear the editor so that we don't
         risk overwriting the file if it exists. This can for instance
         happen of the file contains binary elements or an encoding that
@@ -376,131 +384,73 @@ class GuiDocEditor(QTextEdit):
         self._nwDocument = SHARED.project.storage.getDocument(tHandle)
         self._nwItem = self._nwDocument.nwItem
 
-        theDoc = self._nwDocument.readDocument()
-        if theDoc is None:
-            # There was an io error
+        docText = self._nwDocument.readDocument()
+        if docText is None:
+            # There was an I/O error
             self.clearEditor()
             return False
 
-        docSize = len(theDoc)
-        if docSize > nwConst.MAX_DOCSIZE:
-            SHARED.error(self.tr(
-                "The document you are trying to open is too big. "
-                "The document size is {0} MB. "
-                "The maximum size allowed is {1} MB."
-            ).format(
-                f"{docSize/1.0e6:.2f}",
-                f"{nwConst.MAX_DOCSIZE/1.0e6:.2f}"
-            ))
-            self.clearEditor()
-            return False
-
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
-        self.highLight.setHandle(tHandle)
-
-        # Check that the document is not too big for full, initial spell
-        # checking. If it is too big, we switch to only check as we type
-        self._checkDocSize(docSize)
-        spTemp = self.highLight.spellCheck
-        if self._bigDoc:
-            self.highLight.setSpellCheck(False)
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        self._docHandle = tHandle
 
-        bfTime = time()
         self._allowAutoReplace(False)
-        self.setPlainText(theDoc)
-        qApp.processEvents()
-
+        self._qDocument.setTextContent(docText, tHandle)
         self._allowAutoReplace(True)
-        afTime = time()
-        logger.debug("Document highlighted in %.3f ms", 1000*(afTime-bfTime))
+        qApp.processEvents()
 
         self._lastEdit = time()
         self._lastActive = time()
         self._runDocCounter()
         self.wcTimerDoc.start()
-        self._docHandle = tHandle
 
         self.setReadOnly(False)
         self.docHeader.setTitleFromHandle(self._docHandle)
         self.docFooter.setHandle(self._docHandle)
         self.updateDocMargins()
-        self.highLight.setSpellCheck(spTemp)
 
         if tLine is None and self._nwItem is not None:
-            # For large documents, we queue the repositioning until the
-            # document layout has grown past the point we want to move
-            # the cursor to. This makes the loading significantly
-            # faster.
-            if docSize > 50000:
-                self._queuePos = self._nwItem.cursorPos
-            else:
-                self.setCursorPosition(self._nwItem.cursorPos)
+            self.setCursorPosition(self._nwItem.cursorPos)
         elif isinstance(tLine, int):
             self.setCursorLine(tLine)
 
-        if CONFIG.scrollPastEnd > 0:
-            fSize = QFontMetrics(self.font()).lineSpacing()
-            docFrame = self.document().rootFrame().frameFormat()
-            docFrame.setBottomMargin(round(CONFIG.scrollPastEnd * fSize))
-            self.document().rootFrame().setFrameFormat(docFrame)
-
         self.docFooter.updateLineCount()
 
-        qApp.processEvents()
-        self.document().clearUndoRedoStacks()
-        self.setDocumentChanged(False)
-        qApp.restoreOverrideCursor()
-
         # This is a hack to fix invisible cursor on an empty document
-        if self.document().characterCount() <= 1:
+        if self._qDocument.characterCount() <= 1:
             self.setPlainText("\n")
             self.setPlainText("")
             self.setCursorPosition(0)
 
+        qApp.processEvents()
+        self.setDocumentChanged(False)
+        self._qDocument.clearUndoRedoStacks()
+        self.docToolBar.setVisible(CONFIG.showEditToolBar)
+
+        qApp.restoreOverrideCursor()
+
         # Update the status bar
         if self._nwItem is not None:
             self.statusMessage.emit(self.tr("Opened Document: {0}").format(self._nwItem.itemName))
 
         return True
 
-    def updateTagHighLighting(self):
-        """Rerun the syntax highlighter on all meta data lines.
-        """
-        self.highLight.rehighlightByType(GuiDocHighlighter.BLOCK_META)
+    def updateTagHighLighting(self) -> None:
+        """Rerun the syntax highlighter on all meta data lines."""
+        self._qDocument.syntaxHighlighter.rehighlightByType(GuiDocHighlighter.BLOCK_META)
         return
 
-    def redrawText(self):
-        """Redraw the text by marking the document content as "dirty".
-        """
-        self.document().markContentsDirty(0, self.document().characterCount())
-        self.updateDocMargins()
-        return
-
-    def replaceText(self, theText):
+    def replaceText(self, text: str) -> None:
         """Replace the text of the current document with the provided
         text. This also clears undo history.
         """
-        docSize = len(theText)
-        if docSize > nwConst.MAX_DOCSIZE:
-            SHARED.error(self.tr(
-                "The text you are trying to add is too big. "
-                "The text size is {0} MB. "
-                "The maximum size allowed is {1} MB."
-            ).format(
-                f"{docSize/1.0e6:.2f}",
-                f"{nwConst.MAX_DOCSIZE/1.0e6:.2f}"
-            ))
-            return False
-
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
-        self.setPlainText(theText)
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        self.setPlainText(text)
         self.updateDocMargins()
         self.setDocumentChanged(True)
         qApp.restoreOverrideCursor()
+        return
 
-        return True
-
-    def saveText(self):
+    def saveText(self) -> bool:
         """Save the text currently in the editor to the NWDocument
         object, and update the NWItem meta data.
         """
@@ -516,14 +466,9 @@ class GuiDocEditor(QTextEdit):
             return False
 
         docText = self.getText()
-
         cC, wC, pC = countWords(docText)
         self._updateDocCounts(cC, wC, pC)
 
-        self._nwItem.setCharCount(self._charCount)
-        self._nwItem.setWordCount(self._wordCount)
-        self._nwItem.setParaCount(self._paraCount)
-
         self.saveCursorPosition()
         if not self._nwDocument.writeDocument(docText):
             saveOk = False
@@ -557,10 +502,7 @@ class GuiDocEditor(QTextEdit):
             else:
                 self.novelStructureChanged.emit()
 
-        # ToDo: This should be a signal
         if oldHeader != newHeader:
-            self.mainGui.projView.setTreeItemValues(tHandle)
-            self.mainGui.itemDetails.updateViewBox(tHandle)
             self.docFooter.updateInfo()
 
         # Update the status bar
@@ -568,7 +510,34 @@ class GuiDocEditor(QTextEdit):
 
         return True
 
-    def updateDocMargins(self):
+    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()
+        )
+
+    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
+        qApp.processEvents()
+        return
+
+    def updateDocMargins(self) -> None:
         """Automatically adjust the margins so the text is centred if
         we have a text width set or we're in Focus Mode. Otherwise, just
         ensure the margins are set correctly.
@@ -594,6 +563,7 @@ class GuiDocEditor(QTextEdit):
         fY = wH - fH - tB - sH
         self.docHeader.setGeometry(tB, tB, tW, tH)
         self.docFooter.setGeometry(tB, fY, tW, fH)
+        self.docToolBar.move(0, tH)
 
         rH = 0
         if self.docSearch.isVisible():
@@ -612,19 +582,19 @@ class GuiDocEditor(QTextEdit):
     #  Getters
     ##
 
-    def getText(self):
+    def getText(self) -> str:
         """Get the text content of the current document. This method uses
         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
         """
-        theText = self.document().toRawText()
-        theText = theText.replace(nwUnicode.U_LSEP, "\n")  # Line separators
-        theText = theText.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
-        return theText
+        text = self._qDocument.toRawText()
+        text = text.replace(nwUnicode.U_LSEP, "\n")  # Line separators
+        text = text.replace(nwUnicode.U_PSEP, "\n")  # Paragraph separators
+        return text
 
-    def getCursorPosition(self):
+    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.
         """
@@ -634,64 +604,40 @@ class GuiDocEditor(QTextEdit):
     #  Setters
     ##
 
-    def setDocumentChanged(self, bValue):
+    def setDocumentChanged(self, state: bool) -> bool:
         """Keep track of the document changed variable, and emit the
         document change signal.
         """
-        self._docChanged = bValue
+        self._docChanged = state
         self.editedStatusChanged.emit(self._docChanged)
         return self._docChanged
 
-    def setCursorPosition(self, position):
-        """Move the cursor to a given position in the document.
-        """
-        if not isinstance(position, int):
-            return False
-
-        nChars = self.document().characterCount()
-        if nChars > 1:
-            theCursor = self.textCursor()
-            theCursor.setPosition(minmax(position, 0, nChars-1))
-            self.setTextCursor(theCursor)
-
-            # By default, the editor scrolls so the cursor is on the
-            # last line, so we must correct it. The user setting for
-            # auto-scroll is used to determine the scroll distance. This
-            # makes it compatible with the typewriter scrolling feature
-            # when it is enabled. By default, it's 30% of viewport.
-            vPos = self.verticalScrollBar().value()
-            cPos = self.cursorRect().topLeft().y()
-            mPos = int(CONFIG.autoScrollPos*0.01 * self.viewport().height())
-            if cPos > mPos:
-                # Only scroll if the cursor is past the auto-scroll limit
-                self.verticalScrollBar().setValue(max(0, vPos + cPos - mPos))
-
+    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):
+            cursor = self.textCursor()
+            cursor.setPosition(minmax(position, 0, nChars-1))
+            self.setTextCursor(cursor)
+            self.centerCursor()
             self.docFooter.updateLineCount()
+        return
 
-        return True
-
-    def saveCursorPosition(self):
-        """Save the cursor position to the current project item object.
-        """
+    def saveCursorPosition(self) -> None:
+        """Save the cursor position to the current project item."""
         if self._nwItem is not None:
             cursPos = self.getCursorPosition()
             self._nwItem.setCursorPos(cursPos)
         return
 
-    def setCursorLine(self, lineNo):
-        """Move the cursor to a given line in the document.
-        """
-        if not isinstance(lineNo, int):
-            return False
-
-        lineIdx = lineNo - 1  # Block index is 0 offset, lineNo is 1 offset
-        if lineIdx >= 0:
-            theBlock = self.document().findBlockByLineNumber(lineIdx)
-            if theBlock:
-                self.setCursorPosition(theBlock.position())
-                logger.debug("Cursor moved to line %d", lineNo)
-
-        return True
+    def setCursorLine(self, line: int | None) -> None:
+        """Move the cursor to a given line in the document."""
+        if isinstance(line, int) and line > 0:
+            block = self._qDocument.findBlockByNumber(line - 1)
+            if block:
+                self.setCursorPosition(block.position())
+                logger.debug("Cursor moved to line %d", line)
+        return
 
     ##
     #  Spell Checking
@@ -700,30 +646,25 @@ class GuiDocEditor(QTextEdit):
     def toggleSpellCheck(self, state: bool | None) -> None:
         """This is the main spell check setting function, and this one
         should call all other setSpellCheck functions in other classes.
-        If the spell check mode (theMode) is not defined (None), then
-        toggle the current status saved in this class.
+        If the spell check state is not defined (None), then toggle the
+        current status saved in this class.
         """
         if state is None:
-            state = not self._spellCheck
+            state = not SHARED.project.data.spellCheck
 
-        if not CONFIG.hasEnchant:
-            if state:
-                SHARED.info(self.tr(
-                    "Spell checking requires the package PyEnchant. "
-                    "It does not appear to be installed."
-                ))
+        if SHARED.spelling.spellLanguage is None:
             state = False
 
-        if SHARED.spelling.spellLanguage is None:
+        if state and not CONFIG.hasEnchant:
+            SHARED.info(self.tr(
+                "Spell checking requires the package PyEnchant. "
+                "It does not appear to be installed."
+            ))
             state = False
 
-        self._spellCheck = state
-        self.mainGui.mainMenu.setSpellCheck(state)
         SHARED.project.data.setSpellCheck(state)
-        self.highLight.setSpellCheck(state)
-        if not self._bigDoc or state is False:
-            # We don't run the spell checker automatically on big docs
-            self.spellCheckDocument()
+        self.spellCheckStateChanged.emit(state)
+        self.spellCheckDocument()
 
         logger.debug("Spell check is set to '%s'", str(state))
 
@@ -737,12 +678,8 @@ class GuiDocEditor(QTextEdit):
         """
         logger.debug("Running spell checker")
         start = time()
-        qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
-        if self._bigDoc:
-            # This is much faster for large documents
-            self.setPlainText(self.getText())
-        else:
-            self.highLight.rehighlight()
+        qApp.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
+        self._qDocument.syntaxHighlighter.rehighlight()
         qApp.restoreOverrideCursor()
         logger.debug("Document highlighted in %.3f ms", 1000*(time() - start))
         self.statusMessage.emit(self.tr("Spell check complete"))
@@ -752,7 +689,7 @@ class GuiDocEditor(QTextEdit):
     #  General Class Methods
     ##
 
-    def docAction(self, theAction):
+    def docAction(self, action: nwDocAction) -> bool:
         """Perform an action on the current document based on an action
         flag. This is just a single entry point wrapper function to
         ensure all the feature functions get the correct information
@@ -763,71 +700,83 @@ class GuiDocEditor(QTextEdit):
             logger.error("No document open")
             return False
 
-        if not isinstance(theAction, nwDocAction):
+        if not isinstance(action, nwDocAction):
             logger.error("Not a document action")
             return False
 
-        logger.debug("Requesting action: %s", theAction.name)
+        logger.debug("Requesting action: %s", action.name)
 
         self._allowAutoReplace(False)
-        if theAction == nwDocAction.UNDO:
+        if action == nwDocAction.UNDO:
             self.undo()
-        elif theAction == nwDocAction.REDO:
+        elif action == nwDocAction.REDO:
             self.redo()
-        elif theAction == nwDocAction.CUT:
+        elif action == nwDocAction.CUT:
             self.cut()
-        elif theAction == nwDocAction.COPY:
+        elif action == nwDocAction.COPY:
             self.copy()
-        elif theAction == nwDocAction.PASTE:
+        elif action == nwDocAction.PASTE:
             self.paste()
-        elif theAction == nwDocAction.EMPH:
+        elif action == nwDocAction.EMPH:
             self._toggleFormat(1, "_")
-        elif theAction == nwDocAction.STRONG:
+        elif action == nwDocAction.STRONG:
             self._toggleFormat(2, "*")
-        elif theAction == nwDocAction.STRIKE:
+        elif action == nwDocAction.STRIKE:
             self._toggleFormat(2, "~")
-        elif theAction == nwDocAction.S_QUOTE:
+        elif action == nwDocAction.S_QUOTE:
             self._wrapSelection(self._typSQuoteO, self._typSQuoteC)
-        elif theAction == nwDocAction.D_QUOTE:
+        elif action == nwDocAction.D_QUOTE:
             self._wrapSelection(self._typDQuoteO, self._typDQuoteC)
-        elif theAction == nwDocAction.SEL_ALL:
-            self._makeSelection(QTextCursor.Document)
-        elif theAction == nwDocAction.SEL_PARA:
-            self._makeSelection(QTextCursor.BlockUnderCursor)
-        elif theAction == nwDocAction.BLOCK_H1:
+        elif action == nwDocAction.SEL_ALL:
+            self._makeSelection(QTextCursor.SelectionType.Document)
+        elif action == nwDocAction.SEL_PARA:
+            self._makeSelection(QTextCursor.SelectionType.BlockUnderCursor)
+        elif action == nwDocAction.BLOCK_H1:
             self._formatBlock(nwDocAction.BLOCK_H1)
-        elif theAction == nwDocAction.BLOCK_H2:
+        elif action == nwDocAction.BLOCK_H2:
             self._formatBlock(nwDocAction.BLOCK_H2)
-        elif theAction == nwDocAction.BLOCK_H3:
+        elif action == nwDocAction.BLOCK_H3:
             self._formatBlock(nwDocAction.BLOCK_H3)
-        elif theAction == nwDocAction.BLOCK_H4:
+        elif action == nwDocAction.BLOCK_H4:
             self._formatBlock(nwDocAction.BLOCK_H4)
-        elif theAction == nwDocAction.BLOCK_COM:
+        elif action == nwDocAction.BLOCK_COM:
             self._formatBlock(nwDocAction.BLOCK_COM)
-        elif theAction == nwDocAction.BLOCK_TXT:
+        elif action == nwDocAction.BLOCK_TXT:
             self._formatBlock(nwDocAction.BLOCK_TXT)
-        elif theAction == nwDocAction.BLOCK_TTL:
+        elif action == nwDocAction.BLOCK_TTL:
             self._formatBlock(nwDocAction.BLOCK_TTL)
-        elif theAction == nwDocAction.BLOCK_UNN:
+        elif action == nwDocAction.BLOCK_UNN:
             self._formatBlock(nwDocAction.BLOCK_UNN)
-        elif theAction == nwDocAction.REPL_SNG:
+        elif action == nwDocAction.REPL_SNG:
             self._replaceQuotes("'", self._typSQuoteO, self._typSQuoteC)
-        elif theAction == nwDocAction.REPL_DBL:
+        elif action == nwDocAction.REPL_DBL:
             self._replaceQuotes("\"", self._typDQuoteO, self._typDQuoteC)
-        elif theAction == nwDocAction.RM_BREAKS:
+        elif action == nwDocAction.RM_BREAKS:
             self._removeInParLineBreaks()
-        elif theAction == nwDocAction.ALIGN_L:
+        elif action == nwDocAction.ALIGN_L:
             self._formatBlock(nwDocAction.ALIGN_L)
-        elif theAction == nwDocAction.ALIGN_C:
+        elif action == nwDocAction.ALIGN_C:
             self._formatBlock(nwDocAction.ALIGN_C)
-        elif theAction == nwDocAction.ALIGN_R:
+        elif action == nwDocAction.ALIGN_R:
             self._formatBlock(nwDocAction.ALIGN_R)
-        elif theAction == nwDocAction.INDENT_L:
+        elif action == nwDocAction.INDENT_L:
             self._formatBlock(nwDocAction.INDENT_L)
-        elif theAction == nwDocAction.INDENT_R:
+        elif action == nwDocAction.INDENT_R:
             self._formatBlock(nwDocAction.INDENT_R)
+        elif action == nwDocAction.SC_ITALIC:
+            self._wrapSelection(nwShortcode.ITALIC_O, nwShortcode.ITALIC_C)
+        elif action == nwDocAction.SC_BOLD:
+            self._wrapSelection(nwShortcode.BOLD_O, nwShortcode.BOLD_C)
+        elif action == nwDocAction.SC_STRIKE:
+            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_SUP:
+            self._wrapSelection(nwShortcode.SUP_O, nwShortcode.SUP_C)
+        elif action == nwDocAction.SC_SUB:
+            self._wrapSelection(nwShortcode.SUB_O, nwShortcode.SUB_C)
         else:
-            logger.debug("Unknown or unsupported document action '%s'", str(theAction))
+            logger.debug("Unknown or unsupported document action '%s'", str(action))
             self._allowAutoReplace(True)
             return False
 
@@ -836,37 +785,33 @@ class GuiDocEditor(QTextEdit):
 
         return True
 
-    def anyFocus(self):
-        """Check if any widget or child widget has focus.
-        """
+    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
 
-    def revealLocation(self):
+    def revealLocation(self) -> None:
         """Tell the user where on the file system the file in the editor
         is saved.
         """
-        if self._nwDocument is None:
-            logger.error("No document open")
-            return False
-        SHARED.info(
-            "<br>".join([
-                self.tr("Document Details"),
-                "–"*40,
-                self.tr("Created: {0}").format(self._nwDocument.createdDate),
-                self.tr("Updated: {0}").format(self._nwDocument.updatedDate),
-            ]),
-            details=self.tr("File Location: {0}").format(self._nwDocument.fileLocation),
-            log=False
-        )
+        if isinstance(self._nwDocument, NWDocument):
+            SHARED.info(
+                "<br>".join([
+                    self.tr("Document Details"),
+                    "–"*40,
+                    self.tr("Created: {0}").format(self._nwDocument.createdDate),
+                    self.tr("Updated: {0}").format(self._nwDocument.updatedDate),
+                ]),
+                details=self.tr("File Location: {0}").format(self._nwDocument.fileLocation),
+                log=False
+            )
         return
 
-    def insertText(self, theInsert):
-        """Insert a specific type of text at the cursor position.
-        """
+    def insertText(self, insert: str | nwDocInsert) -> bool:
+        """Insert a specific type of text at the cursor position."""
         if self._docHandle is None:
             logger.error("No document open")
             return False
@@ -874,31 +819,35 @@ class GuiDocEditor(QTextEdit):
         newBlock = False
         goAfter = False
 
-        if isinstance(theInsert, str):
-            theText = theInsert
-        elif isinstance(theInsert, nwDocInsert):
-            if theInsert == nwDocInsert.QUOTE_LS:
-                theText = self._typSQuoteO
-            elif theInsert == nwDocInsert.QUOTE_RS:
-                theText = self._typSQuoteC
-            elif theInsert == nwDocInsert.QUOTE_LD:
-                theText = self._typDQuoteO
-            elif theInsert == nwDocInsert.QUOTE_RD:
-                theText = self._typDQuoteC
-            elif theInsert == nwDocInsert.SYNOPSIS:
-                theText = "% Synopsis: "
+        if isinstance(insert, str):
+            text = insert
+        elif isinstance(insert, nwDocInsert):
+            if insert == nwDocInsert.QUOTE_LS:
+                text = self._typSQuoteO
+            elif insert == nwDocInsert.QUOTE_RS:
+                text = self._typSQuoteC
+            elif insert == nwDocInsert.QUOTE_LD:
+                text = self._typDQuoteO
+            elif insert == nwDocInsert.QUOTE_RD:
+                text = self._typDQuoteC
+            elif insert == nwDocInsert.SYNOPSIS:
+                text = "% Synopsis: "
+                newBlock = True
+                goAfter = True
+            elif insert == nwDocInsert.SHORT:
+                text = "% Short: "
                 newBlock = True
                 goAfter = True
-            elif theInsert == nwDocInsert.NEW_PAGE:
-                theText = "[NEW PAGE]"
+            elif insert == nwDocInsert.NEW_PAGE:
+                text = "[newpage]"
                 newBlock = True
                 goAfter = False
-            elif theInsert == nwDocInsert.VSPACE_S:
-                theText = "[VSPACE]"
+            elif insert == nwDocInsert.VSPACE_S:
+                text = "[vspace]"
                 newBlock = True
                 goAfter = False
-            elif theInsert == nwDocInsert.VSPACE_M:
-                theText = "[VSPACE:2]"
+            elif insert == nwDocInsert.VSPACE_M:
+                text = "[vspace:2]"
                 newBlock = True
                 goAfter = False
             else:
@@ -907,79 +856,55 @@ class GuiDocEditor(QTextEdit):
             return False
 
         if newBlock:
-            self.insertNewBlock(theText, defaultAfter=goAfter)
+            self.insertNewBlock(text, defaultAfter=goAfter)
         else:
-            theCursor = self.textCursor()
-            theCursor.beginEditBlock()
-            theCursor.insertText(theText)
-            theCursor.endEditBlock()
+            cursor = self.textCursor()
+            cursor.beginEditBlock()
+            cursor.insertText(text)
+            cursor.endEditBlock()
 
         return True
 
-    def insertNewBlock(self, theText, defaultAfter=True):
-        """Insert a piece of text on a blank line.
-        """
-        theCursor = self.textCursor()
-        theBlock = theCursor.block()
-        if not theBlock.isValid():
+    def insertNewBlock(self, text: str, defaultAfter: bool = True) -> bool:
+        """Insert a piece of text on a blank line."""
+        cursor = self.textCursor()
+        block = cursor.block()
+        if not block.isValid():
             logger.error("Not a valid text block")
             return False
 
-        sPos = theBlock.position()
-        sLen = theBlock.length()
+        sPos = block.position()
+        sLen = block.length()
 
-        theCursor.beginEditBlock()
+        cursor.beginEditBlock()
 
         if sLen > 1 and defaultAfter:
-            theCursor.setPosition(sPos + sLen - 1)
-            theCursor.insertText("\n")
+            cursor.setPosition(sPos + sLen - 1)
+            cursor.insertText("\n")
         else:
-            theCursor.setPosition(sPos)
+            cursor.setPosition(sPos)
 
-        theCursor.insertText(theText)
+        cursor.insertText(text)
 
         if sLen > 1 and not defaultAfter:
-            theCursor.insertText("\n")
+            cursor.insertText("\n")
 
-        theCursor.endEditBlock()
+        cursor.endEditBlock()
 
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return True
 
-    def insertKeyWord(self, keyWord):
-        """Insert a keyword in the text editor, at the cursor position.
-        If the insert line is not blank, a new line is started.
-        """
-        if keyWord not in nwKeyWords.VALID_KEYS:
-            logger.error("Invalid keyword '%s'", keyWord)
-            return False
-
-        logger.debug("Inserting keyword '%s'", keyWord)
-        theState = self.insertNewBlock("%s: " % keyWord)
-
-        return theState
-
-    def closeSearch(self):
-        """Close the search box.
-        """
+    def closeSearch(self) -> bool:
+        """Close the search box."""
         self.docSearch.closeSearch()
         return self.docSearch.isVisible()
 
-    def toggleSearch(self):
-        """Toggle the visibility of the search box.
-        """
-        if self.docSearch.isVisible():
-            self.docSearch.closeSearch()
-        else:
-            self.beginSearch()
-        return
-
     ##
     #  Document Events and Maintenance
     ##
 
-    def keyPressEvent(self, keyEvent):
+    def keyPressEvent(self, event: QKeyEvent) -> None:
         """Intercept key press events.
         We need to intercept a few key sequences:
           * The return and enter keys redirect here even if the search
@@ -990,49 +915,40 @@ class GuiDocEditor(QTextEdit):
           * We also handle automatic scrolling here.
         """
         self._lastActive = time()
-        isReturn  = keyEvent.key() == Qt.Key_Return
-        isReturn |= keyEvent.key() == Qt.Key_Enter
+        isReturn  = event.key() == Qt.Key.Key_Return
+        isReturn |= event.key() == Qt.Key.Key_Enter
         if isReturn and self.docSearch.anyFocus():
             return
-        elif keyEvent == QKeySequence.Redo:
+        elif event == QKeySequence.StandardKey.Redo:
             self.docAction(nwDocAction.REDO)
             return
-        elif keyEvent == QKeySequence.Undo:
+        elif event == QKeySequence.StandardKey.Undo:
             self.docAction(nwDocAction.UNDO)
             return
-        elif keyEvent == QKeySequence.SelectAll:
+        elif event == QKeySequence.StandardKey.SelectAll:
             self.docAction(nwDocAction.SEL_ALL)
             return
 
         if CONFIG.autoScroll:
-
-            cOld = self.cursorRect().center().y()
-            super().keyPressEvent(keyEvent)
-
-            kMod = keyEvent.modifiers()
-            okMod = kMod == Qt.NoModifier or kMod == Qt.ShiftModifier
-            okKey = keyEvent.key() not in self.MOVE_KEYS
-            if okMod and okKey:
-                cNew = self.cursorRect().center().y()
-                cMov = cNew - cOld
+            cPos = self.cursorRect().topLeft().y()
+            super().keyPressEvent(event)
+            nPos = self.cursorRect().topLeft().y()
+            kMod = event.modifiers()
+            okMod = kMod in (Qt.KeyboardModifier.NoModifier, Qt.KeyboardModifier.ShiftModifier)
+            okKey = event.key() not in self.MOVE_KEYS
+            if nPos != cPos and okMod and okKey:
                 mPos = CONFIG.autoScrollPos*0.01 * self.viewport().height()
-                if abs(cMov) > 0 and cOld > mPos:
-                    # Move the scroll bar
+                if cPos > mPos:
                     vBar = self.verticalScrollBar()
-                    doAnim = QPropertyAnimation(vBar, b"value", self)
-                    doAnim.setDuration(120)
-                    doAnim.setStartValue(vBar.value())
-                    doAnim.setEndValue(vBar.value() + cMov)
-                    doAnim.start()
-
+                    vBar.setValue(vBar.value() + (1 if nPos > cPos else -1))
         else:
-            super().keyPressEvent(keyEvent)
+            super().keyPressEvent(event)
 
         self.docFooter.updateLineCount()
 
         return
 
-    def focusNextPrevChild(self, toNext):
+    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,
@@ -1041,29 +957,26 @@ class GuiDocEditor(QTextEdit):
         if self.hasFocus():
             return False
         elif self.docSearch.isVisible():
-            return self.docSearch.cycleFocus(toNext)
+            return self.docSearch.cycleFocus(next)
         return True
 
-    def mouseReleaseEvent(self, theEvent):
+    def mouseReleaseEvent(self, event: QMouseEvent) -> None:
         """If the mouse button is released and the control key is
         pressed, check if we're clicking on a tag, and trigger the
         follow tag function.
         """
-        if qApp.keyboardModifiers() == Qt.ControlModifier:
-            theCursor = self.cursorForPosition(theEvent.pos())
-            self._followTag(theCursor)
-
-        super().mouseReleaseEvent(theEvent)
+        if qApp.keyboardModifiers() == Qt.KeyboardModifier.ControlModifier:
+            self._processTag(self.cursorForPosition(event.pos()))
+        super().mouseReleaseEvent(event)
         self.docFooter.updateLineCount()
-
         return
 
-    def resizeEvent(self, theEvent):
+    def resizeEvent(self, event: QResizeEvent) -> None:
         """If the text editor is resized, we must make sure the document
         has its margins adjusted according to user preferences.
         """
         self.updateDocMargins()
-        super().resizeEvent(theEvent)
+        super().resizeEvent(event)
         return
 
     ##
@@ -1071,7 +984,7 @@ class GuiDocEditor(QTextEdit):
     ##
 
     @pyqtSlot(str)
-    def updateDocInfo(self, tHandle):
+    def updateDocInfo(self, tHandle: str) -> None:
         """Called when an item label is changed to check if the document
         title bar needs updating,
         """
@@ -1081,168 +994,185 @@ class GuiDocEditor(QTextEdit):
             self.updateDocMargins()
         return
 
+    @pyqtSlot(str)
+    def insertKeyWord(self, keyword: str) -> bool:
+        """Insert a keyword in the text editor, at the cursor position.
+        If the insert line is not blank, a new line is started.
+        """
+        if keyword not in nwKeyWords.VALID_KEYS:
+            logger.error("Invalid keyword '%s'", keyword)
+            return False
+        logger.debug("Inserting keyword '%s'", keyword)
+        state = self.insertNewBlock("%s: " % keyword)
+        return state
+
+    @pyqtSlot()
+    def toggleSearch(self) -> None:
+        """Toggle the visibility of the search box."""
+        if self.docSearch.isVisible():
+            self.docSearch.closeSearch()
+        else:
+            self.beginSearch()
+        return
+
     ##
     #  Private Slots
     ##
 
     @pyqtSlot(int, int, int)
-    def _docChange(self, thePos, chrRem, chrAdd):
+    def _docChange(self, pos: int, removed: int, added: int) -> None:
         """Triggered by QTextDocument->contentsChanged. This also
         triggers the syntax highlighter.
         """
         self._lastEdit = time()
         self._lastFind = None
 
-        if self.document().characterCount() > nwConst.MAX_DOCSIZE:
-            SHARED.error(self.tr(
-                "The document has grown too big and you cannot add more text to it. "
-                "The maximum size of a single novelWriter document is {0} MB."
-            ).format(
-                f"{nwConst.MAX_DOCSIZE/1.0e6:.2f}"
-            ))
-            self.undo()
-            return
-
         if not self._docChanged:
-            self.setDocumentChanged(chrRem != 0 or chrAdd != 0)
+            self.setDocumentChanged(removed != 0 or added != 0)
 
         if not self.wcTimerDoc.isActive():
             self.wcTimerDoc.start()
 
-        if self._doReplace and chrAdd == 1:
-            self._docAutoReplace(self.document().findBlock(thePos))
-
-        return
-
-    @pyqtSlot("QPoint")
-    def _openContextMenu(self, thePos):
-        """Triggered by right click to open the context menu. Also
-        triggered by the Ctrl+. shortcut.
-        """
-        userCursor = self.textCursor()
-        userSelection = userCursor.hasSelection()
-        posCursor = self.cursorForPosition(thePos)
-
-        mnuContext = QMenu(self)
-
-        # Follow, Cut, Copy and Paste
-        # ===========================
+        block = self._qDocument.findBlock(pos)
+        if not block.isValid():
+            return
 
-        if self._followTag(theCursor=posCursor, loadTag=False):
-            mnuTag = QAction(self.tr("Follow Tag"), mnuContext)
-            mnuTag.triggered.connect(lambda: self._followTag(theCursor=posCursor))
-            mnuContext.addAction(mnuTag)
-            mnuContext.addSeparator()
+        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 userSelection:
-            mnuCut = QAction(self.tr("Cut"), mnuContext)
-            mnuCut.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
-            mnuContext.addAction(mnuCut)
+        if self._doReplace and added == 1:
+            self._docAutoReplace(text)
 
-            mnuCopy = QAction(self.tr("Copy"), mnuContext)
-            mnuCopy.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
-            mnuContext.addAction(mnuCopy)
+        return
 
-        mnuPaste = QAction(self.tr("Paste"), mnuContext)
-        mnuPaste.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
-        mnuContext.addAction(mnuPaste)
+    @pyqtSlot(int, int, str)
+    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, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(pos + length, QTextCursor.MoveMode.KeepAnchor)
+            cursor.insertText(text)
+            self._completer.hide()
+        return
 
-        mnuContext.addSeparator()
+    @pyqtSlot("QPoint")
+    def _openContextMenu(self, pos: QPoint) -> None:
+        """Open the editor context menu at a given coordinate."""
+        uCursor = self.textCursor()
+        pCursor = self.cursorForPosition(pos)
+        pBlock = pCursor.block()
+
+        ctxMenu = QMenu(self)
+        ctxMenu.setObjectName("ContextMenu")
+        if pBlock.userState() == GuiDocHighlighter.BLOCK_TITLE:
+            action = ctxMenu.addAction(self.tr("Set as Document Name"))
+            action.triggered.connect(lambda: self._emitRenameItem(pBlock))
+
+        # Follow
+        status = self._processTag(cursor=pCursor, follow=False)
+        if status == nwTrinary.POSITIVE:
+            action = ctxMenu.addAction(self.tr("Follow Tag"))
+            action.triggered.connect(lambda: self._processTag(cursor=pCursor, follow=True))
+            ctxMenu.addSeparator()
+        elif status == nwTrinary.NEGATIVE:
+            action = ctxMenu.addAction(self.tr("Create Note for Tag"))
+            action.triggered.connect(lambda: self._processTag(cursor=pCursor, create=True))
+            ctxMenu.addSeparator()
+
+        # Cut, Copy and Paste
+        if uCursor.hasSelection():
+            action = ctxMenu.addAction(self.tr("Cut"))
+            action.triggered.connect(lambda: self.docAction(nwDocAction.CUT))
+            action = ctxMenu.addAction(self.tr("Copy"))
+            action.triggered.connect(lambda: self.docAction(nwDocAction.COPY))
+
+        action = ctxMenu.addAction(self.tr("Paste"))
+        action.triggered.connect(lambda: self.docAction(nwDocAction.PASTE))
+        ctxMenu.addSeparator()
 
         # Selections
-        # ==========
-
-        mnuSelAll = QAction(self.tr("Select All"), mnuContext)
-        mnuSelAll.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
-        mnuContext.addAction(mnuSelAll)
-
-        mnuSelWord = QAction(self.tr("Select Word"), mnuContext)
-        mnuSelWord.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.WordUnderCursor, thePos)
+        action = ctxMenu.addAction(self.tr("Select All"))
+        action.triggered.connect(lambda: self.docAction(nwDocAction.SEL_ALL))
+        action = ctxMenu.addAction(self.tr("Select Word"))
+        action.triggered.connect(
+            lambda: self._makePosSelection(QTextCursor.SelectionType.WordUnderCursor, pos)
         )
-        mnuContext.addAction(mnuSelWord)
-
-        mnuSelPara = QAction(self.tr("Select Paragraph"), mnuContext)
-        mnuSelPara.triggered.connect(
-            lambda: self._makePosSelection(QTextCursor.BlockUnderCursor, thePos)
+        action = ctxMenu.addAction(self.tr("Select Paragraph"))
+        action.triggered.connect(lambda: self._makePosSelection(
+            QTextCursor.SelectionType.BlockUnderCursor, pos)
         )
-        mnuContext.addAction(mnuSelPara)
 
         # Spell Checking
-        # ==============
-
-        posCursor = self.cursorForPosition(thePos)
-        spellCheck = self._spellCheck
-        theWord = ""
-
-        if posCursor.block().text().startswith("@"):
-            spellCheck = False
-
-        if spellCheck:
-            posCursor.select(QTextCursor.WordUnderCursor)
-            theWord = posCursor.selectedText().strip().strip(self._nonWord)
-            spellCheck &= theWord != ""
-
-        if spellCheck:
-            logger.debug("Looking up '%s' in the dictionary", theWord)
-            spellCheck &= not SHARED.spelling.checkWord(theWord)
-
-        if spellCheck:
-            mnuContext.addSeparator()
-            mnuHead = QAction(self.tr("Spelling Suggestion(s)"), mnuContext)
-            mnuContext.addAction(mnuHead)
-
-            theSuggest = SHARED.spelling.suggestWords(theWord)[:15]
-            if len(theSuggest) > 0:
-                for aWord in theSuggest:
-                    mnuWord = QAction("%s %s" % (nwUnicode.U_ENDASH, aWord), mnuContext)
-                    mnuWord.triggered.connect(
-                        lambda thePos, aWord=aWord: self._correctWord(posCursor, aWord)
-                    )
-                    mnuContext.addAction(mnuWord)
-            else:
-                mnuHead = QAction(
-                    "%s %s" % (nwUnicode.U_ENDASH, self.tr("No Suggestions")), mnuContext
+        if SHARED.project.data.spellCheck:
+            word, cPos, cLen, suggest = self._qDocument.spellErrorAtPos(pCursor.position())
+            if word and cPos >= 0 and cLen > 0:
+                logger.debug("Word '%s' is misspelled", word)
+                block = pCursor.block()
+                sCursor = self.textCursor()
+                sCursor.setPosition(block.position() + cPos)
+                sCursor.movePosition(
+                    QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, cLen
                 )
-                mnuContext.addAction(mnuHead)
+                if suggest:
+                    ctxMenu.addSeparator()
+                    ctxMenu.addAction(self.tr("Spelling Suggestion(s)"))
+                    for option in suggest[:15]:
+                        action = ctxMenu.addAction(f"{nwUnicode.U_ENDASH} {option}")
+                        action.triggered.connect(
+                            lambda _, option=option: self._correctWord(sCursor, option)
+                        )
+                else:
+                    ctxMenu.addAction("%s %s" % (nwUnicode.U_ENDASH, self.tr("No Suggestions")))
 
-            mnuContext.addSeparator()
-            mnuAdd = QAction(self.tr("Add Word to Dictionary"), mnuContext)
-            mnuAdd.triggered.connect(lambda thePos: self._addWord(posCursor))
-            mnuContext.addAction(mnuAdd)
+                ctxMenu.addSeparator()
+                action = ctxMenu.addAction(self.tr("Add Word to Dictionary"))
+                action.triggered.connect(lambda: self._addWord(word, block))
 
-        # Open the context menu
-        mnuContext.exec_(self.viewport().mapToGlobal(thePos))
+        # Execute the context menu
+        ctxMenu.exec_(self.viewport().mapToGlobal(pos))
 
         return
 
     @pyqtSlot("QTextCursor", str)
-    def _correctWord(self, theCursor, theWord):
+    def _correctWord(self, cursor: QTextCursor, word: str) -> None:
         """Slot for the spell check context menu triggering the
         replacement of a word with the word from the dictionary.
         """
-        xPos = theCursor.selectionStart()
-        theCursor.beginEditBlock()
-        theCursor.removeSelectedText()
-        theCursor.insertText(theWord)
-        theCursor.endEditBlock()
-        theCursor.setPosition(xPos)
-        self.setTextCursor(theCursor)
+        pos = cursor.selectionStart()
+        cursor.beginEditBlock()
+        cursor.removeSelectedText()
+        cursor.insertText(word)
+        cursor.endEditBlock()
+        cursor.setPosition(pos)
+        self.setTextCursor(cursor)
         return
 
-    @pyqtSlot("QTextCursor")
-    def _addWord(self, theCursor):
+    @pyqtSlot(str, "QTextBlock")
+    def _addWord(self, word: str, block: QTextBlock) -> None:
         """Slot for the spell check context menu triggered when the user
         wants to add a word to the project dictionary.
         """
-        theWord = theCursor.selectedText().strip().strip(self._nonWord)
-        logger.debug("Added '%s' to project dictionary", theWord)
-        SHARED.spelling.addWord(theWord)
-        self.highLight.rehighlightBlock(theCursor.block())
+        logger.debug("Added '%s' to project dictionary", word)
+        SHARED.spelling.addWord(word)
+        self._qDocument.syntaxHighlighter.rehighlightBlock(block)
         return
 
     @pyqtSlot()
-    def _runDocCounter(self):
+    def _runDocCounter(self) -> None:
         """Decide whether to run the word counter, or not due to
         inactivity.
         """
@@ -1253,39 +1183,32 @@ class GuiDocEditor(QTextEdit):
             logger.debug("Word counter is busy")
             return
 
-        if time() - self._lastEdit < 5 * self.wcInterval:
+        if time() - self._lastEdit < 5.0 * self.wcInterval:
             logger.debug("Running word counter")
-            self.mainGui.threadPool.start(self.wCounterDoc)
+            SHARED.runInThreadPool(self.wCounterDoc)
 
         return
 
     @pyqtSlot(int, int, int)
-    def _updateDocCounts(self, cCount, wCount, pCount):
-        """Slot for the word counter's finished signal
-        """
+    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._charCount = cCount
-        self._wordCount = wCount
-        self._paraCount = pCount
-
         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._checkDocSize(self.document().characterCount())
         self.docFooter.updateCounts()
 
         return
 
     @pyqtSlot()
-    def _updateSelectedStatus(self):
+    def _updateSelectedStatus(self) -> None:
         """The user made a change in text selection. Forward this
         information to the footer, and start the selection word counter.
         """
@@ -1293,18 +1216,15 @@ class GuiDocEditor(QTextEdit):
             if not self.wcTimerSel.isActive():
                 self.wcTimerSel.start()
             self.docFooter.setHasSelection(True)
-
         else:
             self.wcTimerSel.stop()
             self.docFooter.setHasSelection(False)
             self.docFooter.updateCounts()
-
         return
 
     @pyqtSlot()
-    def _runSelCounter(self):
-        """Update the selection word count.
-        """
+    def _runSelCounter(self) -> None:
+        """Update the selection word count."""
         if self._docHandle is None:
             return
 
@@ -1312,14 +1232,13 @@ class GuiDocEditor(QTextEdit):
             logger.debug("Selection word counter is busy")
             return
 
-        self.mainGui.threadPool.start(self.wCounterSel)
+        SHARED.runInThreadPool(self.wCounterSel)
 
         return
 
     @pyqtSlot(int, int, int)
-    def _updateSelCounts(self, cCount, wCount, pCount):
-        """Slot for the word counter's finished signal
-        """
+    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
 
@@ -1329,51 +1248,44 @@ class GuiDocEditor(QTextEdit):
 
         return
 
-    @pyqtSlot("QSizeF")
-    def _docSizeChanged(self, theSize):
-        """Called whenever the underlying document layout size changes.
-        This is used to queue the repositioning of the cursor for very
-        large documents to ensure the region where the cursor is being
-        moved to has been drawn before the move is made.
-        """
-        if self._queuePos is not None:
-            thePos = self.document().documentLayout().hitTest(
-                QPointF(theSize.width(), theSize.height()), Qt.FuzzyHit
-            )
-            if self._queuePos <= thePos:
-                logger.debug("Allowed cursor move to %d <= %d", self._queuePos, thePos)
-                self.setCursorPosition(self._queuePos)
-                self._queuePos = None
-            else:
-                logger.debug("Denied cursor move to %d > %d", self._queuePos, thePos)
+    @pyqtSlot()
+    def _closeCurrentDocument(self) -> None:
+        """Close the document. Forwarded to the main Gui."""
+        self.closeDocumentRequest.emit()
+        self.docToolBar.setVisible(False)
+        return
 
+    @pyqtSlot()
+    def _toggleToolBarVisibility(self) -> None:
+        """Toggle the visibility of the tool bar."""
+        state = not self.docToolBar.isVisible()
+        self.docToolBar.setVisible(state)
+        CONFIG.showEditToolBar = state
         return
 
     ##
     #  Search & Replace
     ##
 
-    def beginSearch(self):
-        """Set the selected text as the search text for the search bar.
-        """
-        theCursor = self.textCursor()
-        if theCursor.hasSelection():
-            self.docSearch.setSearchText(theCursor.selectedText())
+    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)
         resS, _ = self.findAllOccurences()
         self.docSearch.setResultCount(None, len(resS))
         return
 
-    def beginReplace(self):
-        """Initialise the search box and reset the replace text box.
-        """
+    def beginReplace(self) -> None:
+        """Initialise the search box and reset the replace text box."""
         self.beginSearch()
         self.docSearch.setReplaceText("")
         self.updateDocMargins()
         return
 
-    def findNext(self, goBack=False):
+    def findNext(self, goBack: bool = False) -> None:
         """Search for the next or previous occurrence of the search bar
         text in the document. Wrap around if not found and loop is
         enabled, or continue to next file if next file is enabled.
@@ -1387,7 +1299,7 @@ class GuiDocEditor(QTextEdit):
             return
 
         resS, resE = self.findAllOccurences()
-        if len(resS) == 0:
+        if len(resS) == 0 and self._docHandle:
             self.docSearch.setResultCount(0, 0)
             self._lastFind = None
             if self.docSearch.doNextFile and not goBack:
@@ -1397,8 +1309,8 @@ class GuiDocEditor(QTextEdit):
                 self.beginSearch()
             return
 
-        theCursor = self.textCursor()
-        resIdx = bisect.bisect_left(resS, theCursor.position())
+        cursor = self.textCursor()
+        resIdx = bisect.bisect_left(resS, cursor.position())
 
         doLoop = self.docSearch.doLoop
         maxIdx = len(resS) - 1
@@ -1409,7 +1321,7 @@ class GuiDocEditor(QTextEdit):
         if resIdx < 0:
             resIdx = maxIdx if doLoop else 0
 
-        if resIdx > maxIdx:
+        if resIdx > maxIdx and self._docHandle:
             if self.docSearch.doNextFile and not goBack:
                 self.mainGui.openNextDocument(
                     self._docHandle, wrapAround=self.docSearch.doLoop
@@ -1419,9 +1331,9 @@ class GuiDocEditor(QTextEdit):
             else:
                 resIdx = 0 if doLoop else maxIdx
 
-        theCursor.setPosition(resS[resIdx], QTextCursor.MoveAnchor)
-        theCursor.setPosition(resE[resIdx], QTextCursor.KeepAnchor)
-        self.setTextCursor(theCursor)
+        cursor.setPosition(resS[resIdx], QTextCursor.MoveMode.MoveAnchor)
+        cursor.setPosition(resE[resIdx], QTextCursor.MoveMode.KeepAnchor)
+        self.setTextCursor(cursor)
 
         self.docFooter.updateLineCount()
         self.docSearch.setResultCount(resIdx + 1, len(resS))
@@ -1429,113 +1341,113 @@ class GuiDocEditor(QTextEdit):
 
         return
 
-    def findAllOccurences(self):
+    def findAllOccurences(self) -> tuple[list[int], list[int]]:
         """Create a list of all search results of the current search
         text in the document.
         """
         resS = []
         resE = []
-        theCursor = self.textCursor()
-        hasSelection = theCursor.hasSelection()
+        cursor = self.textCursor()
+        hasSelection = cursor.hasSelection()
         if hasSelection:
-            origA = theCursor.selectionStart()
-            origB = theCursor.selectionEnd()
+            origA = cursor.selectionStart()
+            origB = cursor.selectionEnd()
         else:
-            origA = theCursor.position()
-            origB = theCursor.position()
+            origA = cursor.position()
+            origB = cursor.position()
 
         findOpt = QTextDocument.FindFlag(0)
         if self.docSearch.isCaseSense:
-            findOpt |= QTextDocument.FindCaseSensitively
+            findOpt |= QTextDocument.FindFlag.FindCaseSensitively
         if self.docSearch.isWholeWord:
-            findOpt |= QTextDocument.FindWholeWords
+            findOpt |= QTextDocument.FindFlag.FindWholeWords
 
         searchFor = self.docSearch.getSearchObject()
-        theCursor.setPosition(0)
-        self.setTextCursor(theCursor)
+        cursor.setPosition(0)
+        self.setTextCursor(cursor)
 
         # Search up to a maximum of 1000, and make sure certain special
-        # searches like a regex search for .* turns into an infinite loop
+        # searches like a regex search for .* don't loop infinitely
         while self.find(searchFor, findOpt) and len(resE) <= 1000:
-            theCursor = self.textCursor()
-            if theCursor.hasSelection():
-                resS.append(theCursor.selectionStart())
-                resE.append(theCursor.selectionEnd())
+            cursor = self.textCursor()
+            if cursor.hasSelection():
+                resS.append(cursor.selectionStart())
+                resE.append(cursor.selectionEnd())
             else:
                 logger.warning("The search returned an empty result")
                 break
 
         if hasSelection:
-            theCursor.setPosition(origA, QTextCursor.MoveAnchor)
-            theCursor.setPosition(origB, QTextCursor.KeepAnchor)
+            cursor.setPosition(origA, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(origB, QTextCursor.MoveMode.KeepAnchor)
         else:
-            theCursor.setPosition(origA)
+            cursor.setPosition(origA)
 
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return resS, resE
 
-    def replaceNext(self):
+    def replaceNext(self) -> None:
         """Search for the next occurrence of the search bar text in the
         document and replace it with the replace text. Call search next
         automatically when done.
         """
         if not self.anyFocus():
             logger.debug("Editor does not have focus")
-            return False
+            return
 
         if not self.docSearch.isVisible():
             # The search tool is not active, so we activate it.
             self.beginSearch()
             return
 
-        theCursor = self.textCursor()
-        if not theCursor.hasSelection():
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
             # We have no text selected at all, so just make this a
             # regular find next call.
             self.findNext()
             return
 
-        if self._lastFind is None and theCursor.hasSelection():
+        if self._lastFind is None and cursor.hasSelection():
             # If we have a selection but no search, it may have been the
             # text we triggered the search with, in which case we search
             # again from the beginning of that selection to make sure we
             # have a valid result.
-            sPos = theCursor.selectionStart()
-            theCursor.clearSelection()
-            theCursor.setPosition(sPos)
-            self.setTextCursor(theCursor)
+            sPos = cursor.selectionStart()
+            cursor.clearSelection()
+            cursor.setPosition(sPos)
+            self.setTextCursor(cursor)
             self.findNext()
-            theCursor = self.textCursor()
+            cursor = self.textCursor()
 
         if self._lastFind is None:
             # In case the above didn't find a result, we give up here.
             return
 
-        searchFor = self.docSearch.getSearchText()
-        replWith = self.docSearch.getReplaceText()
+        searchFor = self.docSearch.searchText
+        replWith = self.docSearch.replaceText
 
         if self.docSearch.doMatchCap:
-            replWith = transferCase(theCursor.selectedText(), replWith)
+            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] == theCursor.selectionStart()
-            isFind &= self._lastFind[1] == theCursor.selectionEnd()
+            isFind  = self._lastFind[0] == cursor.selectionStart()
+            isFind &= self._lastFind[1] == cursor.selectionEnd()
         except Exception:
             isFind = False
 
         if isFind:
-            theCursor.beginEditBlock()
-            theCursor.removeSelectedText()
-            theCursor.insertText(replWith)
-            theCursor.endEditBlock()
-            theCursor.setPosition(theCursor.selectionEnd())
-            self.setTextCursor(theCursor)
+            cursor.beginEditBlock()
+            cursor.removeSelectedText()
+            cursor.insertText(replWith)
+            cursor.endEditBlock()
+            cursor.setPosition(cursor.selectionEnd())
+            self.setTextCursor(cursor)
             logger.debug(
                 "Replaced occurrence of '%s' with '%s' on line %d",
-                searchFor, replWith, theCursor.blockNumber()
+                searchFor, replWith, cursor.blockNumber()
             )
         else:
             logger.error("The selected text is not a search result, skipping replace")
@@ -1548,128 +1460,143 @@ class GuiDocEditor(QTextEdit):
     #  Internal Functions : Text Manipulation
     ##
 
-    def _toggleFormat(self, fLen, fChar):
+    def _toggleFormat(self, fLen: int, fChar: str) -> bool:
         """Toggle the formatting of a specific type for a piece of text.
         If more than one block is selected, the formatting is applied to
         the first block.
         """
-        theCursor = self._autoSelect()
-        if not theCursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
+        cursor = self.textCursor()
+        posO = cursor.position()
+        if cursor.hasSelection():
+            select = _SelectAction.KEEP_SELECTION
+        else:
+            cursor = self._autoSelect()
+            if cursor.hasSelection() and posO == cursor.selectionEnd():
+                select = _SelectAction.MOVE_AFTER
+            else:
+                select = _SelectAction.KEEP_POSITION
+
+        posS = cursor.selectionStart()
+        posE = cursor.selectionEnd()
+        if self._qDocument.characterAt(posO - 1) == fChar:
+            logger.warning("Format repetition, cancelling action")
+            cursor.clearSelection()
+            cursor.setPosition(posO)
+            self.setTextCursor(cursor)
             return False
 
-        posS = theCursor.selectionStart()
-        posE = theCursor.selectionEnd()
-
-        blockS = self.document().findBlock(posS)
-        blockE = self.document().findBlock(posE)
-
+        blockS = self._qDocument.findBlock(posS)
+        blockE = self._qDocument.findBlock(posE)
         if blockS != blockE:
             posE = blockS.position() + blockS.length() - 1
-            theCursor.clearSelection()
-            theCursor.setPosition(posS, QTextCursor.MoveAnchor)
-            theCursor.setPosition(posE, QTextCursor.KeepAnchor)
-            self.setTextCursor(theCursor)
+            cursor.clearSelection()
+            cursor.setPosition(posS, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
+            self.setTextCursor(cursor)
 
         numB = 0
         for n in range(fLen):
-            if self.document().characterAt(posS-n-1) == fChar:
+            if self._qDocument.characterAt(posS-n-1) == fChar:
                 numB += 1
             else:
                 break
 
         numA = 0
         for n in range(fLen):
-            if self.document().characterAt(posE+n) == fChar:
+            if self._qDocument.characterAt(posE+n) == fChar:
                 numA += 1
             else:
                 break
 
         if fLen == min(numA, numB):
-            self._clearSurrounding(theCursor, fLen)
-        else:
-            self._wrapSelection(fChar*fLen)
-
-        return True
-
-    def _clearSurrounding(self, theCursor, nChars):
-        """Clear n characters before and after the cursor.
-        """
-        if not theCursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
-            return False
+            cursor.clearSelection()
+            cursor.beginEditBlock()
+            cursor.setPosition(posS)
+            for i in range(fLen):
+                cursor.deletePreviousChar()
+            cursor.setPosition(posE)
+            for i in range(fLen):
+                cursor.deletePreviousChar()
+            cursor.endEditBlock()
+            cursor.clearSelection()
+            cursor.setPosition(posO - fLen)
+            self.setTextCursor(cursor)
 
-        posS = theCursor.selectionStart()
-        posE = theCursor.selectionEnd()
-        theCursor.clearSelection()
-        theCursor.beginEditBlock()
-        theCursor.setPosition(posS)
-        for i in range(nChars):
-            theCursor.deletePreviousChar()
-        theCursor.setPosition(posE)
-        for i in range(nChars):
-            theCursor.deletePreviousChar()
-        theCursor.endEditBlock()
-        theCursor.clearSelection()
+        else:
+            self._wrapSelection(fChar*fLen, pos=posO, select=select)
 
         return True
 
-    def _wrapSelection(self, tBefore, tAfter=None):
+    def _wrapSelection(self, before: str, after: str | None = None, pos: int | None = None,
+                       select: _SelectAction = _SelectAction.NO_DECISION) -> bool:
         """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
         wrapping it. If this feature is disabled, nothing is done.
         """
-        if tAfter is None:
-            tAfter = tBefore
+        if after is None:
+            after = before
 
-        theCursor = self._autoSelect()
-        if not theCursor.hasSelection():
-            logger.warning("No selection made, nothing to do")
-            return False
+        cursor = self.textCursor()
+        posO = pos if isinstance(pos, int) else cursor.position()
+        if select == _SelectAction.NO_DECISION:
+            if cursor.hasSelection():
+                select = _SelectAction.KEEP_SELECTION
+            else:
+                cursor = self._autoSelect()
+                if cursor.hasSelection() and posO == cursor.selectionEnd():
+                    select = _SelectAction.MOVE_AFTER
+                else:
+                    select = _SelectAction.KEEP_POSITION
 
-        posS = theCursor.selectionStart()
-        posE = theCursor.selectionEnd()
+        posS = cursor.selectionStart()
+        posE = cursor.selectionEnd()
 
-        qDoc = self.document()
-        blockS = qDoc.findBlock(posS)
-        blockE = qDoc.findBlock(posE)
+        blockS = self._qDocument.findBlock(posS)
+        blockE = self._qDocument.findBlock(posE)
         if blockS != blockE:
             posE = blockS.position() + blockS.length() - 1
 
-        theCursor.clearSelection()
-        theCursor.beginEditBlock()
-        theCursor.setPosition(posE)
-        theCursor.insertText(tAfter)
-        theCursor.setPosition(posS)
-        theCursor.insertText(tBefore)
-        theCursor.endEditBlock()
+        cursor.clearSelection()
+        cursor.beginEditBlock()
+        cursor.setPosition(posE)
+        cursor.insertText(after)
+        cursor.setPosition(posS)
+        cursor.insertText(before)
+        cursor.endEditBlock()
+
+        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)
+        elif select == _SelectAction.KEEP_POSITION:
+            cursor.setPosition(posO + len(before))
 
-        theCursor.setPosition(posE + len(tBefore), QTextCursor.MoveAnchor)
-        theCursor.setPosition(posS + len(tBefore), QTextCursor.KeepAnchor)
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return True
 
-    def _replaceQuotes(self, sQuote, oQuote, cQuote):
-        """Replace all straight quotes in the selected text.
-        """
-        theCursor = self.textCursor()
-        if not theCursor.hasSelection():
+    def _replaceQuotes(self, sQuote: str, oQuote: str, cQuote: str) -> bool:
+        """Replace all straight quotes in the selected text."""
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
             SHARED.error(self.tr("Please select some text before calling replace quotes."))
             return False
 
-        posS = theCursor.selectionStart()
-        posE = theCursor.selectionEnd()
+        posS = cursor.selectionStart()
+        posE = cursor.selectionEnd()
         closeCheck = (
             " ", "\n", nwUnicode.U_LSEP, nwUnicode.U_PSEP
         )
 
         self._allowAutoReplace(False)
         for posC in range(posS, posE+1):
-            theCursor.setPosition(posC)
-            theCursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 2)
-            selText = theCursor.selectedText()
+            cursor.setPosition(posC)
+            cursor.movePosition(
+                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 2
+            )
+            selText = cursor.selectedText()
 
             nS = len(selText)
             if nS == 2:
@@ -1684,169 +1611,170 @@ class GuiDocEditor(QTextEdit):
             if cC != sQuote:
                 continue
 
-            theCursor.clearSelection()
-            theCursor.setPosition(posC)
+            cursor.clearSelection()
+            cursor.setPosition(posC)
             if pC in closeCheck:
-                theCursor.beginEditBlock()
-                theCursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1)
-                theCursor.insertText(oQuote)
-                theCursor.endEditBlock()
+                cursor.beginEditBlock()
+                cursor.movePosition(
+                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
+                )
+                cursor.insertText(oQuote)
+                cursor.endEditBlock()
             else:
-                theCursor.beginEditBlock()
-                theCursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, 1)
-                theCursor.insertText(cQuote)
-                theCursor.endEditBlock()
+                cursor.beginEditBlock()
+                cursor.movePosition(
+                    QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, 1
+                )
+                cursor.insertText(cQuote)
+                cursor.endEditBlock()
 
         self._allowAutoReplace(True)
 
         return True
 
-    def _formatBlock(self, docAction):
-        """Change the block format of the block under the cursor.
-        """
-        theCursor = self.textCursor()
-        theBlock = theCursor.block()
-        if not theBlock.isValid():
-            logger.debug("Invalid block selected for action '%s'", str(docAction))
+    def _formatBlock(self, action: nwDocAction) -> bool:
+        """Change the block format of the block under the cursor."""
+        cursor = self.textCursor()
+        block = cursor.block()
+        if not block.isValid():
+            logger.debug("Invalid block selected for action '%s'", str(action))
             return False
 
         # Remove existing format first, if any
-        theText = theBlock.text()
-        hasText = len(theText) > 0
-        if theText.startswith("@"):
+        setText = block.text()
+        hasText = len(setText) > 0
+        if setText.startswith("@"):
             logger.error("Cannot apply block format to keyword/value line")
             return False
-        elif theText.startswith("% "):
-            newText = theText[2:]
+        elif setText.startswith("% "):
+            newText = setText[2:]
             cOffset = 2
-            if docAction == nwDocAction.BLOCK_COM:
-                docAction = nwDocAction.BLOCK_TXT
-        elif theText.startswith("%"):
-            newText = theText[1:]
+            if action == nwDocAction.BLOCK_COM:
+                action = nwDocAction.BLOCK_TXT
+        elif setText.startswith("%"):
+            newText = setText[1:]
             cOffset = 1
-            if docAction == nwDocAction.BLOCK_COM:
-                docAction = nwDocAction.BLOCK_TXT
-        elif theText.startswith("# "):
-            newText = theText[2:]
+            if action == nwDocAction.BLOCK_COM:
+                action = nwDocAction.BLOCK_TXT
+        elif setText.startswith("# "):
+            newText = setText[2:]
             cOffset = 2
-        elif theText.startswith("## "):
-            newText = theText[3:]
+        elif setText.startswith("## "):
+            newText = setText[3:]
             cOffset = 3
-        elif theText.startswith("### "):
-            newText = theText[4:]
+        elif setText.startswith("### "):
+            newText = setText[4:]
             cOffset = 4
-        elif theText.startswith("#### "):
-            newText = theText[5:]
+        elif setText.startswith("#### "):
+            newText = setText[5:]
             cOffset = 5
-        elif theText.startswith("#! "):
-            newText = theText[3:]
+        elif setText.startswith("#! "):
+            newText = setText[3:]
             cOffset = 3
-        elif theText.startswith("##! "):
-            newText = theText[4:]
+        elif setText.startswith("##! "):
+            newText = setText[4:]
             cOffset = 4
-        elif theText.startswith(">> "):
-            newText = theText[3:]
+        elif setText.startswith(">> "):
+            newText = setText[3:]
             cOffset = 3
-        elif theText.startswith("> ") and docAction != nwDocAction.INDENT_R:
-            newText = theText[2:]
+        elif setText.startswith("> ") and action != nwDocAction.INDENT_R:
+            newText = setText[2:]
             cOffset = 2
-        elif theText.startswith(">>"):
-            newText = theText[2:]
+        elif setText.startswith(">>"):
+            newText = setText[2:]
             cOffset = 2
-        elif theText.startswith(">") and docAction != nwDocAction.INDENT_R:
-            newText = theText[1:]
+        elif setText.startswith(">") and action != nwDocAction.INDENT_R:
+            newText = setText[1:]
             cOffset = 1
         else:
-            newText = theText
+            newText = setText
             cOffset = 0
 
         # Also remove formatting tags at the end
-        if theText.endswith(" <<"):
+        if setText.endswith(" <<"):
             newText = newText[:-3]
-        elif theText.endswith(" <") and docAction != nwDocAction.INDENT_L:
+        elif setText.endswith(" <") and action != nwDocAction.INDENT_L:
             newText = newText[:-2]
-        elif theText.endswith("<<"):
+        elif setText.endswith("<<"):
             newText = newText[:-2]
-        elif theText.endswith("<") and docAction != nwDocAction.INDENT_L:
+        elif setText.endswith("<") and action != nwDocAction.INDENT_L:
             newText = newText[:-1]
 
         # Apply new format
-        if docAction == nwDocAction.BLOCK_COM:
-            theText = "% "+newText
+        if action == nwDocAction.BLOCK_COM:
+            setText = "% "+newText
             cOffset -= 2
-        elif docAction == nwDocAction.BLOCK_H1:
-            theText = "# "+newText
+        elif action == nwDocAction.BLOCK_H1:
+            setText = "# "+newText
             cOffset -= 2
-        elif docAction == nwDocAction.BLOCK_H2:
-            theText = "## "+newText
+        elif action == nwDocAction.BLOCK_H2:
+            setText = "## "+newText
             cOffset -= 3
-        elif docAction == nwDocAction.BLOCK_H3:
-            theText = "### "+newText
+        elif action == nwDocAction.BLOCK_H3:
+            setText = "### "+newText
             cOffset -= 4
-        elif docAction == nwDocAction.BLOCK_H4:
-            theText = "#### "+newText
+        elif action == nwDocAction.BLOCK_H4:
+            setText = "#### "+newText
             cOffset -= 5
-        elif docAction == nwDocAction.BLOCK_TTL:
-            theText = "#! "+newText
+        elif action == nwDocAction.BLOCK_TTL:
+            setText = "#! "+newText
             cOffset -= 3
-        elif docAction == nwDocAction.BLOCK_UNN:
-            theText = "##! "+newText
+        elif action == nwDocAction.BLOCK_UNN:
+            setText = "##! "+newText
             cOffset -= 4
-        elif docAction == nwDocAction.ALIGN_L:
-            theText = newText+" <<"
-        elif docAction == nwDocAction.ALIGN_C:
-            theText = ">> "+newText+" <<"
+        elif action == nwDocAction.ALIGN_L:
+            setText = newText+" <<"
+        elif action == nwDocAction.ALIGN_C:
+            setText = ">> "+newText+" <<"
             cOffset -= 3
-        elif docAction == nwDocAction.ALIGN_R:
-            theText = ">> "+newText
+        elif action == nwDocAction.ALIGN_R:
+            setText = ">> "+newText
             cOffset -= 3
-        elif docAction == nwDocAction.INDENT_L:
-            theText = "> "+newText
+        elif action == nwDocAction.INDENT_L:
+            setText = "> "+newText
             cOffset -= 2
-        elif docAction == nwDocAction.INDENT_R:
-            theText = newText+" <"
-        elif docAction == nwDocAction.BLOCK_TXT:
-            theText = newText
+        elif action == nwDocAction.INDENT_R:
+            setText = newText+" <"
+        elif action == nwDocAction.BLOCK_TXT:
+            setText = newText
         else:
-            logger.error("Unknown or unsupported block format requested: '%s'", str(docAction))
+            logger.error("Unknown or unsupported block format requested: '%s'", str(action))
             return False
 
         # Replace the block text
-        theCursor.beginEditBlock()
-        posO = theCursor.position()
-        theCursor.select(QTextCursor.BlockUnderCursor)
-        posS = theCursor.selectionStart()
-        theCursor.removeSelectedText()
-        theCursor.setPosition(posS)
+        cursor.beginEditBlock()
+        posO = cursor.position()
+        cursor.select(QTextCursor.SelectionType.BlockUnderCursor)
+        posS = cursor.selectionStart()
+        cursor.removeSelectedText()
+        cursor.setPosition(posS)
 
         if posS > 0 and hasText:
             # If the block already had text, we must insert a new block
             # first before we can add back the text to it.
-            theCursor.insertBlock()
+            cursor.insertBlock()
 
-        theCursor.insertText(theText)
+        cursor.insertText(setText)
 
         if posO - cOffset >= 0:
-            theCursor.setPosition(posO - cOffset)
+            cursor.setPosition(posO - cOffset)
 
-        theCursor.endEditBlock()
-        self.setTextCursor(theCursor)
+        cursor.endEditBlock()
+        self.setTextCursor(cursor)
 
         return True
 
-    def _removeInParLineBreaks(self):
-        """Strip line breaks within paragraphs in the selected text.
-        """
-        theCursor = self.textCursor()
-        theDoc = self.document()
+    def _removeInParLineBreaks(self) -> None:
+        """Strip line breaks within paragraphs in the selected text."""
+        cursor = self.textCursor()
 
         iS = 0
-        iE = theDoc.blockCount() - 1
+        iE = self._qDocument.blockCount() - 1
         rS = 0
-        rE = theDoc.characterCount()
-        if theCursor.hasSelection():
-            sBlock = theDoc.findBlock(theCursor.selectionStart())
-            eBlock = theDoc.findBlock(theCursor.selectionEnd())
+        rE = self._qDocument.characterCount()
+        if cursor.hasSelection():
+            sBlock = self._qDocument.findBlock(cursor.selectionStart())
+            eBlock = self._qDocument.findBlock(cursor.selectionEnd())
             iS = sBlock.blockNumber()
             iE = eBlock.blockNumber()
             rS = sBlock.position()
@@ -1856,7 +1784,7 @@ class GuiDocEditor(QTextEdit):
         currPar = []
         cleanText = ""
         for i in range(iS, iE+1):
-            cBlock = theDoc.findBlockByNumber(i)
+            cBlock = self._qDocument.findBlockByNumber(i)
             cText = cBlock.text()
             if cText.strip() == "":
                 if currPar:
@@ -1873,171 +1801,187 @@ class GuiDocEditor(QTextEdit):
             cleanText += " ".join(currPar) + "\n\n"
 
         # Replace the text with the cleaned up text
-        theCursor.beginEditBlock()
-        theCursor.clearSelection()
-        theCursor.setPosition(rS)
-        theCursor.movePosition(QTextCursor.Right, QTextCursor.KeepAnchor, rE-rS)
-        theCursor.insertText(cleanText.rstrip() + "\n")
-        theCursor.endEditBlock()
+        cursor.beginEditBlock()
+        cursor.clearSelection()
+        cursor.setPosition(rS)
+        cursor.movePosition(
+            QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, rE-rS
+        )
+        cursor.insertText(cleanText.rstrip() + "\n")
+        cursor.endEditBlock()
 
-        return True
+        return
 
     ##
     #  Internal Functions
     ##
 
-    def _followTag(self, theCursor=None, loadTag=True):
+    def _processTag(self, cursor: QTextCursor | None = None,
+                    follow: bool = True, create: bool = False) -> nwTrinary:
         """Activated by Ctrl+Enter. Checks that we're in a block
         starting with '@'. We then find the tag under the cursor and
         check that it is not the tag itself. If all this is fine, we
         have a tag and can tell the document viewer to try and find and
         load the file where the tag is defined.
         """
-        if theCursor is None:
-            theCursor = self.textCursor()
+        if cursor is None:
+            cursor = self.textCursor()
 
-        theBlock = theCursor.block()
-        theText = theBlock.text()
+        block = cursor.block()
+        text = block.text()
+        if len(text) == 0:
+            return nwTrinary.NEUTRAL
 
-        if len(theText) == 0:
-            return False
-
-        if theText.startswith("@"):
+        if text.startswith("@") and isinstance(self._nwItem, NWItem):
 
-            isGood, tBits, tPos = SHARED.project.index.scanThis(theText)
+            isGood, tBits, tPos = SHARED.project.index.scanThis(text)
             if not isGood:
-                return False
+                return nwTrinary.NEUTRAL
 
-            theTag = ""
-            cPos = theCursor.selectionStart() - theBlock.position()
-            for sTag, sPos in zip(reversed(tBits), reversed(tPos)):
+            tag = ""
+            exist = False
+            cPos = cursor.selectionStart() - block.position()
+            tExist = SHARED.project.index.checkThese(tBits, self._nwItem)
+            for sTag, sPos, sExist in zip(reversed(tBits), reversed(tPos), reversed(tExist)):
                 if cPos >= sPos:
                     # The cursor is between the start of two tags
                     if cPos <= sPos + len(sTag):
                         # The cursor is inside or at the edge of the tag
-                        theTag = sTag
+                        tag = sTag
+                        exist = sExist
                     break
 
-            if not theTag or theTag.startswith("@"):
+            if not tag or tag.startswith("@"):
                 # The keyword cannot be looked up, so we ignore that
-                return False
-
-            if loadTag:
-                logger.debug("Attempting to follow tag '%s'", theTag)
-                self.loadDocumentTagRequest.emit(theTag, nwDocMode.VIEW)
-            else:
-                logger.debug("Potential tag '%s'", theTag)
-
-            return True
-
-        return False
-
-    def _openSpellContext(self):
-        """Open the spell check context menu at the current point of the
-        cursor.
-        """
+                return nwTrinary.NEUTRAL
+
+            if follow and exist:
+                logger.debug("Attempting to follow tag '%s'", tag)
+                self.loadDocumentTagRequest.emit(tag, nwDocMode.VIEW)
+            elif create and not exist:
+                if SHARED.question(self.tr(
+                    "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])))
+
+            return nwTrinary.POSITIVE if exist else nwTrinary.NEGATIVE
+
+        return nwTrinary.NEUTRAL
+
+    def _emitRenameItem(self, block: QTextBlock) -> None:
+        """Emit a signal to request an item be renamed."""
+        if self._docHandle:
+            text = block.text().lstrip("#").lstrip("!").strip()
+            self.requestProjectItemRenamed.emit(self._docHandle, text)
+        return
+
+    def _openContextFromCursor(self) -> None:
+        """Open the spell check context menu at the cursor."""
         self._openContextMenu(self.cursorRect().center())
         return
 
-    def _docAutoReplace(self, theBlock):
-        """Auto-replace text elements based on main configuration.
-        """
-        if not theBlock.isValid():
-            return
+    def _docAutoReplace(self, text: str) -> None:
+        """Auto-replace text elements based on main configuration."""
+        cursor = self.textCursor()
+        tPos = cursor.positionInBlock()
+        tLen = len(text)
 
-        theText = theBlock.text()
-        theCursor = self.textCursor()
-        thePos = theCursor.positionInBlock()
-        theLen = len(theText)
-
-        if theLen < 1 or thePos-1 > theLen:
+        if tLen < 1 or tPos-1 > tLen:
             return
 
-        theOne = theText[thePos-1:thePos]
-        theTwo = theText[thePos-2:thePos]
-        theThree = theText[thePos-3:thePos]
+        tOne = text[tPos-1:tPos]
+        tTwo = text[tPos-2:tPos]
+        tThree = text[tPos-3:tPos]
 
-        if not theOne:
-            # Sorry, Neo and Zathras
+        if not tOne:
             return
 
         nDelete = 0
-        tInsert = theOne
+        tInsert = tOne
 
-        if self._typRepDQuote and theTwo[:1].isspace() and theTwo.endswith('"'):
+        if self._typRepDQuote and tTwo[:1].isspace() and tTwo.endswith('"'):
             nDelete = 1
             tInsert = self._typDQuoteO
 
-        elif self._typRepDQuote and theOne == '"':
+        elif self._typRepDQuote and tOne == '"':
             nDelete = 1
-            if thePos == 1:
+            if tPos == 1:
                 tInsert = self._typDQuoteO
-            elif thePos == 2 and theTwo == '>"':
+            elif tPos == 2 and tTwo == '>"':
                 tInsert = self._typDQuoteO
-            elif thePos == 3 and theThree == '>>"':
+            elif tPos == 3 and tThree == '>>"':
                 tInsert = self._typDQuoteO
             else:
                 tInsert = self._typDQuoteC
 
-        elif self._typRepSQuote and theTwo[:1].isspace() and theTwo.endswith("'"):
+        elif self._typRepSQuote and tTwo[:1].isspace() and tTwo.endswith("'"):
             nDelete = 1
             tInsert = self._typSQuoteO
 
-        elif self._typRepSQuote and theOne == "'":
+        elif self._typRepSQuote and tOne == "'":
             nDelete = 1
-            if thePos == 1:
+            if tPos == 1:
                 tInsert = self._typSQuoteO
-            elif thePos == 2 and theTwo == ">'":
+            elif tPos == 2 and tTwo == ">'":
                 tInsert = self._typSQuoteO
-            elif thePos == 3 and theThree == ">>'":
+            elif tPos == 3 and tThree == ">>'":
                 tInsert = self._typSQuoteO
             else:
                 tInsert = self._typSQuoteC
 
-        elif self._typRepDash and theThree == "---":
+        elif self._typRepDash and tThree == "---":
             nDelete = 3
             tInsert = nwUnicode.U_EMDASH
 
-        elif self._typRepDash and theTwo == "--":
+        elif self._typRepDash and tTwo == "--":
             nDelete = 2
             tInsert = nwUnicode.U_ENDASH
 
-        elif self._typRepDash and theTwo == nwUnicode.U_ENDASH + "-":
+        elif self._typRepDash and tTwo == nwUnicode.U_ENDASH + "-":
             nDelete = 2
             tInsert = nwUnicode.U_EMDASH
 
-        elif self._typRepDots and theThree == "...":
+        elif self._typRepDots and tThree == "...":
             nDelete = 3
             tInsert = nwUnicode.U_HELLIP
 
-        elif theOne == nwUnicode.U_LSEP:
+        elif tOne == nwUnicode.U_LSEP:
             # This resolves issue #1150
             nDelete = 1
             tInsert = nwUnicode.U_PSEP
 
         tCheck = tInsert
         if self._typPadBefore and tCheck in self._typPadBefore:
-            if self._allowSpaceBeforeColon(theText, tCheck):
+            if self._allowSpaceBeforeColon(text, tCheck):
                 nDelete = max(nDelete, 1)
-                chkPos = thePos - nDelete - 1
-                if chkPos >= 0 and theText[chkPos].isspace():
+                chkPos = tPos - nDelete - 1
+                if chkPos >= 0 and text[chkPos].isspace():
                     # Strip existing space before inserting a new (#1061)
                     nDelete += 1
                 tInsert = self._typPadChar + tInsert
 
         if self._typPadAfter and tCheck in self._typPadAfter:
-            if self._allowSpaceBeforeColon(theText, tCheck):
+            if self._allowSpaceBeforeColon(text, tCheck):
                 nDelete = max(nDelete, 1)
                 tInsert = tInsert + self._typPadChar
 
         if nDelete > 0:
-            theCursor.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, nDelete)
-            theCursor.insertText(tInsert)
+            cursor.movePosition(
+                QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, nDelete
+            )
+            cursor.insertText(tInsert)
 
         return
 
     @staticmethod
-    def _allowSpaceBeforeColon(text, char):
+    def _allowSpaceBeforeColon(text: str, char: str) -> bool:
         """Special checker function only used by the insert space
         feature for French, Spanish, etc, so it doesn't insert a
         space before colons in meta data lines. See issue #1090.
@@ -2050,95 +1994,78 @@ class GuiDocEditor(QTextEdit):
                     return False
         return True
 
-    def _checkDocSize(self, theSize):
-        """Check if document size crosses the big document limit set in
-        config. If so, we will set the big document flag to True.
-        """
-        bigLim = round(CONFIG.bigDocLimit*1000)
-        newState = theSize > bigLim
-
-        if newState != self._bigDoc:
-            if newState:
-                logger.info(
-                    f"The document size is {theSize:n} > {bigLim:n}, "
-                    f"big doc mode has been enabled"
-                )
-            else:
-                logger.info(
-                    f"The document size is {theSize:n} <= {bigLim:n}, "
-                    f"big doc mode has been disabled"
-                )
+    def _autoSelect(self) -> QTextCursor:
+        """Return a cursor which may or may not have a selection based
+        on user settings and document action. The selection will be the
+        word closest to the cursor consisting of alphanumerical unicode
+        characters.
+        """
+        cursor = self.textCursor()
+        if CONFIG.autoSelect and not cursor.hasSelection():
+            cPos = cursor.position()
+            bPos = cursor.block().position()
+            bLen = cursor.block().length()
+
+            # Scan backwards
+            sPos = cPos
+            for i in range(cPos - bPos):
+                sPos = cPos - i - 1
+                if not self._qDocument.characterAt(sPos).isalnum():
+                    sPos += 1
+                    break
 
-        self._bigDoc = newState
+            # Scan forwards
+            ePos = cPos
+            for i in range(bPos + bLen - cPos):
+                ePos = cPos + i
+                if not self._qDocument.characterAt(ePos).isalnum():
+                    break
 
-        return
+            if ePos - sPos <= 0:
+                # No selection possible
+                return cursor
 
-    def _autoSelect(self):
-        """Return a cursor which may or may not have a selection based
-        on user settings and document action.
-        """
-        theCursor = self.textCursor()
-        if CONFIG.autoSelect and not theCursor.hasSelection():
-            theCursor.select(QTextCursor.WordUnderCursor)
-            posS = theCursor.selectionStart()
-            posE = theCursor.selectionEnd()
-
-            # Underscore counts as a part of the word, so check that the
-            # selection isn't wrapped in italics markers.
-            reSelect = False
-            qDoc = self.document()
-            if qDoc.characterAt(posS) == "_":
-                posS += 1
-                reSelect = True
-            if qDoc.characterAt(posE) == "_":
-                posE -= 1
-                reSelect = True
-            if reSelect:
-                theCursor.clearSelection()
-                theCursor.setPosition(posS, QTextCursor.MoveAnchor)
-                theCursor.setPosition(posE-1, QTextCursor.KeepAnchor)
-
-            self.setTextCursor(theCursor)
-
-        return theCursor
-
-    def _makeSelection(self, selMode):
-        """Wrapper function to select text based on a selection mode.
-        """
-        theCursor = self.textCursor()
-        theCursor.clearSelection()
-        theCursor.select(selMode)
+            cursor.clearSelection()
+            cursor.setPosition(sPos, QTextCursor.MoveMode.MoveAnchor)
+            cursor.setPosition(ePos, QTextCursor.MoveMode.KeepAnchor)
+
+            self.setTextCursor(cursor)
 
-        if selMode == QTextCursor.WordUnderCursor:
-            theCursor = self._autoSelect()
+        return cursor
 
-        elif selMode == QTextCursor.BlockUnderCursor:
+    def _makeSelection(self, mode: QTextCursor.SelectionType) -> None:
+        """Select text based on selection mode."""
+        cursor = self.textCursor()
+        cursor.clearSelection()
+        cursor.select(mode)
+
+        if mode == QTextCursor.SelectionType.WordUnderCursor:
+            cursor = self._autoSelect()
+
+        elif mode == QTextCursor.SelectionType.BlockUnderCursor:
             # This selection mode also selects the preceding paragraph
             # separator, which we want to avoid.
-            posS = theCursor.selectionStart()
-            posE = theCursor.selectionEnd()
-            selTxt = theCursor.selectedText()
+            posS = cursor.selectionStart()
+            posE = cursor.selectionEnd()
+            selTxt = cursor.selectedText()
             if selTxt.startswith(nwUnicode.U_PSEP):
-                theCursor.setPosition(posS+1, QTextCursor.MoveAnchor)
-                theCursor.setPosition(posE, QTextCursor.KeepAnchor)
+                cursor.setPosition(posS+1, QTextCursor.MoveMode.MoveAnchor)
+                cursor.setPosition(posE, QTextCursor.MoveMode.KeepAnchor)
 
-        self.setTextCursor(theCursor)
+        self.setTextCursor(cursor)
 
         return
 
-    def _makePosSelection(self, selMode, thePos):
-        """Wrapper function to select text based on selection mode, but
-        first move cursor to given position.
-        """
-        theCursor = self.cursorForPosition(thePos)
-        self.setTextCursor(theCursor)
-        self._makeSelection(selMode)
+    def _makePosSelection(self, mode: QTextCursor.SelectionType, pos: QPoint) -> None:
+        """Select text based on selection mode, but first move cursor."""
+        cursor = self.cursorForPosition(pos)
+        self.setTextCursor(cursor)
+        self._makeSelection(mode)
         return
 
-    def _allowAutoReplace(self, theState):
-        """Enable/disable the auto-replace feature temporarily.
-        """
-        if theState:
+    def _allowAutoReplace(self, state: bool) -> None:
+        """Enable/disable the auto-replace feature temporarily."""
+        if state:
             self._doReplace = CONFIG.doReplace
         else:
             self._doReplace = False
@@ -2147,6 +2074,85 @@ class GuiDocEditor(QTextEdit):
 # END Class GuiDocEditor
 
 
+class MetaCompleter(QMenu):
+    """GuiWidget: Meta 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 @.
+    """
+
+    complete = pyqtSignal(int, int, str)
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent=parent)
+        return
+
+    def updateText(self, text: str, pos: int) -> bool:
+        """Update the menu options based on the line of text."""
+        self.clear()
+        kw, sep, _ = text.partition(":")
+        if pos <= len(kw):
+            offset = 0
+            length = len(kw.rstrip())
+            suffix = "" if sep else ":"
+            options = list(filter(
+                lambda x: x.startswith(kw.rstrip()), nwKeyWords.VALID_KEYS
+            ))
+        else:
+            status, tBits, tPos = SHARED.project.index.scanThis(text)
+            if not status:
+                return False
+            index = bisect.bisect_right(tPos, pos) - 1
+            lookup = tBits[index].lower() if index > 0 else ""
+            offset = tPos[index] if lookup else pos
+            length = len(lookup)
+            suffix = ""
+            options = list(filter(
+                lambda x: lookup in x.lower(), SHARED.project.index.getClassTags(
+                    nwKeyWords.KEY_CLASS.get(kw.strip(), nwItemClass.NO_CLASS)
+                )
+            ))[:15]
+
+        if not options:
+            return False
+
+        for value in sorted(options):
+            rep = value + suffix
+            action = self.addAction(value)
+            action.triggered.connect(lambda _, r=rep: self._emitComplete(offset, length, r))
+
+        return True
+
+    ##
+    #  Events
+    ##
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Capture keypresses and forward most of them to the editor."""
+        parent = self.parent()
+        if event.key() in (
+            Qt.Key.Key_Up, Qt.Key.Key_Down, Qt.Key.Key_Return,
+            Qt.Key.Key_Enter, Qt.Key.Key_Escape
+        ):
+            super().keyPressEvent(event)
+        elif isinstance(parent, GuiDocEditor):
+            parent.keyPressEvent(event)
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _emitComplete(self, pos: int, length: int, value: str):
+        """Emit the signal to indicate a selection has been made."""
+        self.complete.emit(pos, length, value)
+        return
+
+# END Class MetaCompleter
+
+
 # =============================================================================================== #
 #  The Off-GUI Thread Word Counter
 #  A runnable for the word counter to be run in the thread pool off the main GUI thread.
@@ -2154,7 +2160,7 @@ class GuiDocEditor(QTextEdit):
 
 class BackgroundWordCounter(QRunnable):
 
-    def __init__(self, docEditor, forSelection=False):
+    def __init__(self, docEditor: GuiDocEditor, forSelection: bool = False) -> None:
         super().__init__()
 
         self._docEditor = docEditor
@@ -2165,21 +2171,21 @@ class BackgroundWordCounter(QRunnable):
 
         return
 
-    def isRunning(self):
+    def isRunning(self) -> bool:
         return self._isRunning
 
     @pyqtSlot()
-    def run(self):
+    def run(self) -> None:
         """Overloaded run function for the word counter, forwarding the
         call to the function that does the actual counting.
         """
         self._isRunning = True
         if self._forSelection:
-            theText = self._docEditor.textCursor().selectedText()
+            text = self._docEditor.textCursor().selectedText()
         else:
-            theText = self._docEditor.getText()
+            text = self._docEditor.getText()
 
-        cC, wC, pC = countWords(theText)
+        cC, wC, pC = countWords(text)
         self.signals.countsReady.emit(cC, wC, pC)
         self._isRunning = False
 
@@ -2197,6 +2203,145 @@ class BackgroundWordCounterSignals(QObject):
 # END Class BackgroundWordCounterSignals
 
 
+# =============================================================================================== #
+#  The Formatting and Options Fold Out Menu
+#  Only used by DocEditor, and is opened by the first button in the header
+# =============================================================================================== #
+
+class GuiDocToolBar(QWidget):
+
+    requestDocAction = pyqtSignal(nwDocAction)
+
+    def __init__(self, docEditor: GuiDocEditor) -> None:
+        super().__init__(parent=docEditor)
+
+        logger.debug("Create: GuiDocToolBar")
+
+        cM = CONFIG.pxInt(4)
+        tPx = int(0.8*SHARED.theme.fontPixelSize)
+        iconSize = QSize(tPx, tPx)
+        self.setContentsMargins(0, 0, 0, 0)
+
+        # General Buttons
+        # ===============
+
+        self.tbMode = QToolButton(self)
+        self.tbMode.setToolTip(self.tr("Toggle Markdown or Shortcodes Mode"))
+        self.tbMode.setIconSize(iconSize)
+        self.tbMode.setCheckable(True)
+        self.tbMode.setChecked(CONFIG.useShortcodes)
+        self.tbMode.toggled.connect(self._toggleFormatMode)
+
+        self.tbBold = QToolButton(self)
+        self.tbBold.setIconSize(iconSize)
+        self.tbBold.clicked.connect(self._formatBold)
+
+        self.tbItalic = QToolButton(self)
+        self.tbItalic.setIconSize(iconSize)
+        self.tbItalic.clicked.connect(self._formatItalic)
+
+        self.tbStrike = QToolButton(self)
+        self.tbStrike.setIconSize(iconSize)
+        self.tbStrike.clicked.connect(self._formatStrike)
+
+        self.tbUnderline = QToolButton(self)
+        self.tbUnderline.setIconSize(iconSize)
+        self.tbUnderline.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_ULINE)
+        )
+
+        self.tbSuperscript = QToolButton(self)
+        self.tbSuperscript.setIconSize(iconSize)
+        self.tbSuperscript.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_SUP)
+        )
+
+        self.tbSubscript = QToolButton(self)
+        self.tbSubscript.setIconSize(iconSize)
+        self.tbSubscript.clicked.connect(
+            lambda: self.requestDocAction.emit(nwDocAction.SC_SUB)
+        )
+
+        # Assemble
+        # ========
+
+        self.outerBox = QVBoxLayout()
+        self.outerBox.addWidget(self.tbMode)
+        self.outerBox.addWidget(self.tbBold)
+        self.outerBox.addWidget(self.tbItalic)
+        self.outerBox.addWidget(self.tbStrike)
+        self.outerBox.addWidget(self.tbUnderline)
+        self.outerBox.addWidget(self.tbSuperscript)
+        self.outerBox.addWidget(self.tbSubscript)
+        self.outerBox.setContentsMargins(cM, cM, cM, cM)
+        self.outerBox.setSpacing(cM)
+
+        self.setLayout(self.outerBox)
+        self.updateTheme()
+
+        # Starts as Invisible
+        self.setVisible(False)
+
+        logger.debug("Ready: GuiDocToolBar")
+
+        return
+
+    def updateTheme(self) -> None:
+        """Initialise GUI elements that depend on specific settings."""
+        palette = QPalette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
+        self.setPalette(palette)
+
+        tPx = int(0.8*SHARED.theme.fontPixelSize)
+        self.tbMode.setIcon(SHARED.theme.getToggleIcon("fmt_mode", (tPx, tPx)))
+        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"))
+
+        return
+
+    ##
+    #  Private Slots
+    ##
+
+    @pyqtSlot(bool)
+    def _toggleFormatMode(self, checked: bool) -> None:
+        """Toggle the formatting mode."""
+        CONFIG.useShortcodes = checked
+        return
+
+    @pyqtSlot()
+    def _formatBold(self):
+        """Call the bold format action."""
+        self.requestDocAction.emit(
+            nwDocAction.SC_BOLD if self.tbMode.isChecked() else nwDocAction.STRONG
+        )
+        return
+
+    @pyqtSlot()
+    def _formatItalic(self):
+        """Call the italic format action."""
+        self.requestDocAction.emit(
+            nwDocAction.SC_ITALIC if self.tbMode.isChecked() else nwDocAction.EMPH
+        )
+        return
+
+    @pyqtSlot()
+    def _formatStrike(self):
+        """Call the strikethrough format action."""
+        self.requestDocAction.emit(
+            nwDocAction.SC_STRIKE if self.tbMode.isChecked() else nwDocAction.STRIKE
+        )
+        return
+
+# END Class GuiDocToolBar
+
+
 # =============================================================================================== #
 #  The Embedded Document Search/Replace Feature
 #  Only used by DocEditor, and is at a fixed position in the QTextEdit's viewport
@@ -2204,13 +2349,12 @@ class BackgroundWordCounterSignals(QObject):
 
 class GuiDocEditSearch(QFrame):
 
-    def __init__(self, docEditor):
+    def __init__(self, docEditor: GuiDocEditor) -> None:
         super().__init__(parent=docEditor)
 
         logger.debug("Create: GuiDocEditSearch")
 
         self.docEditor = docEditor
-        self.mainGui   = docEditor.mainGui
 
         self.repVisible  = False
         self.isCaseSense = CONFIG.searchCase
@@ -2227,7 +2371,7 @@ class GuiDocEditSearch(QFrame):
 
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
-        self.setFrameStyle(QFrame.StyledPanel | QFrame.Plain)
+        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
 
         self.mainBox = QGridLayout(self)
         self.setLayout(self.mainBox)
@@ -2246,7 +2390,7 @@ class GuiDocEditSearch(QFrame):
         self.replaceBox.returnPressed.connect(self._doReplace)
 
         self.searchOpt = QToolBar(self)
-        self.searchOpt.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.searchOpt.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.searchOpt.setIconSize(QSize(tPx, tPx))
         self.searchOpt.setContentsMargins(0, 0, 0, 0)
 
@@ -2308,7 +2452,7 @@ class GuiDocEditSearch(QFrame):
         bPx = self.searchBox.sizeHint().height()
 
         self.showReplace = QToolButton(self)
-        self.showReplace.setArrowType(Qt.RightArrow)
+        self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
         self.showReplace.setCheckable(True)
         self.showReplace.toggled.connect(self._doToggleReplace)
 
@@ -2322,8 +2466,8 @@ class GuiDocEditSearch(QFrame):
         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.AlignLeft)
-        self.mainBox.addWidget(self.searchOpt,     0, 2, 1, 3, Qt.AlignRight)
+        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.showReplace,   1, 0, 1, 1)
         self.mainBox.addWidget(self.searchBox,     1, 1, 1, 2)
         self.mainBox.addWidget(self.searchButton,  1, 3, 1, 1)
@@ -2353,9 +2497,94 @@ class GuiDocEditSearch(QFrame):
 
         return
 
-    def updateTheme(self):
-        """Update theme elements.
+    ##
+    #  Properties
+    ##
+
+    @property
+    def searchText(self) -> str:
+        """Return the current search text."""
+        return self.searchBox.text()
+
+    @property
+    def replaceText(self) -> str:
+        """Return the current replace text."""
+        return self.replaceBox.text()
+
+    ##
+    #  Getters
+    ##
+
+    def getSearchObject(self) -> str | QRegularExpression | QRegExp:
+        """Return the current search text either as text or as a regular
+        expression object.
+        """
+        text = self.searchBox.text()
+        if self.isRegEx:
+            # 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:
+                    rxOpt |= QRegularExpression.PatternOption.CaseInsensitiveOption
+                regEx = QRegularExpression(text, rxOpt)
+                self._alertSearchValid(regEx.isValid())
+                return regEx
+            else:  # pragma: no cover
+                # >= 50300 to < 51300
+                if self.isCaseSense:
+                    rxOpt = Qt.CaseSensitivity.CaseSensitive
+                else:
+                    rxOpt = Qt.CaseSensitivity.CaseInsensitive
+                regEx = QRegExp(text, rxOpt)
+                self._alertSearchValid(regEx.isValid())
+                return regEx
+
+        return text
+
+    ##
+    #  Setters
+    ##
+
+    def setSearchText(self, text: str | None) -> None:
+        """Open the search bar and set the search text to the text
+        provided, if any.
         """
+        if not self.isVisible():
+            self.setVisible(True)
+        if text is not None:
+            self.searchBox.setText(text)
+        self.searchBox.setFocus()
+        self.searchBox.selectAll()
+        if self.isRegEx:
+            self._alertSearchValid(True)
+        return
+
+    def setReplaceText(self, text: str) -> None:
+        """Set the replace text."""
+        self.showReplace.setChecked(True)
+        self.replaceBox.setFocus()
+        self.replaceBox.setText(text)
+        return
+
+    def setResultCount(self, currRes: int | None, resCount: int | None) -> None:
+        """Set the count values for the current search."""
+        sCurrRes = "?" if currRes is None else str(currRes)
+        sResCount = "?" if resCount is None else "1000+" if resCount > 1000 else str(resCount)
+        minWidth = SHARED.theme.getTextWidth(f"{sResCount}//{sResCount}", self.boxFont)
+        self.resultLabel.setText(f"{sCurrRes}/{sResCount}")
+        self.resultLabel.setMinimumWidth(minWidth)
+        self.adjustSize()
+        self.docEditor.updateDocMargins()
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def updateTheme(self) -> None:
+        """Update theme elements."""
         qPalette = qApp.palette()
         self.setPalette(qPalette)
         self.searchBox.setPalette(qPalette)
@@ -2396,9 +2625,8 @@ class GuiDocEditSearch(QFrame):
 
         return
 
-    def closeSearch(self):
-        """Close the search box.
-        """
+    def closeSearch(self) -> None:
+        """Close the search box."""
         CONFIG.searchCase = self.isCaseSense
         CONFIG.searchWord = self.isWholeWord
         CONFIG.searchRegEx = self.isRegEx
@@ -2413,7 +2641,7 @@ class GuiDocEditSearch(QFrame):
 
         return
 
-    def cycleFocus(self, toNext):
+    def cycleFocus(self, next: bool) -> bool:
         """The tab key just alternates focus between the two input
         boxes, if the replace box is visible.
         """
@@ -2426,184 +2654,96 @@ class GuiDocEditSearch(QFrame):
                 return True
         return False
 
-    def anyFocus(self):
-        """Return True if any of the input boxes have focus.
-        """
+    def anyFocus(self) -> bool:
+        """Return True if any of the input boxes have focus."""
         return self.searchBox.hasFocus() | self.replaceBox.hasFocus()
 
     ##
-    #  Get and Set Functions
-    ##
-
-    def setSearchText(self, theText):
-        """Open the search bar and set the search text to the text
-        provided, if any.
-        """
-        if not self.isVisible():
-            self.setVisible(True)
-        if theText is not None:
-            self.searchBox.setText(theText)
-        self.searchBox.setFocus()
-        self.searchBox.selectAll()
-        if self.isRegEx:
-            self._alertSearchValid(True)
-        return True
-
-    def setReplaceText(self, theText):
-        """Set the replace text.
-        """
-        self.showReplace.setChecked(True)
-        self.replaceBox.setFocus()
-        self.replaceBox.setText(theText)
-        return True
-
-    def setResultCount(self, currRes, resCount):
-        """Set the count values for the current search.
-        """
-        currRes = "?" if currRes is None else currRes
-        resCount = "?" if resCount is None else "1000+" if resCount > 1000 else resCount
-        minWidth = SHARED.theme.getTextWidth(f"{resCount}//{resCount}", self.boxFont)
-        self.resultLabel.setText(f"{currRes}/{resCount}")
-        self.resultLabel.setMinimumWidth(minWidth)
-        self.adjustSize()
-        self.docEditor.updateDocMargins()
-        return
-
-    def getSearchObject(self):
-        """Return the current search text either as text or as a regular
-        expression object.
-        """
-        theText = self.searchBox.text()
-        if self.isRegEx:
-            # 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.UseUnicodePropertiesOption
-                if not self.isCaseSense:
-                    rxOpt |= QRegularExpression.CaseInsensitiveOption
-                theRegEx = QRegularExpression(theText, rxOpt)
-                self._alertSearchValid(theRegEx.isValid())
-                return theRegEx
-
-            else:  # pragma: no cover
-                # >= 50300 to < 51300
-                if self.isCaseSense:
-                    rxOpt = Qt.CaseSensitive
-                else:
-                    rxOpt = Qt.CaseInsensitive
-                theRegEx = QRegExp(theText, rxOpt)
-                self._alertSearchValid(theRegEx.isValid())
-                return theRegEx
-
-        return theText
-
-    def getSearchText(self):
-        """Return the current search text.
-        """
-        return self.searchBox.text()
-
-    def getReplaceText(self):
-        """Return the current replace text.
-        """
-        return self.replaceBox.text()
-
-    ##
-    #  Slots
+    #  Private Slots
     ##
 
     @pyqtSlot()
-    def _doClose(self):
-        """Hide the search/replace bar.
-        """
+    def _doClose(self) -> None:
+        """Hide the search/replace bar."""
         self.closeSearch()
         return
 
     @pyqtSlot()
-    def _doSearch(self):
-        """Call the search action function for the document editor.
-        """
+    def _doSearch(self) -> None:
+        """Call the search action function for the document editor."""
         modKey = qApp.keyboardModifiers()
-        if modKey == Qt.ShiftModifier:
+        if modKey == Qt.KeyboardModifier.ShiftModifier:
             self.docEditor.findNext(goBack=True)
         else:
             self.docEditor.findNext()
         return
 
     @pyqtSlot()
-    def _doReplace(self):
-        """Call the replace action function for the document editor.
-        """
+    def _doReplace(self) -> None:
+        """Call the replace action function for the document editor."""
         self.docEditor.replaceNext()
         return
 
     @pyqtSlot(bool)
-    def _doToggleReplace(self, theState):
-        """Toggle the show/hide of the replace box.
-        """
-        if theState:
-            self.showReplace.setArrowType(Qt.DownArrow)
+    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.RightArrow)
-        self.replaceBox.setVisible(theState)
-        self.replaceButton.setVisible(theState)
-        self.repVisible = theState
+            self.showReplace.setArrowType(Qt.ArrowType.RightArrow)
+        self.replaceBox.setVisible(state)
+        self.replaceButton.setVisible(state)
+        self.repVisible = state
         self.adjustSize()
         self.docEditor.updateDocMargins()
         return
 
     @pyqtSlot(bool)
-    def _doToggleCase(self, theState):
-        """Enable/disable case sensitive mode.
-        """
-        self.isCaseSense = theState
+    def _doToggleCase(self, state: bool) -> None:
+        """Enable/disable case sensitive mode."""
+        self.isCaseSense = state
         return
 
     @pyqtSlot(bool)
-    def _doToggleWord(self, theState):
-        """Enable/disable whole word search mode.
-        """
-        self.isWholeWord = theState
+    def _doToggleWord(self, state: bool) -> None:
+        """Enable/disable whole word search mode."""
+        self.isWholeWord = state
         return
 
     @pyqtSlot(bool)
-    def _doToggleRegEx(self, theState):
-        """Enable/disable regular expression search mode.
-        """
-        self.isRegEx = theState
+    def _doToggleRegEx(self, state: bool) -> None:
+        """Enable/disable regular expression search mode."""
+        self.isRegEx = state
         return
 
     @pyqtSlot(bool)
-    def _doToggleLoop(self, theState):
-        """Enable/disable looping the search.
-        """
-        self.doLoop = theState
+    def _doToggleLoop(self, state: bool) -> None:
+        """Enable/disable looping the search."""
+        self.doLoop = state
         return
 
     @pyqtSlot(bool)
-    def _doToggleProject(self, theState):
-        """Enable/disable continuing search in next project file.
-        """
-        self.doNextFile = theState
+    def _doToggleProject(self, state: bool) -> None:
+        """Enable/disable continuing search in next project file."""
+        self.doNextFile = state
         return
 
     @pyqtSlot(bool)
-    def _doToggleMatchCap(self, theState):
-        """Enable/disable preserving capitalisation when replacing.
-        """
-        self.doMatchCap = theState
+    def _doToggleMatchCap(self, state: bool) -> None:
+        """Enable/disable preserving capitalisation when replacing."""
+        self.doMatchCap = state
         return
 
     ##
     #  Internal Functions
     ##
 
-    def _alertSearchValid(self, isValid):
+    def _alertSearchValid(self, isValid: bool) -> None:
         """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.Base, self.rxCol[isValid])
+        qPalette.setColor(QPalette.ColorRole.Base, self.rxCol[isValid])
         self.searchBox.setPalette(qPalette)
         return
 
@@ -2617,7 +2757,10 @@ class GuiDocEditSearch(QFrame):
 
 class GuiDocEditHeader(QWidget):
 
-    def __init__(self, docEditor):
+    closeDocumentRequest = pyqtSignal()
+    toggleToolBarRequest = pyqtSignal()
+
+    def __init__(self, docEditor: GuiDocEditor) -> None:
         super().__init__(parent=docEditor)
 
         logger.debug("Create: GuiDocEditHeader")
@@ -2629,67 +2772,68 @@ class GuiDocEditHeader(QWidget):
 
         fPx = int(0.9*SHARED.theme.fontPixelSize)
         hSp = CONFIG.pxInt(6)
+        iconSize = QSize(fPx, fPx)
 
         # Main Widget Settings
         self.setAutoFillBackground(True)
 
         # Title Label
-        self.theTitle = QLabel()
-        self.theTitle.setText("")
-        self.theTitle.setIndent(0)
-        self.theTitle.setMargin(0)
-        self.theTitle.setContentsMargins(0, 0, 0, 0)
-        self.theTitle.setAutoFillBackground(True)
-        self.theTitle.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
-        self.theTitle.setFixedHeight(fPx)
-
-        lblFont = self.theTitle.font()
+        self.itemTitle = QLabel()
+        self.itemTitle.setText("")
+        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)
+
+        lblFont = self.itemTitle.font()
         lblFont.setPointSizeF(0.9*SHARED.theme.fontPointSize)
-        self.theTitle.setFont(lblFont)
+        self.itemTitle.setFont(lblFont)
 
         # Buttons
-        self.editButton = QToolButton(self)
-        self.editButton.setContentsMargins(0, 0, 0, 0)
-        self.editButton.setIconSize(QSize(fPx, fPx))
-        self.editButton.setFixedSize(fPx, fPx)
-        self.editButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
-        self.editButton.setVisible(False)
-        self.editButton.setToolTip(self.tr("Edit document label"))
-        self.editButton.clicked.connect(self._editDocument)
+        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.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(QSize(fPx, fPx))
+        self.searchButton.setIconSize(iconSize)
         self.searchButton.setFixedSize(fPx, fPx)
-        self.searchButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.searchButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.searchButton.setVisible(False)
-        self.searchButton.setToolTip(self.tr("Search document"))
-        self.searchButton.clicked.connect(self._searchDocument)
+        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(QSize(fPx, fPx))
+        self.minmaxButton.setIconSize(iconSize)
         self.minmaxButton.setFixedSize(fPx, fPx)
-        self.minmaxButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.minmaxButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.minmaxButton.setVisible(False)
         self.minmaxButton.setToolTip(self.tr("Toggle Focus Mode"))
-        self.minmaxButton.clicked.connect(self._minmaxDocument)
+        self.minmaxButton.clicked.connect(lambda: self.docEditor.toggleFocusModeRequest.emit())
 
         self.closeButton = QToolButton(self)
         self.closeButton.setContentsMargins(0, 0, 0, 0)
-        self.closeButton.setIconSize(QSize(fPx, fPx))
+        self.closeButton.setIconSize(iconSize)
         self.closeButton.setFixedSize(fPx, fPx)
-        self.closeButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.closeButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
         self.closeButton.setVisible(False)
-        self.closeButton.setToolTip(self.tr("Close the document"))
+        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.editButton, 0)
+        self.outerBox.addWidget(self.tbButton, 0)
         self.outerBox.addWidget(self.searchButton, 0)
-        self.outerBox.addWidget(self.theTitle, 1)
+        self.outerBox.addWidget(self.itemTitle, 1)
         self.outerBox.addWidget(self.minmaxButton, 0)
         self.outerBox.addWidget(self.closeButton, 0)
         self.setLayout(self.outerBox)
@@ -2711,10 +2855,9 @@ class GuiDocEditHeader(QWidget):
     #  Methods
     ##
 
-    def updateTheme(self):
-        """Update theme elements.
-        """
-        self.editButton.setIcon(SHARED.theme.getIcon("edit"))
+    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"))
@@ -2724,7 +2867,7 @@ class GuiDocEditHeader(QWidget):
             "QToolButton:hover {{border: none; background: rgba({0},{1},{2},0.2);}}"
         ).format(*SHARED.theme.colText)
 
-        self.editButton.setStyleSheet(buttonStyle)
+        self.tbButton.setStyleSheet(buttonStyle)
         self.searchButton.setStyleSheet(buttonStyle)
         self.minmaxButton.setStyleSheet(buttonStyle)
         self.closeButton.setStyleSheet(buttonStyle)
@@ -2733,28 +2876,28 @@ class GuiDocEditHeader(QWidget):
 
         return
 
-    def matchColours(self):
+    def matchColours(self) -> None:
         """Update the colours of the widget to match those of the syntax
         theme rather than the main GUI.
         """
-        thePalette = QPalette()
-        thePalette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        thePalette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
-        thePalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        palette = QPalette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
 
-        self.setPalette(thePalette)
-        self.theTitle.setPalette(thePalette)
+        self.setPalette(palette)
+        self.itemTitle.setPalette(palette)
 
         return
 
-    def setTitleFromHandle(self, tHandle):
+    def setTitleFromHandle(self, tHandle: str | None) -> bool:
         """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.theTitle.setText("")
-            self.editButton.setVisible(False)
+            self.itemTitle.setText("")
+            self.tbButton.setVisible(False)
             self.searchButton.setVisible(False)
             self.closeButton.setVisible(False)
             self.minmaxButton.setVisible(False)
@@ -2769,21 +2912,21 @@ class GuiDocEditHeader(QWidget):
                 if nwItem is not None:
                     tTitle.append(nwItem.itemName)
             sSep = "  %s  " % nwUnicode.U_RSAQUO
-            self.theTitle.setText(sSep.join(tTitle))
+            self.itemTitle.setText(sSep.join(tTitle))
         else:
             nwItem = pTree[tHandle]
             if nwItem is None:
                 return False
-            self.theTitle.setText(nwItem.itemName)
+            self.itemTitle.setText(nwItem.itemName)
 
-        self.editButton.setVisible(True)
+        self.tbButton.setVisible(True)
         self.searchButton.setVisible(True)
         self.closeButton.setVisible(True)
         self.minmaxButton.setVisible(True)
 
         return True
 
-    def updateFocusMode(self):
+    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.
@@ -2795,50 +2938,29 @@ class GuiDocEditHeader(QWidget):
         return
 
     ##
-    #  Slots
+    #  Private Slots
     ##
 
     @pyqtSlot()
-    def _editDocument(self):
-        """Open the edit item dialog from the main GUI.
-        """
-        self.mainGui.editItemLabel(self._docHandle)
-        return
-
-    @pyqtSlot()
-    def _searchDocument(self):
-        """Toggle the visibility of the search box.
-        """
-        self.docEditor.toggleSearch()
-        return
-
-    @pyqtSlot()
-    def _closeDocument(self):
-        """Trigger the close editor on the main window.
-        """
-        self.mainGui.closeDocEditor()
-        self.editButton.setVisible(False)
+    def _closeDocument(self) -> None:
+        """Trigger the close editor on the main window."""
+        self.closeDocumentRequest.emit()
+        self.tbButton.setVisible(False)
         self.searchButton.setVisible(False)
         self.closeButton.setVisible(False)
         self.minmaxButton.setVisible(False)
         return
 
-    @pyqtSlot()
-    def _minmaxDocument(self):
-        """Switch on or off Focus Mode.
-        """
-        self.mainGui.toggleFocusMode()
-        return
-
     ##
     #  Events
     ##
 
-    def mousePressEvent(self, theEvent):
+    def mousePressEvent(self, event: QMouseEvent):
         """Capture a click on the title and ensure that the item is
         selected in the project tree.
         """
-        self.mainGui.projView.setSelectedHandle(self._docHandle, doScroll=True)
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.docEditor.requestProjectItemSelected.emit(self._docHandle, True)
         return
 
 # END Class GuiDocEditHeader
@@ -2851,15 +2973,14 @@ class GuiDocEditHeader(QWidget):
 
 class GuiDocEditFooter(QWidget):
 
-    def __init__(self, docEditor):
+    def __init__(self, docEditor: GuiDocEditor) -> None:
         super().__init__(parent=docEditor)
 
         logger.debug("Create: GuiDocEditFooter")
 
         self.docEditor = docEditor
-        self.mainGui   = docEditor.mainGui
 
-        self._theItem   = None
+        self._tItem     = None
         self._docHandle = None
 
         self._docSelection = False
@@ -2876,11 +2997,13 @@ class GuiDocEditFooter(QWidget):
         self.setContentsMargins(0, 0, 0, 0)
         self.setAutoFillBackground(True)
 
+        alLeftTop = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop
+
         # Status
         self.statusIcon = QLabel("")
         self.statusIcon.setContentsMargins(0, 0, 0, 0)
         self.statusIcon.setFixedHeight(self.sPx)
-        self.statusIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.statusIcon.setAlignment(alLeftTop)
 
         self.statusText = QLabel(self.tr("Status"))
         self.statusText.setIndent(0)
@@ -2888,14 +3011,14 @@ class GuiDocEditFooter(QWidget):
         self.statusText.setContentsMargins(0, 0, 0, 0)
         self.statusText.setAutoFillBackground(True)
         self.statusText.setFixedHeight(fPx)
-        self.statusText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.statusText.setAlignment(alLeftTop)
         self.statusText.setFont(lblFont)
 
         # Lines
         self.linesIcon = QLabel("")
         self.linesIcon.setContentsMargins(0, 0, 0, 0)
         self.linesIcon.setFixedHeight(self.sPx)
-        self.linesIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.linesIcon.setAlignment(alLeftTop)
 
         self.linesText = QLabel("")
         self.linesText.setIndent(0)
@@ -2903,14 +3026,14 @@ class GuiDocEditFooter(QWidget):
         self.linesText.setContentsMargins(0, 0, 0, 0)
         self.linesText.setAutoFillBackground(True)
         self.linesText.setFixedHeight(fPx)
-        self.linesText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.linesText.setAlignment(alLeftTop)
         self.linesText.setFont(lblFont)
 
         # Words
         self.wordsIcon = QLabel("")
         self.wordsIcon.setContentsMargins(0, 0, 0, 0)
         self.wordsIcon.setFixedHeight(self.sPx)
-        self.wordsIcon.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.wordsIcon.setAlignment(alLeftTop)
 
         self.wordsText = QLabel("")
         self.wordsText.setIndent(0)
@@ -2918,7 +3041,7 @@ class GuiDocEditFooter(QWidget):
         self.wordsText.setContentsMargins(0, 0, 0, 0)
         self.wordsText.setAutoFillBackground(True)
         self.wordsText.setFixedHeight(fPx)
-        self.wordsText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.wordsText.setAlignment(alLeftTop)
         self.wordsText.setFont(lblFont)
 
         # Assemble Layout
@@ -2954,41 +3077,37 @@ class GuiDocEditFooter(QWidget):
     #  Methods
     ##
 
-    def updateTheme(self):
-        """Update theme elements.
-        """
+    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)))
-
         self.matchColours()
-
         return
 
-    def matchColours(self):
+    def matchColours(self) -> None:
         """Update the colours of the widget to match those of the syntax
         theme rather than the main GUI.
         """
-        thePalette = QPalette()
-        thePalette.setColor(QPalette.Window, QColor(*SHARED.theme.colBack))
-        thePalette.setColor(QPalette.WindowText, QColor(*SHARED.theme.colText))
-        thePalette.setColor(QPalette.Text, QColor(*SHARED.theme.colText))
+        palette = QPalette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(*SHARED.theme.colBack))
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(*SHARED.theme.colText))
+        palette.setColor(QPalette.ColorRole.Text, QColor(*SHARED.theme.colText))
 
-        self.setPalette(thePalette)
-        self.statusText.setPalette(thePalette)
-        self.linesText.setPalette(thePalette)
-        self.wordsText.setPalette(thePalette)
+        self.setPalette(palette)
+        self.statusText.setPalette(palette)
+        self.linesText.setPalette(palette)
+        self.wordsText.setPalette(palette)
 
         return
 
-    def setHandle(self, tHandle):
-        """Set the handle that will populate the footer's data.
-        """
+    def setHandle(self, tHandle: str | None) -> None:
+        """Set the handle that will populate the footer's data."""
         self._docHandle = tHandle
         if self._docHandle is None:
             logger.debug("No handle set, so clearing the editor footer")
-            self._theItem = None
+            self._tItem = None
         else:
-            self._theItem = SHARED.project.tree[self._docHandle]
+            self._tItem = SHARED.project.tree[self._docHandle]
 
         self.setHasSelection(False)
         self.updateInfo()
@@ -2996,49 +3115,44 @@ class GuiDocEditFooter(QWidget):
 
         return
 
-    def setHasSelection(self, hasSelection):
+    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):
-        """Update the content of text labels.
-        """
-        if self._theItem is None:
+    def updateInfo(self) -> None:
+        """Update the content of text labels."""
+        if self._tItem is None:
             sIcon = QPixmap()
             sText = ""
         else:
-            theStatus, theIcon = self._theItem.getImportStatus(incIcon=True)
-            sIcon = theIcon.pixmap(self.sPx, self.sPx)
-            sText = f"{theStatus} / {self._theItem.describeMe()}"
+            status, icon = self._tItem.getImportStatus(incIcon=True)
+            sIcon = icon.pixmap(self.sPx, self.sPx)
+            sText = f"{status} / {self._tItem.describeMe()}"
 
         self.statusIcon.setPixmap(sIcon)
         self.statusText.setText(sText)
 
         return
 
-    def updateLineCount(self):
-        """Update the line counter.
-        """
-        if self._theItem is None:
+    def updateLineCount(self) -> None:
+        """Update the line counter."""
+        if self._tItem is None:
             iLine = 0
             iDist = 0
         else:
-            theCursor = self.docEditor.textCursor()
-            iLine = theCursor.blockNumber() + 1
-            iDist = 100*iLine/self.docEditor.document().blockCount()
-
+            cursor = self.docEditor.textCursor()
+            iLine = cursor.blockNumber() + 1
+            iDist = 100*iLine/self.docEditor._qDocument.blockCount()
         self.linesText.setText(
             self.tr("Line: {0} ({1})").format(f"{iLine:n}", f"{iDist:.0f} %")
         )
-
         return
 
-    def updateCounts(self, wCount=None, cCount=None):
-        """Select which word count display mode to use.
-        """
+    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:
@@ -3049,40 +3163,36 @@ class GuiDocEditFooter(QWidget):
     #  Internal Functions
     ##
 
-    def _updateWordCounts(self):
-        """Update the word count for the whole document.
-        """
-        if self._theItem is None:
+    def _updateWordCounts(self) -> None:
+        """Update the word count for the whole document."""
+        if self._tItem is None:
             wCount = 0
             wDiff = 0
         else:
-            wCount = self._theItem.wordCount
-            wDiff = wCount - self._theItem.initCount
+            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.document().characterCount()
+        byteSize = self.docEditor._qDocument.characterCount()
         self.wordsText.setToolTip(
             self.tr("Document size is {0} bytes").format(f"{byteSize:n}")
         )
 
         return
 
-    def _updateSelectionWordCounts(self, wCount, cCount):
-        """Update the word count for a selection.
-        """
+    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}")
         )
-
         return
 
 # END Class GuiDocEditFooter